aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Makefile8
-rw-r--r--README.md5
-rw-r--r--changelog.md5
-rw-r--r--source/Common.cpp35
-rw-r--r--source/Common.hpp1
-rw-r--r--source/Key.cpp35
-rw-r--r--source/KeyCollection.cpp16
-rw-r--r--source/KeyLocation.cpp3
-rw-r--r--source/mbedtls/.gitignore28
-rw-r--r--source/mbedtls/LICENSE2
-rw-r--r--source/mbedtls/README.md218
-rw-r--r--source/mbedtls/gpl-2.0.txt339
-rw-r--r--source/mbedtls/include/.gitignore4
-rw-r--r--source/mbedtls/include/CMakeLists.txt16
-rw-r--r--source/mbedtls/include/mbedtls/aes.h628
-rw-r--r--source/mbedtls/include/mbedtls/check_config.h685
-rw-r--r--source/mbedtls/include/mbedtls/cipher.h808
-rw-r--r--source/mbedtls/include/mbedtls/cipher_internal.h127
-rw-r--r--source/mbedtls/include/mbedtls/cmac.h208
-rw-r--r--source/mbedtls/include/mbedtls/config.h49
-rw-r--r--source/mbedtls/include/mbedtls/platform_util.h64
-rw-r--r--source/mbedtls/lib/.gitignore4
-rw-r--r--source/mbedtls/lib/CMakeLists.txt181
-rw-r--r--source/mbedtls/lib/Makefile46
-rw-r--r--source/mbedtls/lib/aes.c2125
-rw-r--r--source/mbedtls/lib/cipher.c1108
-rw-r--r--source/mbedtls/lib/cipher_wrap.c2274
-rw-r--r--source/mbedtls/lib/cmac.c1080
-rw-r--r--source/mbedtls/lib/platform_util.c69
-rw-r--r--source/sha256.c113
-rw-r--r--source/sha256.h36
-rw-r--r--source/sha256_armv8.s163
32 files changed, 32 insertions, 10451 deletions
diff --git a/Makefile b/Makefile
index fae9b9a..47e5323 100644
--- a/Makefile
+++ b/Makefile
@@ -32,7 +32,7 @@ include $(DEVKITPRO)/libnx/switch_rules
32#--------------------------------------------------------------------------------- 32#---------------------------------------------------------------------------------
33APP_TITLE := Lockpick 33APP_TITLE := Lockpick
34APP_AUTHOR := shchmue 34APP_AUTHOR := shchmue
35APP_VERSION := 1.2.2 35APP_VERSION := 1.2.3
36 36
37TARGET := $(subst $e ,_,$(notdir $(APP_TITLE))) 37TARGET := $(subst $e ,_,$(notdir $(APP_TITLE)))
38BUILD := build 38BUILD := build
@@ -58,13 +58,13 @@ CXXFLAGS := $(CFLAGS) -std=gnu++17 -fno-rtti -fno-exceptions
58ASFLAGS := -g $(ARCH) 58ASFLAGS := -g $(ARCH)
59LDFLAGS = -specs=$(DEVKITPRO)/libnx/switch.specs -g $(ARCH) -Wl,-Map,$(notdir $*.map) 59LDFLAGS = -specs=$(DEVKITPRO)/libnx/switch.specs -g $(ARCH) -Wl,-Map,$(notdir $*.map)
60 60
61LIBS := -lnx -lmbedcrypto -lstdc++fs `freetype-config --libs` 61LIBS := -lnx -lstdc++fs `freetype-config --libs`
62 62
63#--------------------------------------------------------------------------------- 63#---------------------------------------------------------------------------------
64# list of directories containing libraries, this must be the top level containing 64# list of directories containing libraries, this must be the top level containing
65# include and lib 65# include and lib
66#--------------------------------------------------------------------------------- 66#---------------------------------------------------------------------------------
67LIBDIRS := $(PORTLIBS) $(LIBNX) $(TOPDIR)/source/mbedtls 67LIBDIRS := $(PORTLIBS) $(LIBNX)
68 68
69 69
70#--------------------------------------------------------------------------------- 70#---------------------------------------------------------------------------------
@@ -150,13 +150,11 @@ all: $(BUILD)
150 150
151$(BUILD): 151$(BUILD):
152 @[ -d $@ ] || mkdir -p $@ $(BUILD) $(OUTDIR) 152 @[ -d $@ ] || mkdir -p $@ $(BUILD) $(OUTDIR)
153 $(MAKE) -C source/mbedtls/lib all
154 @$(MAKE) --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile 153 @$(MAKE) --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile
155 154
156#--------------------------------------------------------------------------------- 155#---------------------------------------------------------------------------------
157clean: 156clean:
158 @echo clean ... 157 @echo clean ...
159 $(MAKE) -C source/mbedtls/lib clean
160 @rm -fr $(BUILD) $(OUTDIR) $(TARGET).pfs0 $(TARGET).nso $(TARGET).nro $(TARGET).nacp $(TARGET).elf 158 @rm -fr $(BUILD) $(OUTDIR) $(TARGET).pfs0 $(TARGET).nso $(TARGET).nro $(TARGET).nacp $(TARGET).elf
161 159
162 160
diff --git a/README.md b/README.md
index e8fec5b..4ea1fda 100644
--- a/README.md
+++ b/README.md
@@ -36,7 +36,7 @@ Notes
36 36
37Building 37Building
38= 38=
39Release built with `libnx v2.0.0` but still builds and runs with `v1.6.0`. 39Release built with [libnx commit d2e2c15](https://github.com/switchbrew/libnx/tree/d2e2c159374f18c22350846019f2a615cb35b523).
40 40
41Uses `freetype` which comes with `switch-portlibs` via `devkitPro pacman`: 41Uses `freetype` which comes with `switch-portlibs` via `devkitPro pacman`:
42``` 42```
@@ -59,13 +59,12 @@ Special Thanks
59* Shouts out to fellow key derivers: shadowninja108 for [HACGUI](https://github.com/shadowninja108/HACGUI), Thealexbarney for [Libhac](https://github.com/Thealexbarney/LibHac), and [rajkosto](https://github.com/rajkosto/) :eyes: 59* Shouts out to fellow key derivers: shadowninja108 for [HACGUI](https://github.com/shadowninja108/HACGUI), Thealexbarney for [Libhac](https://github.com/Thealexbarney/LibHac), and [rajkosto](https://github.com/rajkosto/) :eyes:
60* [misson2000](https://github.com/misson20000) for help with `std::invoke` to get the function timer working 60* [misson2000](https://github.com/misson20000) for help with `std::invoke` to get the function timer working
61* [Simon](https://github.com/simontime) for the `eticket_rsa_kek` derivation method and for suggesting invoking `spl` for faster titlekey derivation 61* [Simon](https://github.com/simontime) for the `eticket_rsa_kek` derivation method and for suggesting invoking `spl` for faster titlekey derivation
62* [SciresM](https://github.com/SciresM) for the libnx aes library
62* The constantly-improving docs on [Switchbrew wiki](https://switchbrew.org/wiki/) and [libnx](https://switchbrew.github.io/libnx/files.html) 63* The constantly-improving docs on [Switchbrew wiki](https://switchbrew.org/wiki/) and [libnx](https://switchbrew.github.io/libnx/files.html)
63* Literally the friends I made along the way! I came to the scene late and I've still managed to meet some wonderful people :) Thanks for all the help testing, making suggestions, and cheerleading! 64* Literally the friends I made along the way! I came to the scene late and I've still managed to meet some wonderful people :) Thanks for all the help testing, making suggestions, and cheerleading!
64 65
65Licenses 66Licenses
66= 67=
67* `AES` functions are from [mbedtls 2.13.0](https://tls.mbed.org/) licensed under [GPLv2](source/mbedtls/gpl-2.0.txt)
68* Aarch64 assembly `sha256` is from [Atmosphère](https://github.com/atmosphere-NX/Atmosphere) licensed under [GPLv2](https://github.com/Atmosphere-NX/Atmosphere/blob/master/LICENSE)
69* `es` ipc code is from [Tinfoil](https://github.com/Adubbz/Tinfoil) licensed under [MIT](https://github.com/Adubbz/Tinfoil/blob/master/LICENSE) 68* `es` ipc code is from [Tinfoil](https://github.com/Adubbz/Tinfoil) licensed under [MIT](https://github.com/Adubbz/Tinfoil/blob/master/LICENSE)
70* `FatFs R0.13c` is located [here](http://elm-chan.org/fsw/ff/00index_e.html) and is licensed under its own [BSD-style license](source/fatfs/LICENSE.txt) 69* `FatFs R0.13c` is located [here](http://elm-chan.org/fsw/ff/00index_e.html) and is licensed under its own [BSD-style license](source/fatfs/LICENSE.txt)
71* Simple `xxHash` implementation is from [stbrumme](https://github.com/stbrumme/xxhash) licensed under [MIT](https://github.com/stbrumme/xxhash/blob/master/LICENSE) 70* Simple `xxHash` implementation is from [stbrumme](https://github.com/stbrumme/xxhash) licensed under [MIT](https://github.com/stbrumme/xxhash/blob/master/LICENSE)
diff --git a/changelog.md b/changelog.md
index 0f6edd0..adc96b4 100644
--- a/changelog.md
+++ b/changelog.md
@@ -1,4 +1,9 @@
1# Changelog 1# Changelog
2## Version 1.2.3
3* Remove mbedtls dependency in favor of new libnx crypto library
4* Remove libnx 1.6.0 support since crypto requires later commit
5* Skip contradictory messaging if skipping keyfile save
6
2## Version 1.2.2 7## Version 1.2.2
3* Do not overwrite existing keyfile that contains master_key_07 8* Do not overwrite existing keyfile that contains master_key_07
4* Read eticket_rsa_kek from existing keyfile in case user is only running this for titlekeys 9* Read eticket_rsa_kek from existing keyfile in case user is only running this for titlekeys
diff --git a/source/Common.cpp b/source/Common.cpp
index d0e5097..e8fa6ba 100644
--- a/source/Common.cpp
+++ b/source/Common.cpp
@@ -32,18 +32,10 @@
32 32
33#include <switch.h> 33#include <switch.h>
34 34
35#include "sha256.h"
36
37#ifdef RGBX8
38 #define LIBNX_200
39#endif
40
41namespace Common { 35namespace Common {
42 static u32 framebuf_width = 0; 36 static u32 framebuf_width = 0;
43#ifdef LIBNX_200
44 static Framebuffer fb; 37 static Framebuffer fb;
45 static u32 stride; 38 static u32 stride;
46#endif
47 static u32 *framebuf; 39 static u32 *framebuf;
48 // FreeType vars 40 // FreeType vars
49 static FT_Library library; 41 static FT_Library library;
@@ -119,28 +111,19 @@ namespace Common {
119 111
120 PlFontData font; 112 PlFontData font;
121 113
122#ifndef LIBNX_200
123 consoleInit(NULL);
124#endif
125
126 plGetSharedFontByType(&font, PlSharedFontType_Standard); 114 plGetSharedFontByType(&font, PlSharedFontType_Standard);
127 115
128 FT_Init_FreeType(&library); 116 FT_Init_FreeType(&library);
129 FT_New_Memory_Face(library, static_cast<FT_Byte *>(font.address), font.size, 0, &face); 117 FT_New_Memory_Face(library, static_cast<FT_Byte *>(font.address), font.size, 0, &face);
130 FT_Set_Char_Size(face, 0, 6*64, 300, 300); 118 FT_Set_Char_Size(face, 0, 6*64, 300, 300);
131 119
132#ifdef LIBNX_200
133 framebufferCreate(&fb, nwindowGetDefault(), FB_WIDTH, FB_HEIGHT, PIXEL_FORMAT_RGBA_8888, 2); 120 framebufferCreate(&fb, nwindowGetDefault(), FB_WIDTH, FB_HEIGHT, PIXEL_FORMAT_RGBA_8888, 2);
134 framebufferMakeLinear(&fb); 121 framebufferMakeLinear(&fb);
135 framebuf = (u32 *)framebufferBegin(&fb, &stride); 122 framebuf = (u32 *)framebufferBegin(&fb, &stride);
136 framebuf_width = stride / sizeof(u32); 123 framebuf_width = stride / sizeof(u32);
137 memset(framebuf, 0, stride*FB_HEIGHT); 124 memset(framebuf, 0, stride*FB_HEIGHT);
138 framebufferEnd(&fb); 125 framebufferEnd(&fb);
139#else 126
140 gfxSetMode(GfxMode_LinearDouble);
141 framebuf = (u32 *)gfxGetFramebuffer(&framebuf_width, NULL);
142 memset(framebuf, 0, gfxGetFramebufferSize());
143#endif
144 draw_text(0x010, 0x020, YELLOW, "Lockpick! by shchmue"); 127 draw_text(0x010, 0x020, YELLOW, "Lockpick! by shchmue");
145 draw_text(0x190, 0x020, YELLOW, "Note: This can only dump keys 00-05 (or 00-06 on 6.2.0)"); 128 draw_text(0x190, 0x020, YELLOW, "Note: This can only dump keys 00-05 (or 00-06 on 6.2.0)");
146 draw_text(0x190, 0x040, YELLOW, "Use Lockpick_RCM for newer keys on firmware 7.0.0+!"); 129 draw_text(0x190, 0x040, YELLOW, "Use Lockpick_RCM for newer keys on firmware 7.0.0+!");
@@ -229,11 +212,7 @@ namespace Common {
229 update_display(); 212 update_display();
230 } 213 }
231 214
232#ifdef LIBNX_200
233 framebufferClose(&fb); 215 framebufferClose(&fb);
234#else
235 consoleExit(NULL);
236#endif
237 FT_Done_Face(face); 216 FT_Done_Face(face);
238 FT_Done_FreeType(library); 217 FT_Done_FreeType(library);
239 218
@@ -241,20 +220,8 @@ namespace Common {
241 } 220 }
242 221
243 void update_display() { 222 void update_display() {
244#ifdef LIBNX_200
245 framebufferBegin(&fb, &stride); 223 framebufferBegin(&fb, &stride);
246 framebufferEnd(&fb); 224 framebufferEnd(&fb);
247#else
248 consoleUpdate(NULL);
249#endif
250 }
251
252 void sha256(const u8 *data, u8 *hash, size_t length) {
253 struct sha256_state ctx;
254 sha256_init(&ctx);
255 sha256_update(&ctx, data, length);
256 sha256_finalize(&ctx);
257 sha256_finish(&ctx, hash);
258 } 225 }
259 226
260 byte_vector key_string_to_byte_vector(std::string key_string) { 227 byte_vector key_string_to_byte_vector(std::string key_string) {
diff --git a/source/Common.hpp b/source/Common.hpp
index fe064ac..a06eb52 100644
--- a/source/Common.hpp
+++ b/source/Common.hpp
@@ -67,7 +67,6 @@ namespace Common {
67 // refresh display 67 // refresh display
68 void update_display(); 68 void update_display();
69 69
70 void sha256(const u8 *data, u8 *hash, size_t length);
71 // reads "<keyname> = <hexkey>" and returns byte vector 70 // reads "<keyname> = <hexkey>" and returns byte vector
72 byte_vector key_string_to_byte_vector(std::string key_string); 71 byte_vector key_string_to_byte_vector(std::string key_string);
73} \ No newline at end of file 72} \ No newline at end of file
diff --git a/source/Key.cpp b/source/Key.cpp
index 0145cb4..c3f72e6 100644
--- a/source/Key.cpp
+++ b/source/Key.cpp
@@ -19,12 +19,10 @@
19#include <algorithm> 19#include <algorithm>
20#include <vector> 20#include <vector>
21 21
22#include <mbedtls/aes.h>
23#include <mbedtls/cmac.h>
24
25#include "Common.hpp"
26#include "xxhash64.h" 22#include "xxhash64.h"
27 23
24#include <switch.h>
25
28size_t Key::saved_key_count = 0; 26size_t Key::saved_key_count = 0;
29 27
30Key::Key(std::string name, u64 xx_hash, byte_vector hash, u8 length, byte_vector key) : 28Key::Key(std::string name, u64 xx_hash, byte_vector hash, u8 length, byte_vector key) :
@@ -86,16 +84,9 @@ byte_vector Key::aes_decrypt_ctr(const byte_vector &data, byte_vector iv) {
86 if (!found()) 84 if (!found())
87 return dest; 85 return dest;
88 86
89 // used internally 87 Aes128CtrContext con;
90 size_t nc_off = 0; 88 aes128CtrContextCreate(&con, key.data(), iv.data());
91 u8 stream_block[0x10]; 89 aes128CtrCrypt(&con, dest.data(), data.data(), data.size());
92
93 mbedtls_aes_context dec;
94 mbedtls_aes_init(&dec);
95 mbedtls_aes_setkey_enc(&dec, key.data(), length * 8);
96 mbedtls_aes_crypt_ctr(&dec, data.size(), &nc_off, iv.data(), stream_block, data.data(), dest.data());
97 mbedtls_aes_free(&dec);
98
99 return dest; 90 return dest;
100} 91}
101 92
@@ -104,13 +95,10 @@ byte_vector Key::aes_decrypt_ecb(const byte_vector &data) {
104 if (!found()) 95 if (!found())
105 return dest; 96 return dest;
106 97
107 mbedtls_aes_context dec; 98 Aes128Context con;
108 mbedtls_aes_init(&dec); 99 aes128ContextCreate(&con, key.data(), false);
109 mbedtls_aes_setkey_dec(&dec, key.data(), length * 8);
110 for (size_t offset = 0; offset < data.size(); offset += 0x10) 100 for (size_t offset = 0; offset < data.size(); offset += 0x10)
111 mbedtls_aes_crypt_ecb(&dec, MBEDTLS_AES_DECRYPT, data.data() + offset, dest.data() + offset); 101 aes128DecryptBlock(&con, dest.data() + offset, data.data() + offset);
112 mbedtls_aes_free(&dec);
113
114 return dest; 102 return dest;
115} 103}
116 104
@@ -119,8 +107,7 @@ byte_vector Key::cmac(byte_vector data) {
119 if (!found()) 107 if (!found())
120 return dest; 108 return dest;
121 109
122 mbedtls_cipher_cmac(mbedtls_cipher_info_from_type(MBEDTLS_CIPHER_AES_128_ECB), key.data(), length * 8, data.data(), data.size(), dest.data()); 110 cmacAes128CalculateMac(dest.data(), key.data(), data.data(), data.size());
123
124 return dest; 111 return dest;
125} 112}
126 113
@@ -131,7 +118,7 @@ void Key::find_key(const byte_vector &buffer, size_t start) {
131 u8 temp_hash[0x20]; 118 u8 temp_hash[0x20];
132 119
133 if (buffer.size() == length) { 120 if (buffer.size() == length) {
134 Common::sha256(buffer.data(), temp_hash, length); 121 sha256CalculateHash(temp_hash, buffer.data(), length);
135 if (!std::equal(hash.begin(), hash.end(), temp_hash)) 122 if (!std::equal(hash.begin(), hash.end(), temp_hash))
136 return; 123 return;
137 std::copy(buffer.begin(), buffer.begin() + length, std::back_inserter(key)); 124 std::copy(buffer.begin(), buffer.begin() + length, std::back_inserter(key));
@@ -143,7 +130,7 @@ void Key::find_key(const byte_vector &buffer, size_t start) {
143 for (size_t i = start; i < buffer.size() - length; i++) { 130 for (size_t i = start; i < buffer.size() - length; i++) {
144 if (xx_hash == XXHash64::hash(buffer.data() + i, length, 0)) { 131 if (xx_hash == XXHash64::hash(buffer.data() + i, length, 0)) {
145 // double-check sha256 since xxhash64 isn't as collision-safe 132 // double-check sha256 since xxhash64 isn't as collision-safe
146 Common::sha256(buffer.data() + i, temp_hash, length); 133 sha256CalculateHash(temp_hash, buffer.data() + i, length);
147 if (!std::equal(hash.begin(), hash.end(), temp_hash)) 134 if (!std::equal(hash.begin(), hash.end(), temp_hash))
148 continue; 135 continue;
149 std::copy(buffer.begin() + i, buffer.begin() + i + length, std::back_inserter(key)); 136 std::copy(buffer.begin() + i, buffer.begin() + i + length, std::back_inserter(key));
diff --git a/source/KeyCollection.cpp b/source/KeyCollection.cpp
index 12fa79d..8c23f9a 100644
--- a/source/KeyCollection.cpp
+++ b/source/KeyCollection.cpp
@@ -273,9 +273,11 @@ void KeyCollection::get_keys() {
273 Common::draw_text_with_time(0x10, 0x110, GREEN, "Total time elapsed:", total_time.get_elapsed()); 273 Common::draw_text_with_time(0x10, 0x110, GREEN, "Total time elapsed:", total_time.get_elapsed());
274 274
275 char keys_str[32]; 275 char keys_str[32];
276 sprintf(keys_str, "Total keys found: %lu", Key::get_saved_key_count()); 276 if (!Lockpick_RCM_file_found) {
277 Common::draw_text(0x2a0, 0x110, CYAN, keys_str); 277 sprintf(keys_str, "Total keys found: %lu", Key::get_saved_key_count());
278 Common::draw_text(0x80, 0x140, YELLOW, "Keys saved to \"/switch/prod.keys\"!"); 278 Common::draw_text(0x2a0, 0x110, CYAN, keys_str);
279 Common::draw_text(0x80, 0x140, YELLOW, "Keys saved to \"/switch/prod.keys\"!");
280 }
279 281
280 Common::draw_text(0x10, 0x170, CYAN, "Dumping titlekeys..."); 282 Common::draw_text(0x10, 0x170, CYAN, "Dumping titlekeys...");
281 Common::update_display(); 283 Common::update_display();
@@ -727,15 +729,15 @@ void KeyCollection::get_titlekeys() {
727void KeyCollection::mgf1(const u8 *data, size_t data_length, u8 *mask, size_t mask_length) { 729void KeyCollection::mgf1(const u8 *data, size_t data_length, u8 *mask, size_t mask_length) {
728 u8 data_counter[data_length + 4] = {}; 730 u8 data_counter[data_length + 4] = {};
729 std::copy(data, data + data_length, data_counter); 731 std::copy(data, data + data_length, data_counter);
730 Common::sha256(data_counter, mask, data_length + 4); 732 sha256CalculateHash(mask, data_counter, data_length + 4);
731 for (u32 i = 1; i < (mask_length / 0x20) + 1; i++) { 733 for (u32 i = 1; i < (mask_length / 0x20) + 1; i++) {
732 for (size_t j = 0; j < 4; j++) 734 for (size_t j = 0; j < 4; j++)
733 data_counter[data_length + 3 - j] = (i >> (8 * j)) & 0xff; 735 data_counter[data_length + 3 - j] = (i >> (8 * j)) & 0xff;
734 if (i * 0x20 <= mask_length) 736 if (i * 0x20 <= mask_length)
735 Common::sha256(data_counter, mask + (i * 0x20), data_length + 4); 737 sha256CalculateHash(mask + (i * 0x20), data_counter, data_length + 4);
736 else { 738 else {
737 u8 temp_mask[0x20]; 739 u8 temp_mask[0x20];
738 Common::sha256(data_counter, temp_mask, data_length + 4); 740 sha256CalculateHash(temp_mask, data_counter, data_length + 4);
739 std::copy(temp_mask, temp_mask + mask_length - (i * 0x20), mask + (i * 0x20)); 741 std::copy(temp_mask, temp_mask + mask_length - (i * 0x20), mask + (i * 0x20));
740 } 742 }
741 } 743 }
diff --git a/source/KeyLocation.cpp b/source/KeyLocation.cpp
index 8333187..ca4a513 100644
--- a/source/KeyLocation.cpp
+++ b/source/KeyLocation.cpp
@@ -16,7 +16,6 @@
16 16
17#include "KeyLocation.hpp" 17#include "KeyLocation.hpp"
18 18
19#include "Common.hpp"
20#include "xxhash64.h" 19#include "xxhash64.h"
21 20
22#include <algorithm> 21#include <algorithm>
@@ -114,7 +113,7 @@ void KeyLocation::find_keys(std::vector<Key *> &keys) {
114 size_t key_index = hash_index[hash]; 113 size_t key_index = hash_index[hash];
115 u8 key_length = keys[key_index]->length; 114 u8 key_length = keys[key_index]->length;
116 // double-check sha256 since xxhash64 isn't as collision-safe 115 // double-check sha256 since xxhash64 isn't as collision-safe
117 Common::sha256(data.data() + i, temp_hash, key_length); 116 sha256CalculateHash(temp_hash, data.data() + i, key_length);
118 if (!std::equal(keys[key_index]->hash.begin(), keys[key_index]->hash.end(), temp_hash)) 117 if (!std::equal(keys[key_index]->hash.begin(), keys[key_index]->hash.end(), temp_hash))
119 continue; 118 continue;
120 std::copy(data.begin() + i, data.begin() + i + key_length, std::back_inserter(keys[key_index]->key)); 119 std::copy(data.begin() + i, data.begin() + i + key_length, std::back_inserter(keys[key_index]->key));
diff --git a/source/mbedtls/.gitignore b/source/mbedtls/.gitignore
deleted file mode 100644
index f40064d..0000000
--- a/source/mbedtls/.gitignore
+++ /dev/null
@@ -1,28 +0,0 @@
1CMakeCache.txt
2CMakeFiles
3CTestTestfile.cmake
4cmake_install.cmake
5Testing
6Coverage
7*.gcno
8*.gcda
9
10# generated by scripts/memory.sh
11massif-*
12
13# MSVC files generated by CMake:
14/*.sln
15/*.vcxproj
16/*.filters
17
18# MSVC build artifacts:
19*.exe
20*.pdb
21*.ilk
22*.lib
23
24# Python build artifacts:
25*.pyc
26
27# CMake generates *.dir/ folders for in-tree builds (used by MSVC projects), ignore all of those:
28*.dir/
diff --git a/source/mbedtls/LICENSE b/source/mbedtls/LICENSE
deleted file mode 100644
index 0a95e29..0000000
--- a/source/mbedtls/LICENSE
+++ /dev/null
@@ -1,2 +0,0 @@
1This package of mbed TLS is specifically licensed under the GPL 2.0,
2as can be found in: gpl-2.0.txt
diff --git a/source/mbedtls/README.md b/source/mbedtls/README.md
deleted file mode 100644
index 6345848..0000000
--- a/source/mbedtls/README.md
+++ /dev/null
@@ -1,218 +0,0 @@
1README for Mbed TLS
2===================
3
4Configuration
5-------------
6
7Mbed TLS should build out of the box on most systems. Some platform specific options are available in the fully documented configuration file `include/mbedtls/config.h`, which is also the place where features can be selected. This file can be edited manually, or in a more programmatic way using the Perl script `scripts/config.pl` (use `--help` for usage instructions).
8
9Compiler options can be set using conventional environment variables such as `CC` and `CFLAGS` when using the Make and CMake build system (see below).
10
11Compiling
12---------
13
14There are currently four active build systems used within Mbed TLS releases:
15
16- yotta
17- GNU Make
18- CMake
19- Microsoft Visual Studio (Microsoft Visual Studio 2010 or later)
20
21The main systems used for development are CMake and GNU Make. Those systems are always complete and up-to-date. The others should reflect all changes present in the CMake and Make build system, although features may not be ported there automatically.
22
23Yotta, as a build system, is slightly different from the other build systems:
24
25- it provides a minimalistic configuration file by default
26- depending on the yotta target, features of Mbed OS may be used in examples and tests
27
28The Make and CMake build systems create three libraries: libmbedcrypto, libmbedx509, and libmbedtls. Note that libmbedtls depends on libmbedx509 and libmbedcrypto, and libmbedx509 depends on libmbedcrypto. As a result, some linkers will expect flags to be in a specific order, for example the GNU linker wants `-lmbedtls -lmbedx509 -lmbedcrypto`. Also, when loading shared libraries using dlopen(), you'll need to load libmbedcrypto first, then libmbedx509, before you can load libmbedtls.
29
30### Yotta
31
32[yotta](http://yottabuild.org) is a package manager and build system developed by Mbed, and is the build system of Mbed OS 16.03. To install it on your platform, please follow the yotta [installation instructions](http://docs.yottabuild.org/#installing).
33
34Once yotta is installed, you can use it to download the latest version of Mbed TLS from the yotta registry with:
35
36 yotta install mbedtls
37
38and build it with:
39
40 yotta build
41
42If, on the other hand, you already have a copy of Mbed TLS from a source other than the yotta registry, for example from cloning our GitHub repository, or from downloading a tarball of the standalone edition, then you'll first need to generate the yotta module by running:
43
44 yotta/create-module.sh
45
46This should be executed from the root Mbed TLS project directory. This will create the yotta module in the `yotta/module` directory within it. You can then change to that directory and build as usual:
47
48 cd yotta/module
49 yotta build
50
51In any case, you'll probably want to set the yotta target before building unless it has already been set globally. For more information on using yotta, please consult the [yotta documentation](http://docs.yottabuild.org/).
52
53For more details on the yotta/Mbed OS edition of Mbed TLS, including example programs, please consult the [Readme at the root of the yotta module](https://github.com/ARMmbed/mbedtls/blob/development/yotta/data/README.md).
54
55### Make
56
57We require GNU Make. To build the library and the sample programs, GNU Make and a C compiler are sufficient. Some of the more advanced build targets require some Unix/Linux tools.
58
59We intentionally only use a minimum of functionality in the makefiles in order to keep them as simple and independent of different toolchains as possible, to allow users to more easily move between different platforms. Users who need more features are recommended to use CMake.
60
61In order to build from the source code using GNU Make, just enter at the command line:
62
63 make
64
65In order to run the tests, enter:
66
67 make check
68
69The tests need Perl to be built and run. If you don't have Perl installed, you can skip building the tests with:
70
71 make no_test
72
73You'll still be able to run a much smaller set of tests with:
74
75 programs/test/selftest
76
77In order to build for a Windows platform, you should use `WINDOWS_BUILD=1` if the target is Windows but the build environment is Unix-like (for instance when cross-compiling, or compiling from an MSYS shell), and `WINDOWS=1` if the build environment is a Windows shell (for instance using mingw32-make) (in that case some targets will not be available).
78
79Setting the variable `SHARED` in your environment will build shared libraries in addition to the static libraries. Setting `DEBUG` gives you a debug build. You can override `CFLAGS` and `LDFLAGS` by setting them in your environment or on the make command line; compiler warning options may be overridden separately using `WARNING_CFLAGS`. Some directory-specific options (for example, `-I` directives) are still preserved.
80
81Please note that setting `CFLAGS` overrides its default value of `-O2` and setting `WARNING_CFLAGS` overrides its default value (starting with `-Wall -W`), so it you just want to add some warning options to the default ones, you can do so by setting `CFLAGS=-O2 -Werror` for example. Setting `WARNING_CFLAGS` is useful when you want to get rid of its default content (for example because your compiler doesn't accept `-Wall` as an option). Directory-specific options cannot be overriden from the command line.
82
83Depending on your platform, you might run into some issues. Please check the Makefiles in `library/`, `programs/` and `tests/` for options to manually add or remove for specific platforms. You can also check [the Mbed TLS Knowledge Base](https://tls.mbed.org/kb) for articles on your platform or issue.
84
85In case you find that you need to do something else as well, please let us know what, so we can add it to the [Mbed TLS Knowledge Base](https://tls.mbed.org/kb).
86
87### CMake
88
89In order to build the source using CMake in a separate directory (recommended), just enter at the command line:
90
91 mkdir /path/to/build_dir && cd /path/to/build_dir
92 cmake /path/to/mbedtls_source
93 make
94
95In order to run the tests, enter:
96
97 make test
98
99The test suites need Perl to be built. If you don't have Perl installed, you'll want to disable the test suites with:
100
101 cmake -DENABLE_TESTING=Off /path/to/mbedtls_source
102
103If you disabled the test suites, but kept the programs enabled, you can still run a much smaller set of tests with:
104
105 programs/test/selftest
106
107To configure CMake for building shared libraries, use:
108
109 cmake -DUSE_SHARED_MBEDTLS_LIBRARY=On /path/to/mbedtls_source
110
111There are many different build modes available within the CMake buildsystem. Most of them are available for gcc and clang, though some are compiler-specific:
112
113- `Release`. This generates the default code without any unnecessary information in the binary files.
114- `Debug`. This generates debug information and disables optimization of the code.
115- `Coverage`. This generates code coverage information in addition to debug information.
116- `ASan`. This instruments the code with AddressSanitizer to check for memory errors. (This includes LeakSanitizer, with recent version of gcc and clang.) (With recent version of clang, this mode also instruments the code with UndefinedSanitizer to check for undefined behaviour.)
117- `ASanDbg`. Same as ASan but slower, with debug information and better stack traces.
118- `MemSan`. This instruments the code with MemorySanitizer to check for uninitialised memory reads. Experimental, needs recent clang on Linux/x86\_64.
119- `MemSanDbg`. Same as MemSan but slower, with debug information, better stack traces and origin tracking.
120- `Check`. This activates the compiler warnings that depend on optimization and treats all warnings as errors.
121
122Switching build modes in CMake is simple. For debug mode, enter at the command line:
123
124 cmake -D CMAKE_BUILD_TYPE=Debug /path/to/mbedtls_source
125
126To list other available CMake options, use:
127
128 cmake -LH
129
130Note that, with CMake, you can't adjust the compiler or its flags after the
131initial invocation of cmake. This means that `CC=your_cc make` and `make
132CC=your_cc` will *not* work (similarly with `CFLAGS` and other variables).
133These variables need to be adjusted when invoking cmake for the first time,
134for example:
135
136 CC=your_cc cmake /path/to/mbedtls_source
137
138If you already invoked cmake and want to change those settings, you need to
139remove the build directory and create it again.
140
141Note that it is possible to build in-place; this will however overwrite the
142provided Makefiles (see `scripts/tmp_ignore_makefiles.sh` if you want to
143prevent `git status` from showing them as modified). In order to do so, from
144the Mbed TLS source directory, use:
145
146 cmake .
147 make
148
149If you want to change `CC` or `CFLAGS` afterwards, you will need to remove the
150CMake cache. This can be done with the following command using GNU find:
151
152 find . -iname '*cmake*' -not -name CMakeLists.txt -exec rm -rf {} +
153
154You can now make the desired change:
155
156 CC=your_cc cmake .
157 make
158
159Regarding variables, also note that if you set CFLAGS when invoking cmake,
160your value of CFLAGS doesn't override the content provided by cmake (depending
161on the build mode as seen above), it's merely prepended to it.
162
163### Microsoft Visual Studio
164
165The build files for Microsoft Visual Studio are generated for Visual Studio 2010.
166
167The solution file `mbedTLS.sln` contains all the basic projects needed to build the library and all the programs. The files in tests are not generated and compiled, as these need a perl environment as well. However, the selftest program in `programs/test/` is still available.
168
169Example programs
170----------------
171
172We've included example programs for a lot of different features and uses in `programs/`. Most programs only focus on a single feature or usage scenario, so keep that in mind when copying parts of the code.
173
174Tests
175-----
176
177Mbed TLS includes an elaborate test suite in `tests/` that initially requires Perl to generate the tests files (e.g. `test\_suite\_mpi.c`). These files are generated from a `function file` (e.g. `suites/test\_suite\_mpi.function`) and a `data file` (e.g. `suites/test\_suite\_mpi.data`). The `function file` contains the test functions. The `data file` contains the test cases, specified as parameters that will be passed to the test function.
178
179For machines with a Unix shell and OpenSSL (and optionally GnuTLS) installed, additional test scripts are available:
180
181- `tests/ssl-opt.sh` runs integration tests for various TLS options (renegotiation, resumption, etc.) and tests interoperability of these options with other implementations.
182- `tests/compat.sh` tests interoperability of every ciphersuite with other implementations.
183- `tests/scripts/test-ref-configs.pl` test builds in various reduced configurations.
184- `tests/scripts/key-exchanges.pl` test builds in configurations with a single key exchange enabled
185- `tests/scripts/all.sh` runs a combination of the above tests, plus some more, with various build options (such as ASan, full `config.h`, etc).
186
187Configurations
188--------------
189
190We provide some non-standard configurations focused on specific use cases in the `configs/` directory. You can read more about those in `configs/README.txt`
191
192Porting Mbed TLS
193----------------
194
195Mbed TLS can be ported to many different architectures, OS's and platforms. Before starting a port, you may find the following Knowledge Base articles useful:
196
197- [Porting Mbed TLS to a new environment or OS](https://tls.mbed.org/kb/how-to/how-do-i-port-mbed-tls-to-a-new-environment-OS)
198- [What external dependencies does Mbed TLS rely on?](https://tls.mbed.org/kb/development/what-external-dependencies-does-mbedtls-rely-on)
199- [How do I configure Mbed TLS](https://tls.mbed.org/kb/compiling-and-building/how-do-i-configure-mbedtls)
200
201Contributing
202------------
203
204We gratefully accept bug reports and contributions from the community. There are some requirements we need to fulfill in order to be able to integrate contributions:
205
206- All contributions, whether large or small require a Contributor's License Agreement (CLA) to be accepted. This is because source code can possibly fall under copyright law and we need your consent to share in the ownership of the copyright.
207- We would ask that contributions conform to [our coding standards](https://tls.mbed.org/kb/development/mbedtls-coding-standards), and that contributions should be fully tested before submission.
208- As with any open source project, contributions will be reviewed by the project team and community and may need some modifications to be accepted.
209
210To accept the Contributor’s Licence Agreement (CLA), individual contributors can do this by creating an Mbed account and [accepting the online agreement here with a click through](https://os.mbed.com/contributor_agreement/). Alternatively, for contributions from corporations, or those that do not wish to create an Mbed account, a slightly different agreement can be found [here](https://www.mbed.com/en/about-mbed/contributor-license-agreements/). This agreement should be signed and returned to Arm as described in the instructions given.
211
212### Making a Contribution
213
2141. [Check for open issues](https://github.com/ARMmbed/mbedtls/issues) or [start a discussion](https://forums.mbed.com/c/mbed-tls) around a feature idea or a bug.
2152. Fork the [Mbed TLS repository on GitHub](https://github.com/ARMmbed/mbedtls) to start making your changes. As a general rule, you should use the "development" branch as a basis.
2163. Write a test which shows that the bug was fixed or that the feature works as expected.
2174. Send a pull request and bug us until it gets merged and published. Contributions may need some modifications, so work with us to get your change accepted. We will include your name in the ChangeLog :)
218
diff --git a/source/mbedtls/gpl-2.0.txt b/source/mbedtls/gpl-2.0.txt
deleted file mode 100644
index d159169..0000000
--- a/source/mbedtls/gpl-2.0.txt
+++ /dev/null
@@ -1,339 +0,0 @@
1 GNU GENERAL PUBLIC LICENSE
2 Version 2, June 1991
3
4 Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
5 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
6 Everyone is permitted to copy and distribute verbatim copies
7 of this license document, but changing it is not allowed.
8
9 Preamble
10
11 The licenses for most software are designed to take away your
12freedom to share and change it. By contrast, the GNU General Public
13License is intended to guarantee your freedom to share and change free
14software--to make sure the software is free for all its users. This
15General Public License applies to most of the Free Software
16Foundation's software and to any other program whose authors commit to
17using it. (Some other Free Software Foundation software is covered by
18the GNU Lesser General Public License instead.) You can apply it to
19your programs, too.
20
21 When we speak of free software, we are referring to freedom, not
22price. Our General Public Licenses are designed to make sure that you
23have the freedom to distribute copies of free software (and charge for
24this service if you wish), that you receive source code or can get it
25if you want it, that you can change the software or use pieces of it
26in new free programs; and that you know you can do these things.
27
28 To protect your rights, we need to make restrictions that forbid
29anyone to deny you these rights or to ask you to surrender the rights.
30These restrictions translate to certain responsibilities for you if you
31distribute copies of the software, or if you modify it.
32
33 For example, if you distribute copies of such a program, whether
34gratis or for a fee, you must give the recipients all the rights that
35you have. You must make sure that they, too, receive or can get the
36source code. And you must show them these terms so they know their
37rights.
38
39 We protect your rights with two steps: (1) copyright the software, and
40(2) offer you this license which gives you legal permission to copy,
41distribute and/or modify the software.
42
43 Also, for each author's protection and ours, we want to make certain
44that everyone understands that there is no warranty for this free
45software. If the software is modified by someone else and passed on, we
46want its recipients to know that what they have is not the original, so
47that any problems introduced by others will not reflect on the original
48authors' reputations.
49
50 Finally, any free program is threatened constantly by software
51patents. We wish to avoid the danger that redistributors of a free
52program will individually obtain patent licenses, in effect making the
53program proprietary. To prevent this, we have made it clear that any
54patent must be licensed for everyone's free use or not licensed at all.
55
56 The precise terms and conditions for copying, distribution and
57modification follow.
58
59 GNU GENERAL PUBLIC LICENSE
60 TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
61
62 0. This License applies to any program or other work which contains
63a notice placed by the copyright holder saying it may be distributed
64under the terms of this General Public License. The "Program", below,
65refers to any such program or work, and a "work based on the Program"
66means either the Program or any derivative work under copyright law:
67that is to say, a work containing the Program or a portion of it,
68either verbatim or with modifications and/or translated into another
69language. (Hereinafter, translation is included without limitation in
70the term "modification".) Each licensee is addressed as "you".
71
72Activities other than copying, distribution and modification are not
73covered by this License; they are outside its scope. The act of
74running the Program is not restricted, and the output from the Program
75is covered only if its contents constitute a work based on the
76Program (independent of having been made by running the Program).
77Whether that is true depends on what the Program does.
78
79 1. You may copy and distribute verbatim copies of the Program's
80source code as you receive it, in any medium, provided that you
81conspicuously and appropriately publish on each copy an appropriate
82copyright notice and disclaimer of warranty; keep intact all the
83notices that refer to this License and to the absence of any warranty;
84and give any other recipients of the Program a copy of this License
85along with the Program.
86
87You may charge a fee for the physical act of transferring a copy, and
88you may at your option offer warranty protection in exchange for a fee.
89
90 2. You may modify your copy or copies of the Program or any portion
91of it, thus forming a work based on the Program, and copy and
92distribute such modifications or work under the terms of Section 1
93above, provided that you also meet all of these conditions:
94
95 a) You must cause the modified files to carry prominent notices
96 stating that you changed the files and the date of any change.
97
98 b) You must cause any work that you distribute or publish, that in
99 whole or in part contains or is derived from the Program or any
100 part thereof, to be licensed as a whole at no charge to all third
101 parties under the terms of this License.
102
103 c) If the modified program normally reads commands interactively
104 when run, you must cause it, when started running for such
105 interactive use in the most ordinary way, to print or display an
106 announcement including an appropriate copyright notice and a
107 notice that there is no warranty (or else, saying that you provide
108 a warranty) and that users may redistribute the program under
109 these conditions, and telling the user how to view a copy of this
110 License. (Exception: if the Program itself is interactive but
111 does not normally print such an announcement, your work based on
112 the Program is not required to print an announcement.)
113
114These requirements apply to the modified work as a whole. If
115identifiable sections of that work are not derived from the Program,
116and can be reasonably considered independent and separate works in
117themselves, then this License, and its terms, do not apply to those
118sections when you distribute them as separate works. But when you
119distribute the same sections as part of a whole which is a work based
120on the Program, the distribution of the whole must be on the terms of
121this License, whose permissions for other licensees extend to the
122entire whole, and thus to each and every part regardless of who wrote it.
123
124Thus, it is not the intent of this section to claim rights or contest
125your rights to work written entirely by you; rather, the intent is to
126exercise the right to control the distribution of derivative or
127collective works based on the Program.
128
129In addition, mere aggregation of another work not based on the Program
130with the Program (or with a work based on the Program) on a volume of
131a storage or distribution medium does not bring the other work under
132the scope of this License.
133
134 3. You may copy and distribute the Program (or a work based on it,
135under Section 2) in object code or executable form under the terms of
136Sections 1 and 2 above provided that you also do one of the following:
137
138 a) Accompany it with the complete corresponding machine-readable
139 source code, which must be distributed under the terms of Sections
140 1 and 2 above on a medium customarily used for software interchange; or,
141
142 b) Accompany it with a written offer, valid for at least three
143 years, to give any third party, for a charge no more than your
144 cost of physically performing source distribution, a complete
145 machine-readable copy of the corresponding source code, to be
146 distributed under the terms of Sections 1 and 2 above on a medium
147 customarily used for software interchange; or,
148
149 c) Accompany it with the information you received as to the offer
150 to distribute corresponding source code. (This alternative is
151 allowed only for noncommercial distribution and only if you
152 received the program in object code or executable form with such
153 an offer, in accord with Subsection b above.)
154
155The source code for a work means the preferred form of the work for
156making modifications to it. For an executable work, complete source
157code means all the source code for all modules it contains, plus any
158associated interface definition files, plus the scripts used to
159control compilation and installation of the executable. However, as a
160special exception, the source code distributed need not include
161anything that is normally distributed (in either source or binary
162form) with the major components (compiler, kernel, and so on) of the
163operating system on which the executable runs, unless that component
164itself accompanies the executable.
165
166If distribution of executable or object code is made by offering
167access to copy from a designated place, then offering equivalent
168access to copy the source code from the same place counts as
169distribution of the source code, even though third parties are not
170compelled to copy the source along with the object code.
171
172 4. You may not copy, modify, sublicense, or distribute the Program
173except as expressly provided under this License. Any attempt
174otherwise to copy, modify, sublicense or distribute the Program is
175void, and will automatically terminate your rights under this License.
176However, parties who have received copies, or rights, from you under
177this License will not have their licenses terminated so long as such
178parties remain in full compliance.
179
180 5. You are not required to accept this License, since you have not
181signed it. However, nothing else grants you permission to modify or
182distribute the Program or its derivative works. These actions are
183prohibited by law if you do not accept this License. Therefore, by
184modifying or distributing the Program (or any work based on the
185Program), you indicate your acceptance of this License to do so, and
186all its terms and conditions for copying, distributing or modifying
187the Program or works based on it.
188
189 6. Each time you redistribute the Program (or any work based on the
190Program), the recipient automatically receives a license from the
191original licensor to copy, distribute or modify the Program subject to
192these terms and conditions. You may not impose any further
193restrictions on the recipients' exercise of the rights granted herein.
194You are not responsible for enforcing compliance by third parties to
195this License.
196
197 7. If, as a consequence of a court judgment or allegation of patent
198infringement or for any other reason (not limited to patent issues),
199conditions are imposed on you (whether by court order, agreement or
200otherwise) that contradict the conditions of this License, they do not
201excuse you from the conditions of this License. If you cannot
202distribute so as to satisfy simultaneously your obligations under this
203License and any other pertinent obligations, then as a consequence you
204may not distribute the Program at all. For example, if a patent
205license would not permit royalty-free redistribution of the Program by
206all those who receive copies directly or indirectly through you, then
207the only way you could satisfy both it and this License would be to
208refrain entirely from distribution of the Program.
209
210If any portion of this section is held invalid or unenforceable under
211any particular circumstance, the balance of the section is intended to
212apply and the section as a whole is intended to apply in other
213circumstances.
214
215It is not the purpose of this section to induce you to infringe any
216patents or other property right claims or to contest validity of any
217such claims; this section has the sole purpose of protecting the
218integrity of the free software distribution system, which is
219implemented by public license practices. Many people have made
220generous contributions to the wide range of software distributed
221through that system in reliance on consistent application of that
222system; it is up to the author/donor to decide if he or she is willing
223to distribute software through any other system and a licensee cannot
224impose that choice.
225
226This section is intended to make thoroughly clear what is believed to
227be a consequence of the rest of this License.
228
229 8. If the distribution and/or use of the Program is restricted in
230certain countries either by patents or by copyrighted interfaces, the
231original copyright holder who places the Program under this License
232may add an explicit geographical distribution limitation excluding
233those countries, so that distribution is permitted only in or among
234countries not thus excluded. In such case, this License incorporates
235the limitation as if written in the body of this License.
236
237 9. The Free Software Foundation may publish revised and/or new versions
238of the General Public License from time to time. Such new versions will
239be similar in spirit to the present version, but may differ in detail to
240address new problems or concerns.
241
242Each version is given a distinguishing version number. If the Program
243specifies a version number of this License which applies to it and "any
244later version", you have the option of following the terms and conditions
245either of that version or of any later version published by the Free
246Software Foundation. If the Program does not specify a version number of
247this License, you may choose any version ever published by the Free Software
248Foundation.
249
250 10. If you wish to incorporate parts of the Program into other free
251programs whose distribution conditions are different, write to the author
252to ask for permission. For software which is copyrighted by the Free
253Software Foundation, write to the Free Software Foundation; we sometimes
254make exceptions for this. Our decision will be guided by the two goals
255of preserving the free status of all derivatives of our free software and
256of promoting the sharing and reuse of software generally.
257
258 NO WARRANTY
259
260 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
261FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
262OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
263PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
264OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
265MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
266TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
267PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
268REPAIR OR CORRECTION.
269
270 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
271WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
272REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
273INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
274OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
275TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
276YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
277PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
278POSSIBILITY OF SUCH DAMAGES.
279
280 END OF TERMS AND CONDITIONS
281
282 How to Apply These Terms to Your New Programs
283
284 If you develop a new program, and you want it to be of the greatest
285possible use to the public, the best way to achieve this is to make it
286free software which everyone can redistribute and change under these terms.
287
288 To do so, attach the following notices to the program. It is safest
289to attach them to the start of each source file to most effectively
290convey the exclusion of warranty; and each file should have at least
291the "copyright" line and a pointer to where the full notice is found.
292
293 <one line to give the program's name and a brief idea of what it does.>
294 Copyright (C) <year> <name of author>
295
296 This program is free software; you can redistribute it and/or modify
297 it under the terms of the GNU General Public License as published by
298 the Free Software Foundation; either version 2 of the License, or
299 (at your option) any later version.
300
301 This program is distributed in the hope that it will be useful,
302 but WITHOUT ANY WARRANTY; without even the implied warranty of
303 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
304 GNU General Public License for more details.
305
306 You should have received a copy of the GNU General Public License along
307 with this program; if not, write to the Free Software Foundation, Inc.,
308 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
309
310Also add information on how to contact you by electronic and paper mail.
311
312If the program is interactive, make it output a short notice like this
313when it starts in an interactive mode:
314
315 Gnomovision version 69, Copyright (C) year name of author
316 Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
317 This is free software, and you are welcome to redistribute it
318 under certain conditions; type `show c' for details.
319
320The hypothetical commands `show w' and `show c' should show the appropriate
321parts of the General Public License. Of course, the commands you use may
322be called something other than `show w' and `show c'; they could even be
323mouse-clicks or menu items--whatever suits your program.
324
325You should also get your employer (if you work as a programmer) or your
326school, if any, to sign a "copyright disclaimer" for the program, if
327necessary. Here is a sample; alter the names:
328
329 Yoyodyne, Inc., hereby disclaims all copyright interest in the program
330 `Gnomovision' (which makes passes at compilers) written by James Hacker.
331
332 <signature of Ty Coon>, 1 April 1989
333 Ty Coon, President of Vice
334
335This General Public License does not permit incorporating your program into
336proprietary programs. If your program is a subroutine library, you may
337consider it more useful to permit linking proprietary applications with the
338library. If this is what you want to do, use the GNU Lesser General
339Public License instead of this License.
diff --git a/source/mbedtls/include/.gitignore b/source/mbedtls/include/.gitignore
deleted file mode 100644
index bf67d02..0000000
--- a/source/mbedtls/include/.gitignore
+++ /dev/null
@@ -1,4 +0,0 @@
1Makefile
2*.sln
3*.vcxproj
4mbedtls/check_config
diff --git a/source/mbedtls/include/CMakeLists.txt b/source/mbedtls/include/CMakeLists.txt
deleted file mode 100644
index 1b581a5..0000000
--- a/source/mbedtls/include/CMakeLists.txt
+++ /dev/null
@@ -1,16 +0,0 @@
1option(INSTALL_MBEDTLS_HEADERS "Install mbed TLS headers." ON)
2
3if(INSTALL_MBEDTLS_HEADERS)
4
5 file(GLOB headers "mbedtls/*.h")
6
7 install(FILES ${headers}
8 DESTINATION include/mbedtls
9 PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ)
10
11endif(INSTALL_MBEDTLS_HEADERS)
12
13# Make config.h available in an out-of-source build. ssl-opt.sh requires it.
14if (NOT ${CMAKE_CURRENT_BINARY_DIR} STREQUAL ${CMAKE_CURRENT_SOURCE_DIR})
15 link_to_source(mbedtls)
16endif()
diff --git a/source/mbedtls/include/mbedtls/aes.h b/source/mbedtls/include/mbedtls/aes.h
deleted file mode 100644
index 9af6bb7..0000000
--- a/source/mbedtls/include/mbedtls/aes.h
+++ /dev/null
@@ -1,628 +0,0 @@
1/**
2 * \file aes.h
3 *
4 * \brief This file contains AES definitions and functions.
5 *
6 * The Advanced Encryption Standard (AES) specifies a FIPS-approved
7 * cryptographic algorithm that can be used to protect electronic
8 * data.
9 *
10 * The AES algorithm is a symmetric block cipher that can
11 * encrypt and decrypt information. For more information, see
12 * <em>FIPS Publication 197: Advanced Encryption Standard</em> and
13 * <em>ISO/IEC 18033-2:2006: Information technology -- Security
14 * techniques -- Encryption algorithms -- Part 2: Asymmetric
15 * ciphers</em>.
16 *
17 * The AES-XTS block mode is standardized by NIST SP 800-38E
18 * <https://nvlpubs.nist.gov/nistpubs/legacy/sp/nistspecialpublication800-38e.pdf>
19 * and described in detail by IEEE P1619
20 * <https://ieeexplore.ieee.org/servlet/opac?punumber=4375278>.
21 */
22
23/* Copyright (C) 2006-2018, Arm Limited (or its affiliates), All Rights Reserved.
24 * SPDX-License-Identifier: GPL-2.0
25 *
26 * This program is free software; you can redistribute it and/or modify
27 * it under the terms of the GNU General Public License as published by
28 * the Free Software Foundation; either version 2 of the License, or
29 * (at your option) any later version.
30 *
31 * This program is distributed in the hope that it will be useful,
32 * but WITHOUT ANY WARRANTY; without even the implied warranty of
33 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
34 * GNU General Public License for more details.
35 *
36 * You should have received a copy of the GNU General Public License along
37 * with this program; if not, write to the Free Software Foundation, Inc.,
38 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
39 *
40 * This file is part of Mbed TLS (https://tls.mbed.org)
41 */
42
43#ifndef MBEDTLS_AES_H
44#define MBEDTLS_AES_H
45
46#if !defined(MBEDTLS_CONFIG_FILE)
47#include "config.h"
48#else
49#include MBEDTLS_CONFIG_FILE
50#endif
51
52#include <stddef.h>
53#include <stdint.h>
54
55/* padlock.c and aesni.c rely on these values! */
56#define MBEDTLS_AES_ENCRYPT 1 /**< AES encryption. */
57#define MBEDTLS_AES_DECRYPT 0 /**< AES decryption. */
58
59/* Error codes in range 0x0020-0x0022 */
60#define MBEDTLS_ERR_AES_INVALID_KEY_LENGTH -0x0020 /**< Invalid key length. */
61#define MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH -0x0022 /**< Invalid data input length. */
62
63/* Error codes in range 0x0021-0x0025 */
64#define MBEDTLS_ERR_AES_BAD_INPUT_DATA -0x0021 /**< Invalid input data. */
65#define MBEDTLS_ERR_AES_FEATURE_UNAVAILABLE -0x0023 /**< Feature not available. For example, an unsupported AES key size. */
66#define MBEDTLS_ERR_AES_HW_ACCEL_FAILED -0x0025 /**< AES hardware accelerator failed. */
67
68#if ( defined(__ARMCC_VERSION) || defined(_MSC_VER) ) && \
69 !defined(inline) && !defined(__cplusplus)
70#define inline __inline
71#endif
72
73#ifdef __cplusplus
74extern "C" {
75#endif
76
77#if !defined(MBEDTLS_AES_ALT)
78// Regular implementation
79//
80
81/**
82 * \brief The AES context-type definition.
83 */
84typedef struct mbedtls_aes_context
85{
86 int nr; /*!< The number of rounds. */
87 uint32_t *rk; /*!< AES round keys. */
88 uint32_t buf[68]; /*!< Unaligned data buffer. This buffer can
89 hold 32 extra Bytes, which can be used for
90 one of the following purposes:
91 <ul><li>Alignment if VIA padlock is
92 used.</li>
93 <li>Simplifying key expansion in the 256-bit
94 case by generating an extra round key.
95 </li></ul> */
96}
97mbedtls_aes_context;
98
99#if defined(MBEDTLS_CIPHER_MODE_XTS)
100/**
101 * \brief The AES XTS context-type definition.
102 */
103typedef struct mbedtls_aes_xts_context
104{
105 mbedtls_aes_context crypt; /*!< The AES context to use for AES block
106 encryption or decryption. */
107 mbedtls_aes_context tweak; /*!< The AES context used for tweak
108 computation. */
109} mbedtls_aes_xts_context;
110#endif /* MBEDTLS_CIPHER_MODE_XTS */
111
112#else /* MBEDTLS_AES_ALT */
113#include "aes_alt.h"
114#endif /* MBEDTLS_AES_ALT */
115
116/**
117 * \brief This function initializes the specified AES context.
118 *
119 * It must be the first API called before using
120 * the context.
121 *
122 * \param ctx The AES context to initialize.
123 */
124void mbedtls_aes_init( mbedtls_aes_context *ctx );
125
126/**
127 * \brief This function releases and clears the specified AES context.
128 *
129 * \param ctx The AES context to clear.
130 */
131void mbedtls_aes_free( mbedtls_aes_context *ctx );
132
133#if defined(MBEDTLS_CIPHER_MODE_XTS)
134/**
135 * \brief This function initializes the specified AES XTS context.
136 *
137 * It must be the first API called before using
138 * the context.
139 *
140 * \param ctx The AES XTS context to initialize.
141 */
142void mbedtls_aes_xts_init( mbedtls_aes_xts_context *ctx );
143
144/**
145 * \brief This function releases and clears the specified AES XTS context.
146 *
147 * \param ctx The AES XTS context to clear.
148 */
149void mbedtls_aes_xts_free( mbedtls_aes_xts_context *ctx );
150#endif /* MBEDTLS_CIPHER_MODE_XTS */
151
152/**
153 * \brief This function sets the encryption key.
154 *
155 * \param ctx The AES context to which the key should be bound.
156 * \param key The encryption key.
157 * \param keybits The size of data passed in bits. Valid options are:
158 * <ul><li>128 bits</li>
159 * <li>192 bits</li>
160 * <li>256 bits</li></ul>
161 *
162 * \return \c 0 on success.
163 * \return #MBEDTLS_ERR_AES_INVALID_KEY_LENGTH on failure.
164 */
165int mbedtls_aes_setkey_enc( mbedtls_aes_context *ctx, const unsigned char *key,
166 unsigned int keybits );
167
168/**
169 * \brief This function sets the decryption key.
170 *
171 * \param ctx The AES context to which the key should be bound.
172 * \param key The decryption key.
173 * \param keybits The size of data passed. Valid options are:
174 * <ul><li>128 bits</li>
175 * <li>192 bits</li>
176 * <li>256 bits</li></ul>
177 *
178 * \return \c 0 on success.
179 * \return #MBEDTLS_ERR_AES_INVALID_KEY_LENGTH on failure.
180 */
181int mbedtls_aes_setkey_dec( mbedtls_aes_context *ctx, const unsigned char *key,
182 unsigned int keybits );
183
184#if defined(MBEDTLS_CIPHER_MODE_XTS)
185/**
186 * \brief This function prepares an XTS context for encryption and
187 * sets the encryption key.
188 *
189 * \param ctx The AES XTS context to which the key should be bound.
190 * \param key The encryption key. This is comprised of the XTS key1
191 * concatenated with the XTS key2.
192 * \param keybits The size of \p key passed in bits. Valid options are:
193 * <ul><li>256 bits (each of key1 and key2 is a 128-bit key)</li>
194 * <li>512 bits (each of key1 and key2 is a 256-bit key)</li></ul>
195 *
196 * \return \c 0 on success.
197 * \return #MBEDTLS_ERR_AES_INVALID_KEY_LENGTH on failure.
198 */
199int mbedtls_aes_xts_setkey_enc( mbedtls_aes_xts_context *ctx,
200 const unsigned char *key,
201 unsigned int keybits );
202
203/**
204 * \brief This function prepares an XTS context for decryption and
205 * sets the decryption key.
206 *
207 * \param ctx The AES XTS context to which the key should be bound.
208 * \param key The decryption key. This is comprised of the XTS key1
209 * concatenated with the XTS key2.
210 * \param keybits The size of \p key passed in bits. Valid options are:
211 * <ul><li>256 bits (each of key1 and key2 is a 128-bit key)</li>
212 * <li>512 bits (each of key1 and key2 is a 256-bit key)</li></ul>
213 *
214 * \return \c 0 on success.
215 * \return #MBEDTLS_ERR_AES_INVALID_KEY_LENGTH on failure.
216 */
217int mbedtls_aes_xts_setkey_dec( mbedtls_aes_xts_context *ctx,
218 const unsigned char *key,
219 unsigned int keybits );
220#endif /* MBEDTLS_CIPHER_MODE_XTS */
221
222/**
223 * \brief This function performs an AES single-block encryption or
224 * decryption operation.
225 *
226 * It performs the operation defined in the \p mode parameter
227 * (encrypt or decrypt), on the input data buffer defined in
228 * the \p input parameter.
229 *
230 * mbedtls_aes_init(), and either mbedtls_aes_setkey_enc() or
231 * mbedtls_aes_setkey_dec() must be called before the first
232 * call to this API with the same context.
233 *
234 * \param ctx The AES context to use for encryption or decryption.
235 * \param mode The AES operation: #MBEDTLS_AES_ENCRYPT or
236 * #MBEDTLS_AES_DECRYPT.
237 * \param input The 16-Byte buffer holding the input data.
238 * \param output The 16-Byte buffer holding the output data.
239
240 * \return \c 0 on success.
241 */
242int mbedtls_aes_crypt_ecb( mbedtls_aes_context *ctx,
243 int mode,
244 const unsigned char input[16],
245 unsigned char output[16] );
246
247#if defined(MBEDTLS_CIPHER_MODE_CBC)
248/**
249 * \brief This function performs an AES-CBC encryption or decryption operation
250 * on full blocks.
251 *
252 * It performs the operation defined in the \p mode
253 * parameter (encrypt/decrypt), on the input data buffer defined in
254 * the \p input parameter.
255 *
256 * It can be called as many times as needed, until all the input
257 * data is processed. mbedtls_aes_init(), and either
258 * mbedtls_aes_setkey_enc() or mbedtls_aes_setkey_dec() must be called
259 * before the first call to this API with the same context.
260 *
261 * \note This function operates on aligned blocks, that is, the input size
262 * must be a multiple of the AES block size of 16 Bytes.
263 *
264 * \note Upon exit, the content of the IV is updated so that you can
265 * call the same function again on the next
266 * block(s) of data and get the same result as if it was
267 * encrypted in one call. This allows a "streaming" usage.
268 * If you need to retain the contents of the IV, you should
269 * either save it manually or use the cipher module instead.
270 *
271 *
272 * \param ctx The AES context to use for encryption or decryption.
273 * \param mode The AES operation: #MBEDTLS_AES_ENCRYPT or
274 * #MBEDTLS_AES_DECRYPT.
275 * \param length The length of the input data in Bytes. This must be a
276 * multiple of the block size (16 Bytes).
277 * \param iv Initialization vector (updated after use).
278 * \param input The buffer holding the input data.
279 * \param output The buffer holding the output data.
280 *
281 * \return \c 0 on success.
282 * \return #MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH
283 * on failure.
284 */
285int mbedtls_aes_crypt_cbc( mbedtls_aes_context *ctx,
286 int mode,
287 size_t length,
288 unsigned char iv[16],
289 const unsigned char *input,
290 unsigned char *output );
291#endif /* MBEDTLS_CIPHER_MODE_CBC */
292
293#if defined(MBEDTLS_CIPHER_MODE_XTS)
294/**
295 * \brief This function performs an AES-XTS encryption or decryption
296 * operation for an entire XTS data unit.
297 *
298 * AES-XTS encrypts or decrypts blocks based on their location as
299 * defined by a data unit number. The data unit number must be
300 * provided by \p data_unit.
301 *
302 * NIST SP 800-38E limits the maximum size of a data unit to 2^20
303 * AES blocks. If the data unit is larger than this, this function
304 * returns #MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH.
305 *
306 * \param ctx The AES XTS context to use for AES XTS operations.
307 * \param mode The AES operation: #MBEDTLS_AES_ENCRYPT or
308 * #MBEDTLS_AES_DECRYPT.
309 * \param length The length of a data unit in bytes. This can be any
310 * length between 16 bytes and 2^24 bytes inclusive
311 * (between 1 and 2^20 block cipher blocks).
312 * \param data_unit The address of the data unit encoded as an array of 16
313 * bytes in little-endian format. For disk encryption, this
314 * is typically the index of the block device sector that
315 * contains the data.
316 * \param input The buffer holding the input data (which is an entire
317 * data unit). This function reads \p length bytes from \p
318 * input.
319 * \param output The buffer holding the output data (which is an entire
320 * data unit). This function writes \p length bytes to \p
321 * output.
322 *
323 * \return \c 0 on success.
324 * \return #MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH if \p length is
325 * smaller than an AES block in size (16 bytes) or if \p
326 * length is larger than 2^20 blocks (16 MiB).
327 */
328int mbedtls_aes_crypt_xts( mbedtls_aes_xts_context *ctx,
329 int mode,
330 size_t length,
331 const unsigned char data_unit[16],
332 const unsigned char *input,
333 unsigned char *output );
334#endif /* MBEDTLS_CIPHER_MODE_XTS */
335
336#if defined(MBEDTLS_CIPHER_MODE_CFB)
337/**
338 * \brief This function performs an AES-CFB128 encryption or decryption
339 * operation.
340 *
341 * It performs the operation defined in the \p mode
342 * parameter (encrypt or decrypt), on the input data buffer
343 * defined in the \p input parameter.
344 *
345 * For CFB, you must set up the context with mbedtls_aes_setkey_enc(),
346 * regardless of whether you are performing an encryption or decryption
347 * operation, that is, regardless of the \p mode parameter. This is
348 * because CFB mode uses the same key schedule for encryption and
349 * decryption.
350 *
351 * \note Upon exit, the content of the IV is updated so that you can
352 * call the same function again on the next
353 * block(s) of data and get the same result as if it was
354 * encrypted in one call. This allows a "streaming" usage.
355 * If you need to retain the contents of the
356 * IV, you must either save it manually or use the cipher
357 * module instead.
358 *
359 *
360 * \param ctx The AES context to use for encryption or decryption.
361 * \param mode The AES operation: #MBEDTLS_AES_ENCRYPT or
362 * #MBEDTLS_AES_DECRYPT.
363 * \param length The length of the input data.
364 * \param iv_off The offset in IV (updated after use).
365 * \param iv The initialization vector (updated after use).
366 * \param input The buffer holding the input data.
367 * \param output The buffer holding the output data.
368 *
369 * \return \c 0 on success.
370 */
371int mbedtls_aes_crypt_cfb128( mbedtls_aes_context *ctx,
372 int mode,
373 size_t length,
374 size_t *iv_off,
375 unsigned char iv[16],
376 const unsigned char *input,
377 unsigned char *output );
378
379/**
380 * \brief This function performs an AES-CFB8 encryption or decryption
381 * operation.
382 *
383 * It performs the operation defined in the \p mode
384 * parameter (encrypt/decrypt), on the input data buffer defined
385 * in the \p input parameter.
386 *
387 * Due to the nature of CFB, you must use the same key schedule for
388 * both encryption and decryption operations. Therefore, you must
389 * use the context initialized with mbedtls_aes_setkey_enc() for
390 * both #MBEDTLS_AES_ENCRYPT and #MBEDTLS_AES_DECRYPT.
391 *
392 * \note Upon exit, the content of the IV is updated so that you can
393 * call the same function again on the next
394 * block(s) of data and get the same result as if it was
395 * encrypted in one call. This allows a "streaming" usage.
396 * If you need to retain the contents of the
397 * IV, you should either save it manually or use the cipher
398 * module instead.
399 *
400 *
401 * \param ctx The AES context to use for encryption or decryption.
402 * \param mode The AES operation: #MBEDTLS_AES_ENCRYPT or
403 * #MBEDTLS_AES_DECRYPT
404 * \param length The length of the input data.
405 * \param iv The initialization vector (updated after use).
406 * \param input The buffer holding the input data.
407 * \param output The buffer holding the output data.
408 *
409 * \return \c 0 on success.
410 */
411int mbedtls_aes_crypt_cfb8( mbedtls_aes_context *ctx,
412 int mode,
413 size_t length,
414 unsigned char iv[16],
415 const unsigned char *input,
416 unsigned char *output );
417#endif /*MBEDTLS_CIPHER_MODE_CFB */
418
419#if defined(MBEDTLS_CIPHER_MODE_OFB)
420/**
421 * \brief This function performs an AES-OFB (Output Feedback Mode)
422 * encryption or decryption operation.
423 *
424 * For OFB, you must set up the context with
425 * mbedtls_aes_setkey_enc(), regardless of whether you are
426 * performing an encryption or decryption operation. This is
427 * because OFB mode uses the same key schedule for encryption and
428 * decryption.
429 *
430 * The OFB operation is identical for encryption or decryption,
431 * therefore no operation mode needs to be specified.
432 *
433 * \note Upon exit, the content of iv, the Initialisation Vector, is
434 * updated so that you can call the same function again on the next
435 * block(s) of data and get the same result as if it was encrypted
436 * in one call. This allows a "streaming" usage, by initialising
437 * iv_off to 0 before the first call, and preserving its value
438 * between calls.
439 *
440 * For non-streaming use, the iv should be initialised on each call
441 * to a unique value, and iv_off set to 0 on each call.
442 *
443 * If you need to retain the contents of the initialisation vector,
444 * you must either save it manually or use the cipher module
445 * instead.
446 *
447 * \warning For the OFB mode, the initialisation vector must be unique
448 * every encryption operation. Reuse of an initialisation vector
449 * will compromise security.
450 *
451 * \param ctx The AES context to use for encryption or decryption.
452 * \param length The length of the input data.
453 * \param iv_off The offset in IV (updated after use).
454 * \param iv The initialization vector (updated after use).
455 * \param input The buffer holding the input data.
456 * \param output The buffer holding the output data.
457 *
458 * \return \c 0 on success.
459 */
460int mbedtls_aes_crypt_ofb( mbedtls_aes_context *ctx,
461 size_t length,
462 size_t *iv_off,
463 unsigned char iv[16],
464 const unsigned char *input,
465 unsigned char *output );
466
467#endif /* MBEDTLS_CIPHER_MODE_OFB */
468
469#if defined(MBEDTLS_CIPHER_MODE_CTR)
470/**
471 * \brief This function performs an AES-CTR encryption or decryption
472 * operation.
473 *
474 * This function performs the operation defined in the \p mode
475 * parameter (encrypt/decrypt), on the input data buffer
476 * defined in the \p input parameter.
477 *
478 * Due to the nature of CTR, you must use the same key schedule
479 * for both encryption and decryption operations. Therefore, you
480 * must use the context initialized with mbedtls_aes_setkey_enc()
481 * for both #MBEDTLS_AES_ENCRYPT and #MBEDTLS_AES_DECRYPT.
482 *
483 * \warning You must never reuse a nonce value with the same key. Doing so
484 * would void the encryption for the two messages encrypted with
485 * the same nonce and key.
486 *
487 * There are two common strategies for managing nonces with CTR:
488 *
489 * 1. You can handle everything as a single message processed over
490 * successive calls to this function. In that case, you want to
491 * set \p nonce_counter and \p nc_off to 0 for the first call, and
492 * then preserve the values of \p nonce_counter, \p nc_off and \p
493 * stream_block across calls to this function as they will be
494 * updated by this function.
495 *
496 * With this strategy, you must not encrypt more than 2**128
497 * blocks of data with the same key.
498 *
499 * 2. You can encrypt separate messages by dividing the \p
500 * nonce_counter buffer in two areas: the first one used for a
501 * per-message nonce, handled by yourself, and the second one
502 * updated by this function internally.
503 *
504 * For example, you might reserve the first 12 bytes for the
505 * per-message nonce, and the last 4 bytes for internal use. In that
506 * case, before calling this function on a new message you need to
507 * set the first 12 bytes of \p nonce_counter to your chosen nonce
508 * value, the last 4 to 0, and \p nc_off to 0 (which will cause \p
509 * stream_block to be ignored). That way, you can encrypt at most
510 * 2**96 messages of up to 2**32 blocks each with the same key.
511 *
512 * The per-message nonce (or information sufficient to reconstruct
513 * it) needs to be communicated with the ciphertext and must be unique.
514 * The recommended way to ensure uniqueness is to use a message
515 * counter. An alternative is to generate random nonces, but this
516 * limits the number of messages that can be securely encrypted:
517 * for example, with 96-bit random nonces, you should not encrypt
518 * more than 2**32 messages with the same key.
519 *
520 * Note that for both stategies, sizes are measured in blocks and
521 * that an AES block is 16 bytes.
522 *
523 * \warning Upon return, \p stream_block contains sensitive data. Its
524 * content must not be written to insecure storage and should be
525 * securely discarded as soon as it's no longer needed.
526 *
527 * \param ctx The AES context to use for encryption or decryption.
528 * \param length The length of the input data.
529 * \param nc_off The offset in the current \p stream_block, for
530 * resuming within the current cipher stream. The
531 * offset pointer should be 0 at the start of a stream.
532 * \param nonce_counter The 128-bit nonce and counter.
533 * \param stream_block The saved stream block for resuming. This is
534 * overwritten by the function.
535 * \param input The buffer holding the input data.
536 * \param output The buffer holding the output data.
537 *
538 * \return \c 0 on success.
539 */
540int mbedtls_aes_crypt_ctr( mbedtls_aes_context *ctx,
541 size_t length,
542 size_t *nc_off,
543 unsigned char nonce_counter[16],
544 unsigned char stream_block[16],
545 const unsigned char *input,
546 unsigned char *output );
547#endif /* MBEDTLS_CIPHER_MODE_CTR */
548
549/**
550 * \brief Internal AES block encryption function. This is only
551 * exposed to allow overriding it using
552 * \c MBEDTLS_AES_ENCRYPT_ALT.
553 *
554 * \param ctx The AES context to use for encryption.
555 * \param input The plaintext block.
556 * \param output The output (ciphertext) block.
557 *
558 * \return \c 0 on success.
559 */
560int mbedtls_internal_aes_encrypt( mbedtls_aes_context *ctx,
561 const unsigned char input[16],
562 unsigned char output[16] );
563
564/**
565 * \brief Internal AES block decryption function. This is only
566 * exposed to allow overriding it using see
567 * \c MBEDTLS_AES_DECRYPT_ALT.
568 *
569 * \param ctx The AES context to use for decryption.
570 * \param input The ciphertext block.
571 * \param output The output (plaintext) block.
572 *
573 * \return \c 0 on success.
574 */
575int mbedtls_internal_aes_decrypt( mbedtls_aes_context *ctx,
576 const unsigned char input[16],
577 unsigned char output[16] );
578
579#if !defined(MBEDTLS_DEPRECATED_REMOVED)
580#if defined(MBEDTLS_DEPRECATED_WARNING)
581#define MBEDTLS_DEPRECATED __attribute__((deprecated))
582#else
583#define MBEDTLS_DEPRECATED
584#endif
585/**
586 * \brief Deprecated internal AES block encryption function
587 * without return value.
588 *
589 * \deprecated Superseded by mbedtls_aes_encrypt_ext() in 2.5.0.
590 *
591 * \param ctx The AES context to use for encryption.
592 * \param input Plaintext block.
593 * \param output Output (ciphertext) block.
594 */
595MBEDTLS_DEPRECATED void mbedtls_aes_encrypt( mbedtls_aes_context *ctx,
596 const unsigned char input[16],
597 unsigned char output[16] );
598
599/**
600 * \brief Deprecated internal AES block decryption function
601 * without return value.
602 *
603 * \deprecated Superseded by mbedtls_aes_decrypt_ext() in 2.5.0.
604 *
605 * \param ctx The AES context to use for decryption.
606 * \param input Ciphertext block.
607 * \param output Output (plaintext) block.
608 */
609MBEDTLS_DEPRECATED void mbedtls_aes_decrypt( mbedtls_aes_context *ctx,
610 const unsigned char input[16],
611 unsigned char output[16] );
612
613#undef MBEDTLS_DEPRECATED
614#endif /* !MBEDTLS_DEPRECATED_REMOVED */
615
616/**
617 * \brief Checkup routine.
618 *
619 * \return \c 0 on success.
620 * \return \c 1 on failure.
621 */
622int mbedtls_aes_self_test( int verbose );
623
624#ifdef __cplusplus
625}
626#endif
627
628#endif /* aes.h */
diff --git a/source/mbedtls/include/mbedtls/check_config.h b/source/mbedtls/include/mbedtls/check_config.h
deleted file mode 100644
index a4fa7bd..0000000
--- a/source/mbedtls/include/mbedtls/check_config.h
+++ /dev/null
@@ -1,685 +0,0 @@
1/**
2 * \file check_config.h
3 *
4 * \brief Consistency checks for configuration options
5 */
6/*
7 * Copyright (C) 2006-2018, ARM Limited, All Rights Reserved
8 * SPDX-License-Identifier: GPL-2.0
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License along
21 * with this program; if not, write to the Free Software Foundation, Inc.,
22 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
23 *
24 * This file is part of mbed TLS (https://tls.mbed.org)
25 */
26
27/*
28 * It is recommended to include this file from your config.h
29 * in order to catch dependency issues early.
30 */
31
32#ifndef MBEDTLS_CHECK_CONFIG_H
33#define MBEDTLS_CHECK_CONFIG_H
34
35/*
36 * We assume CHAR_BIT is 8 in many places. In practice, this is true on our
37 * target platforms, so not an issue, but let's just be extra sure.
38 */
39#include <limits.h>
40#if CHAR_BIT != 8
41#error "mbed TLS requires a platform with 8-bit chars"
42#endif
43
44#if defined(_WIN32)
45#if !defined(MBEDTLS_PLATFORM_C)
46#error "MBEDTLS_PLATFORM_C is required on Windows"
47#endif
48
49/* Fix the config here. Not convenient to put an #ifdef _WIN32 in config.h as
50 * it would confuse config.pl. */
51#if !defined(MBEDTLS_PLATFORM_SNPRINTF_ALT) && \
52 !defined(MBEDTLS_PLATFORM_SNPRINTF_MACRO)
53#define MBEDTLS_PLATFORM_SNPRINTF_ALT
54#endif
55#endif /* _WIN32 */
56
57#if defined(TARGET_LIKE_MBED) && \
58 ( defined(MBEDTLS_NET_C) || defined(MBEDTLS_TIMING_C) )
59#error "The NET and TIMING modules are not available for mbed OS - please use the network and timing functions provided by mbed OS"
60#endif
61
62#if defined(MBEDTLS_DEPRECATED_WARNING) && \
63 !defined(__GNUC__) && !defined(__clang__)
64#error "MBEDTLS_DEPRECATED_WARNING only works with GCC and Clang"
65#endif
66
67#if defined(MBEDTLS_HAVE_TIME_DATE) && !defined(MBEDTLS_HAVE_TIME)
68#error "MBEDTLS_HAVE_TIME_DATE without MBEDTLS_HAVE_TIME does not make sense"
69#endif
70
71#if defined(MBEDTLS_AESNI_C) && !defined(MBEDTLS_HAVE_ASM)
72#error "MBEDTLS_AESNI_C defined, but not all prerequisites"
73#endif
74
75#if defined(MBEDTLS_CTR_DRBG_C) && !defined(MBEDTLS_AES_C)
76#error "MBEDTLS_CTR_DRBG_C defined, but not all prerequisites"
77#endif
78
79#if defined(MBEDTLS_DHM_C) && !defined(MBEDTLS_BIGNUM_C)
80#error "MBEDTLS_DHM_C defined, but not all prerequisites"
81#endif
82
83#if defined(MBEDTLS_SSL_TRUNCATED_HMAC_COMPAT) && !defined(MBEDTLS_SSL_TRUNCATED_HMAC)
84#error "MBEDTLS_SSL_TRUNCATED_HMAC_COMPAT defined, but not all prerequisites"
85#endif
86
87#if defined(MBEDTLS_CMAC_C) && \
88 !defined(MBEDTLS_AES_C) && !defined(MBEDTLS_DES_C)
89#error "MBEDTLS_CMAC_C defined, but not all prerequisites"
90#endif
91
92#if defined(MBEDTLS_NIST_KW_C) && \
93 ( !defined(MBEDTLS_AES_C) || !defined(MBEDTLS_CIPHER_C) )
94#error "MBEDTLS_NIST_KW_C defined, but not all prerequisites"
95#endif
96
97#if defined(MBEDTLS_ECDH_C) && !defined(MBEDTLS_ECP_C)
98#error "MBEDTLS_ECDH_C defined, but not all prerequisites"
99#endif
100
101#if defined(MBEDTLS_ECDSA_C) && \
102 ( !defined(MBEDTLS_ECP_C) || \
103 !defined(MBEDTLS_ASN1_PARSE_C) || \
104 !defined(MBEDTLS_ASN1_WRITE_C) )
105#error "MBEDTLS_ECDSA_C defined, but not all prerequisites"
106#endif
107
108#if defined(MBEDTLS_ECJPAKE_C) && \
109 ( !defined(MBEDTLS_ECP_C) || !defined(MBEDTLS_MD_C) )
110#error "MBEDTLS_ECJPAKE_C defined, but not all prerequisites"
111#endif
112
113#if defined(MBEDTLS_ECDSA_DETERMINISTIC) && !defined(MBEDTLS_HMAC_DRBG_C)
114#error "MBEDTLS_ECDSA_DETERMINISTIC defined, but not all prerequisites"
115#endif
116
117#if defined(MBEDTLS_ECP_C) && ( !defined(MBEDTLS_BIGNUM_C) || ( \
118 !defined(MBEDTLS_ECP_DP_SECP192R1_ENABLED) && \
119 !defined(MBEDTLS_ECP_DP_SECP224R1_ENABLED) && \
120 !defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED) && \
121 !defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED) && \
122 !defined(MBEDTLS_ECP_DP_SECP521R1_ENABLED) && \
123 !defined(MBEDTLS_ECP_DP_BP256R1_ENABLED) && \
124 !defined(MBEDTLS_ECP_DP_BP384R1_ENABLED) && \
125 !defined(MBEDTLS_ECP_DP_BP512R1_ENABLED) && \
126 !defined(MBEDTLS_ECP_DP_SECP192K1_ENABLED) && \
127 !defined(MBEDTLS_ECP_DP_SECP224K1_ENABLED) && \
128 !defined(MBEDTLS_ECP_DP_SECP256K1_ENABLED) ) )
129#error "MBEDTLS_ECP_C defined, but not all prerequisites"
130#endif
131
132#if defined(MBEDTLS_ENTROPY_C) && (!defined(MBEDTLS_SHA512_C) && \
133 !defined(MBEDTLS_SHA256_C))
134#error "MBEDTLS_ENTROPY_C defined, but not all prerequisites"
135#endif
136#if defined(MBEDTLS_ENTROPY_C) && defined(MBEDTLS_SHA512_C) && \
137 defined(MBEDTLS_CTR_DRBG_ENTROPY_LEN) && (MBEDTLS_CTR_DRBG_ENTROPY_LEN > 64)
138#error "MBEDTLS_CTR_DRBG_ENTROPY_LEN value too high"
139#endif
140#if defined(MBEDTLS_ENTROPY_C) && \
141 ( !defined(MBEDTLS_SHA512_C) || defined(MBEDTLS_ENTROPY_FORCE_SHA256) ) \
142 && defined(MBEDTLS_CTR_DRBG_ENTROPY_LEN) && (MBEDTLS_CTR_DRBG_ENTROPY_LEN > 32)
143#error "MBEDTLS_CTR_DRBG_ENTROPY_LEN value too high"
144#endif
145#if defined(MBEDTLS_ENTROPY_C) && \
146 defined(MBEDTLS_ENTROPY_FORCE_SHA256) && !defined(MBEDTLS_SHA256_C)
147#error "MBEDTLS_ENTROPY_FORCE_SHA256 defined, but not all prerequisites"
148#endif
149
150#if defined(MBEDTLS_TEST_NULL_ENTROPY) && \
151 ( !defined(MBEDTLS_ENTROPY_C) || !defined(MBEDTLS_NO_DEFAULT_ENTROPY_SOURCES) )
152#error "MBEDTLS_TEST_NULL_ENTROPY defined, but not all prerequisites"
153#endif
154#if defined(MBEDTLS_TEST_NULL_ENTROPY) && \
155 ( defined(MBEDTLS_ENTROPY_NV_SEED) || defined(MBEDTLS_ENTROPY_HARDWARE_ALT) || \
156 defined(MBEDTLS_HAVEGE_C) )
157#error "MBEDTLS_TEST_NULL_ENTROPY defined, but entropy sources too"
158#endif
159
160#if defined(MBEDTLS_GCM_C) && ( \
161 !defined(MBEDTLS_AES_C) && !defined(MBEDTLS_CAMELLIA_C) )
162#error "MBEDTLS_GCM_C defined, but not all prerequisites"
163#endif
164
165#if defined(MBEDTLS_ECP_RANDOMIZE_JAC_ALT) && !defined(MBEDTLS_ECP_INTERNAL_ALT)
166#error "MBEDTLS_ECP_RANDOMIZE_JAC_ALT defined, but not all prerequisites"
167#endif
168
169#if defined(MBEDTLS_ECP_ADD_MIXED_ALT) && !defined(MBEDTLS_ECP_INTERNAL_ALT)
170#error "MBEDTLS_ECP_ADD_MIXED_ALT defined, but not all prerequisites"
171#endif
172
173#if defined(MBEDTLS_ECP_DOUBLE_JAC_ALT) && !defined(MBEDTLS_ECP_INTERNAL_ALT)
174#error "MBEDTLS_ECP_DOUBLE_JAC_ALT defined, but not all prerequisites"
175#endif
176
177#if defined(MBEDTLS_ECP_NORMALIZE_JAC_MANY_ALT) && !defined(MBEDTLS_ECP_INTERNAL_ALT)
178#error "MBEDTLS_ECP_NORMALIZE_JAC_MANY_ALT defined, but not all prerequisites"
179#endif
180
181#if defined(MBEDTLS_ECP_NORMALIZE_JAC_ALT) && !defined(MBEDTLS_ECP_INTERNAL_ALT)
182#error "MBEDTLS_ECP_NORMALIZE_JAC_ALT defined, but not all prerequisites"
183#endif
184
185#if defined(MBEDTLS_ECP_DOUBLE_ADD_MXZ_ALT) && !defined(MBEDTLS_ECP_INTERNAL_ALT)
186#error "MBEDTLS_ECP_DOUBLE_ADD_MXZ_ALT defined, but not all prerequisites"
187#endif
188
189#if defined(MBEDTLS_ECP_RANDOMIZE_MXZ_ALT) && !defined(MBEDTLS_ECP_INTERNAL_ALT)
190#error "MBEDTLS_ECP_RANDOMIZE_MXZ_ALT defined, but not all prerequisites"
191#endif
192
193#if defined(MBEDTLS_ECP_NORMALIZE_MXZ_ALT) && !defined(MBEDTLS_ECP_INTERNAL_ALT)
194#error "MBEDTLS_ECP_NORMALIZE_MXZ_ALT defined, but not all prerequisites"
195#endif
196
197#if defined(MBEDTLS_HAVEGE_C) && !defined(MBEDTLS_TIMING_C)
198#error "MBEDTLS_HAVEGE_C defined, but not all prerequisites"
199#endif
200
201#if defined(MBEDTLS_HKDF_C) && !defined(MBEDTLS_MD_C)
202#error "MBEDTLS_HKDF_C defined, but not all prerequisites"
203#endif
204
205#if defined(MBEDTLS_HMAC_DRBG_C) && !defined(MBEDTLS_MD_C)
206#error "MBEDTLS_HMAC_DRBG_C defined, but not all prerequisites"
207#endif
208
209#if defined(MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED) && \
210 ( !defined(MBEDTLS_ECDH_C) || !defined(MBEDTLS_X509_CRT_PARSE_C) )
211#error "MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA_ENABLED defined, but not all prerequisites"
212#endif
213
214#if defined(MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED) && \
215 ( !defined(MBEDTLS_ECDH_C) || !defined(MBEDTLS_X509_CRT_PARSE_C) )
216#error "MBEDTLS_KEY_EXCHANGE_ECDH_RSA_ENABLED defined, but not all prerequisites"
217#endif
218
219#if defined(MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED) && !defined(MBEDTLS_DHM_C)
220#error "MBEDTLS_KEY_EXCHANGE_DHE_PSK_ENABLED defined, but not all prerequisites"
221#endif
222
223#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED) && \
224 !defined(MBEDTLS_ECDH_C)
225#error "MBEDTLS_KEY_EXCHANGE_ECDHE_PSK_ENABLED defined, but not all prerequisites"
226#endif
227
228#if defined(MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED) && \
229 ( !defined(MBEDTLS_DHM_C) || !defined(MBEDTLS_RSA_C) || \
230 !defined(MBEDTLS_X509_CRT_PARSE_C) || !defined(MBEDTLS_PKCS1_V15) )
231#error "MBEDTLS_KEY_EXCHANGE_DHE_RSA_ENABLED defined, but not all prerequisites"
232#endif
233
234#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED) && \
235 ( !defined(MBEDTLS_ECDH_C) || !defined(MBEDTLS_RSA_C) || \
236 !defined(MBEDTLS_X509_CRT_PARSE_C) || !defined(MBEDTLS_PKCS1_V15) )
237#error "MBEDTLS_KEY_EXCHANGE_ECDHE_RSA_ENABLED defined, but not all prerequisites"
238#endif
239
240#if defined(MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED) && \
241 ( !defined(MBEDTLS_ECDH_C) || !defined(MBEDTLS_ECDSA_C) || \
242 !defined(MBEDTLS_X509_CRT_PARSE_C) )
243#error "MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED defined, but not all prerequisites"
244#endif
245
246#if defined(MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED) && \
247 ( !defined(MBEDTLS_RSA_C) || !defined(MBEDTLS_X509_CRT_PARSE_C) || \
248 !defined(MBEDTLS_PKCS1_V15) )
249#error "MBEDTLS_KEY_EXCHANGE_RSA_PSK_ENABLED defined, but not all prerequisites"
250#endif
251
252#if defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED) && \
253 ( !defined(MBEDTLS_RSA_C) || !defined(MBEDTLS_X509_CRT_PARSE_C) || \
254 !defined(MBEDTLS_PKCS1_V15) )
255#error "MBEDTLS_KEY_EXCHANGE_RSA_ENABLED defined, but not all prerequisites"
256#endif
257
258#if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED) && \
259 ( !defined(MBEDTLS_ECJPAKE_C) || !defined(MBEDTLS_SHA256_C) || \
260 !defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED) )
261#error "MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED defined, but not all prerequisites"
262#endif
263
264#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C) && \
265 ( !defined(MBEDTLS_PLATFORM_C) || !defined(MBEDTLS_PLATFORM_MEMORY) )
266#error "MBEDTLS_MEMORY_BUFFER_ALLOC_C defined, but not all prerequisites"
267#endif
268
269#if defined(MBEDTLS_PADLOCK_C) && !defined(MBEDTLS_HAVE_ASM)
270#error "MBEDTLS_PADLOCK_C defined, but not all prerequisites"
271#endif
272
273#if defined(MBEDTLS_PEM_PARSE_C) && !defined(MBEDTLS_BASE64_C)
274#error "MBEDTLS_PEM_PARSE_C defined, but not all prerequisites"
275#endif
276
277#if defined(MBEDTLS_PEM_WRITE_C) && !defined(MBEDTLS_BASE64_C)
278#error "MBEDTLS_PEM_WRITE_C defined, but not all prerequisites"
279#endif
280
281#if defined(MBEDTLS_PK_C) && \
282 ( !defined(MBEDTLS_RSA_C) && !defined(MBEDTLS_ECP_C) )
283#error "MBEDTLS_PK_C defined, but not all prerequisites"
284#endif
285
286#if defined(MBEDTLS_PK_PARSE_C) && !defined(MBEDTLS_PK_C)
287#error "MBEDTLS_PK_PARSE_C defined, but not all prerequisites"
288#endif
289
290#if defined(MBEDTLS_PK_WRITE_C) && !defined(MBEDTLS_PK_C)
291#error "MBEDTLS_PK_WRITE_C defined, but not all prerequisites"
292#endif
293
294#if defined(MBEDTLS_PKCS11_C) && !defined(MBEDTLS_PK_C)
295#error "MBEDTLS_PKCS11_C defined, but not all prerequisites"
296#endif
297
298#if defined(MBEDTLS_PLATFORM_EXIT_ALT) && !defined(MBEDTLS_PLATFORM_C)
299#error "MBEDTLS_PLATFORM_EXIT_ALT defined, but not all prerequisites"
300#endif
301
302#if defined(MBEDTLS_PLATFORM_EXIT_MACRO) && !defined(MBEDTLS_PLATFORM_C)
303#error "MBEDTLS_PLATFORM_EXIT_MACRO defined, but not all prerequisites"
304#endif
305
306#if defined(MBEDTLS_PLATFORM_EXIT_MACRO) &&\
307 ( defined(MBEDTLS_PLATFORM_STD_EXIT) ||\
308 defined(MBEDTLS_PLATFORM_EXIT_ALT) )
309#error "MBEDTLS_PLATFORM_EXIT_MACRO and MBEDTLS_PLATFORM_STD_EXIT/MBEDTLS_PLATFORM_EXIT_ALT cannot be defined simultaneously"
310#endif
311
312#if defined(MBEDTLS_PLATFORM_TIME_ALT) &&\
313 ( !defined(MBEDTLS_PLATFORM_C) ||\
314 !defined(MBEDTLS_HAVE_TIME) )
315#error "MBEDTLS_PLATFORM_TIME_ALT defined, but not all prerequisites"
316#endif
317
318#if defined(MBEDTLS_PLATFORM_TIME_MACRO) &&\
319 ( !defined(MBEDTLS_PLATFORM_C) ||\
320 !defined(MBEDTLS_HAVE_TIME) )
321#error "MBEDTLS_PLATFORM_TIME_MACRO defined, but not all prerequisites"
322#endif
323
324#if defined(MBEDTLS_PLATFORM_TIME_TYPE_MACRO) &&\
325 ( !defined(MBEDTLS_PLATFORM_C) ||\
326 !defined(MBEDTLS_HAVE_TIME) )
327#error "MBEDTLS_PLATFORM_TIME_TYPE_MACRO defined, but not all prerequisites"
328#endif
329
330#if defined(MBEDTLS_PLATFORM_TIME_MACRO) &&\
331 ( defined(MBEDTLS_PLATFORM_STD_TIME) ||\
332 defined(MBEDTLS_PLATFORM_TIME_ALT) )
333#error "MBEDTLS_PLATFORM_TIME_MACRO and MBEDTLS_PLATFORM_STD_TIME/MBEDTLS_PLATFORM_TIME_ALT cannot be defined simultaneously"
334#endif
335
336#if defined(MBEDTLS_PLATFORM_TIME_TYPE_MACRO) &&\
337 ( defined(MBEDTLS_PLATFORM_STD_TIME) ||\
338 defined(MBEDTLS_PLATFORM_TIME_ALT) )
339#error "MBEDTLS_PLATFORM_TIME_TYPE_MACRO and MBEDTLS_PLATFORM_STD_TIME/MBEDTLS_PLATFORM_TIME_ALT cannot be defined simultaneously"
340#endif
341
342#if defined(MBEDTLS_PLATFORM_FPRINTF_ALT) && !defined(MBEDTLS_PLATFORM_C)
343#error "MBEDTLS_PLATFORM_FPRINTF_ALT defined, but not all prerequisites"
344#endif
345
346#if defined(MBEDTLS_PLATFORM_FPRINTF_MACRO) && !defined(MBEDTLS_PLATFORM_C)
347#error "MBEDTLS_PLATFORM_FPRINTF_MACRO defined, but not all prerequisites"
348#endif
349
350#if defined(MBEDTLS_PLATFORM_FPRINTF_MACRO) &&\
351 ( defined(MBEDTLS_PLATFORM_STD_FPRINTF) ||\
352 defined(MBEDTLS_PLATFORM_FPRINTF_ALT) )
353#error "MBEDTLS_PLATFORM_FPRINTF_MACRO and MBEDTLS_PLATFORM_STD_FPRINTF/MBEDTLS_PLATFORM_FPRINTF_ALT cannot be defined simultaneously"
354#endif
355
356#if defined(MBEDTLS_PLATFORM_FREE_MACRO) &&\
357 ( !defined(MBEDTLS_PLATFORM_C) || !defined(MBEDTLS_PLATFORM_MEMORY) )
358#error "MBEDTLS_PLATFORM_FREE_MACRO defined, but not all prerequisites"
359#endif
360
361#if defined(MBEDTLS_PLATFORM_FREE_MACRO) &&\
362 defined(MBEDTLS_PLATFORM_STD_FREE)
363#error "MBEDTLS_PLATFORM_FREE_MACRO and MBEDTLS_PLATFORM_STD_FREE cannot be defined simultaneously"
364#endif
365
366#if defined(MBEDTLS_PLATFORM_FREE_MACRO) && !defined(MBEDTLS_PLATFORM_CALLOC_MACRO)
367#error "MBEDTLS_PLATFORM_CALLOC_MACRO must be defined if MBEDTLS_PLATFORM_FREE_MACRO is"
368#endif
369
370#if defined(MBEDTLS_PLATFORM_CALLOC_MACRO) &&\
371 ( !defined(MBEDTLS_PLATFORM_C) || !defined(MBEDTLS_PLATFORM_MEMORY) )
372#error "MBEDTLS_PLATFORM_CALLOC_MACRO defined, but not all prerequisites"
373#endif
374
375#if defined(MBEDTLS_PLATFORM_CALLOC_MACRO) &&\
376 defined(MBEDTLS_PLATFORM_STD_CALLOC)
377#error "MBEDTLS_PLATFORM_CALLOC_MACRO and MBEDTLS_PLATFORM_STD_CALLOC cannot be defined simultaneously"
378#endif
379
380#if defined(MBEDTLS_PLATFORM_CALLOC_MACRO) && !defined(MBEDTLS_PLATFORM_FREE_MACRO)
381#error "MBEDTLS_PLATFORM_FREE_MACRO must be defined if MBEDTLS_PLATFORM_CALLOC_MACRO is"
382#endif
383
384#if defined(MBEDTLS_PLATFORM_MEMORY) && !defined(MBEDTLS_PLATFORM_C)
385#error "MBEDTLS_PLATFORM_MEMORY defined, but not all prerequisites"
386#endif
387
388#if defined(MBEDTLS_PLATFORM_PRINTF_ALT) && !defined(MBEDTLS_PLATFORM_C)
389#error "MBEDTLS_PLATFORM_PRINTF_ALT defined, but not all prerequisites"
390#endif
391
392#if defined(MBEDTLS_PLATFORM_PRINTF_MACRO) && !defined(MBEDTLS_PLATFORM_C)
393#error "MBEDTLS_PLATFORM_PRINTF_MACRO defined, but not all prerequisites"
394#endif
395
396#if defined(MBEDTLS_PLATFORM_PRINTF_MACRO) &&\
397 ( defined(MBEDTLS_PLATFORM_STD_PRINTF) ||\
398 defined(MBEDTLS_PLATFORM_PRINTF_ALT) )
399#error "MBEDTLS_PLATFORM_PRINTF_MACRO and MBEDTLS_PLATFORM_STD_PRINTF/MBEDTLS_PLATFORM_PRINTF_ALT cannot be defined simultaneously"
400#endif
401
402#if defined(MBEDTLS_PLATFORM_SNPRINTF_ALT) && !defined(MBEDTLS_PLATFORM_C)
403#error "MBEDTLS_PLATFORM_SNPRINTF_ALT defined, but not all prerequisites"
404#endif
405
406#if defined(MBEDTLS_PLATFORM_SNPRINTF_MACRO) && !defined(MBEDTLS_PLATFORM_C)
407#error "MBEDTLS_PLATFORM_SNPRINTF_MACRO defined, but not all prerequisites"
408#endif
409
410#if defined(MBEDTLS_PLATFORM_SNPRINTF_MACRO) &&\
411 ( defined(MBEDTLS_PLATFORM_STD_SNPRINTF) ||\
412 defined(MBEDTLS_PLATFORM_SNPRINTF_ALT) )
413#error "MBEDTLS_PLATFORM_SNPRINTF_MACRO and MBEDTLS_PLATFORM_STD_SNPRINTF/MBEDTLS_PLATFORM_SNPRINTF_ALT cannot be defined simultaneously"
414#endif
415
416#if defined(MBEDTLS_PLATFORM_STD_MEM_HDR) &&\
417 !defined(MBEDTLS_PLATFORM_NO_STD_FUNCTIONS)
418#error "MBEDTLS_PLATFORM_STD_MEM_HDR defined, but not all prerequisites"
419#endif
420
421#if defined(MBEDTLS_PLATFORM_STD_CALLOC) && !defined(MBEDTLS_PLATFORM_MEMORY)
422#error "MBEDTLS_PLATFORM_STD_CALLOC defined, but not all prerequisites"
423#endif
424
425#if defined(MBEDTLS_PLATFORM_STD_CALLOC) && !defined(MBEDTLS_PLATFORM_MEMORY)
426#error "MBEDTLS_PLATFORM_STD_CALLOC defined, but not all prerequisites"
427#endif
428
429#if defined(MBEDTLS_PLATFORM_STD_FREE) && !defined(MBEDTLS_PLATFORM_MEMORY)
430#error "MBEDTLS_PLATFORM_STD_FREE defined, but not all prerequisites"
431#endif
432
433#if defined(MBEDTLS_PLATFORM_STD_EXIT) &&\
434 !defined(MBEDTLS_PLATFORM_EXIT_ALT)
435#error "MBEDTLS_PLATFORM_STD_EXIT defined, but not all prerequisites"
436#endif
437
438#if defined(MBEDTLS_PLATFORM_STD_TIME) &&\
439 ( !defined(MBEDTLS_PLATFORM_TIME_ALT) ||\
440 !defined(MBEDTLS_HAVE_TIME) )
441#error "MBEDTLS_PLATFORM_STD_TIME defined, but not all prerequisites"
442#endif
443
444#if defined(MBEDTLS_PLATFORM_STD_FPRINTF) &&\
445 !defined(MBEDTLS_PLATFORM_FPRINTF_ALT)
446#error "MBEDTLS_PLATFORM_STD_FPRINTF defined, but not all prerequisites"
447#endif
448
449#if defined(MBEDTLS_PLATFORM_STD_PRINTF) &&\
450 !defined(MBEDTLS_PLATFORM_PRINTF_ALT)
451#error "MBEDTLS_PLATFORM_STD_PRINTF defined, but not all prerequisites"
452#endif
453
454#if defined(MBEDTLS_PLATFORM_STD_SNPRINTF) &&\
455 !defined(MBEDTLS_PLATFORM_SNPRINTF_ALT)
456#error "MBEDTLS_PLATFORM_STD_SNPRINTF defined, but not all prerequisites"
457#endif
458
459#if defined(MBEDTLS_ENTROPY_NV_SEED) &&\
460 ( !defined(MBEDTLS_PLATFORM_C) || !defined(MBEDTLS_ENTROPY_C) )
461#error "MBEDTLS_ENTROPY_NV_SEED defined, but not all prerequisites"
462#endif
463
464#if defined(MBEDTLS_PLATFORM_NV_SEED_ALT) &&\
465 !defined(MBEDTLS_ENTROPY_NV_SEED)
466#error "MBEDTLS_PLATFORM_NV_SEED_ALT defined, but not all prerequisites"
467#endif
468
469#if defined(MBEDTLS_PLATFORM_STD_NV_SEED_READ) &&\
470 !defined(MBEDTLS_PLATFORM_NV_SEED_ALT)
471#error "MBEDTLS_PLATFORM_STD_NV_SEED_READ defined, but not all prerequisites"
472#endif
473
474#if defined(MBEDTLS_PLATFORM_STD_NV_SEED_WRITE) &&\
475 !defined(MBEDTLS_PLATFORM_NV_SEED_ALT)
476#error "MBEDTLS_PLATFORM_STD_NV_SEED_WRITE defined, but not all prerequisites"
477#endif
478
479#if defined(MBEDTLS_PLATFORM_NV_SEED_READ_MACRO) &&\
480 ( defined(MBEDTLS_PLATFORM_STD_NV_SEED_READ) ||\
481 defined(MBEDTLS_PLATFORM_NV_SEED_ALT) )
482#error "MBEDTLS_PLATFORM_NV_SEED_READ_MACRO and MBEDTLS_PLATFORM_STD_NV_SEED_READ cannot be defined simultaneously"
483#endif
484
485#if defined(MBEDTLS_PLATFORM_NV_SEED_WRITE_MACRO) &&\
486 ( defined(MBEDTLS_PLATFORM_STD_NV_SEED_WRITE) ||\
487 defined(MBEDTLS_PLATFORM_NV_SEED_ALT) )
488#error "MBEDTLS_PLATFORM_NV_SEED_WRITE_MACRO and MBEDTLS_PLATFORM_STD_NV_SEED_WRITE cannot be defined simultaneously"
489#endif
490
491#if defined(MBEDTLS_RSA_C) && ( !defined(MBEDTLS_BIGNUM_C) || \
492 !defined(MBEDTLS_OID_C) )
493#error "MBEDTLS_RSA_C defined, but not all prerequisites"
494#endif
495
496#if defined(MBEDTLS_RSA_C) && ( !defined(MBEDTLS_PKCS1_V21) && \
497 !defined(MBEDTLS_PKCS1_V15) )
498#error "MBEDTLS_RSA_C defined, but none of the PKCS1 versions enabled"
499#endif
500
501#if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT) && \
502 ( !defined(MBEDTLS_RSA_C) || !defined(MBEDTLS_PKCS1_V21) )
503#error "MBEDTLS_X509_RSASSA_PSS_SUPPORT defined, but not all prerequisites"
504#endif
505
506#if defined(MBEDTLS_SSL_PROTO_SSL3) && ( !defined(MBEDTLS_MD5_C) || \
507 !defined(MBEDTLS_SHA1_C) )
508#error "MBEDTLS_SSL_PROTO_SSL3 defined, but not all prerequisites"
509#endif
510
511#if defined(MBEDTLS_SSL_PROTO_TLS1) && ( !defined(MBEDTLS_MD5_C) || \
512 !defined(MBEDTLS_SHA1_C) )
513#error "MBEDTLS_SSL_PROTO_TLS1 defined, but not all prerequisites"
514#endif
515
516#if defined(MBEDTLS_SSL_PROTO_TLS1_1) && ( !defined(MBEDTLS_MD5_C) || \
517 !defined(MBEDTLS_SHA1_C) )
518#error "MBEDTLS_SSL_PROTO_TLS1_1 defined, but not all prerequisites"
519#endif
520
521#if defined(MBEDTLS_SSL_PROTO_TLS1_2) && ( !defined(MBEDTLS_SHA1_C) && \
522 !defined(MBEDTLS_SHA256_C) && !defined(MBEDTLS_SHA512_C) )
523#error "MBEDTLS_SSL_PROTO_TLS1_2 defined, but not all prerequisites"
524#endif
525
526#if defined(MBEDTLS_SSL_PROTO_DTLS) && \
527 !defined(MBEDTLS_SSL_PROTO_TLS1_1) && \
528 !defined(MBEDTLS_SSL_PROTO_TLS1_2)
529#error "MBEDTLS_SSL_PROTO_DTLS defined, but not all prerequisites"
530#endif
531
532#if defined(MBEDTLS_SSL_CLI_C) && !defined(MBEDTLS_SSL_TLS_C)
533#error "MBEDTLS_SSL_CLI_C defined, but not all prerequisites"
534#endif
535
536#if defined(MBEDTLS_SSL_TLS_C) && ( !defined(MBEDTLS_CIPHER_C) || \
537 !defined(MBEDTLS_MD_C) )
538#error "MBEDTLS_SSL_TLS_C defined, but not all prerequisites"
539#endif
540
541#if defined(MBEDTLS_SSL_SRV_C) && !defined(MBEDTLS_SSL_TLS_C)
542#error "MBEDTLS_SSL_SRV_C defined, but not all prerequisites"
543#endif
544
545#if defined(MBEDTLS_SSL_TLS_C) && (!defined(MBEDTLS_SSL_PROTO_SSL3) && \
546 !defined(MBEDTLS_SSL_PROTO_TLS1) && !defined(MBEDTLS_SSL_PROTO_TLS1_1) && \
547 !defined(MBEDTLS_SSL_PROTO_TLS1_2))
548#error "MBEDTLS_SSL_TLS_C defined, but no protocols are active"
549#endif
550
551#if defined(MBEDTLS_SSL_TLS_C) && (defined(MBEDTLS_SSL_PROTO_SSL3) && \
552 defined(MBEDTLS_SSL_PROTO_TLS1_1) && !defined(MBEDTLS_SSL_PROTO_TLS1))
553#error "Illegal protocol selection"
554#endif
555
556#if defined(MBEDTLS_SSL_TLS_C) && (defined(MBEDTLS_SSL_PROTO_TLS1) && \
557 defined(MBEDTLS_SSL_PROTO_TLS1_2) && !defined(MBEDTLS_SSL_PROTO_TLS1_1))
558#error "Illegal protocol selection"
559#endif
560
561#if defined(MBEDTLS_SSL_TLS_C) && (defined(MBEDTLS_SSL_PROTO_SSL3) && \
562 defined(MBEDTLS_SSL_PROTO_TLS1_2) && (!defined(MBEDTLS_SSL_PROTO_TLS1) || \
563 !defined(MBEDTLS_SSL_PROTO_TLS1_1)))
564#error "Illegal protocol selection"
565#endif
566
567#if defined(MBEDTLS_SSL_DTLS_HELLO_VERIFY) && !defined(MBEDTLS_SSL_PROTO_DTLS)
568#error "MBEDTLS_SSL_DTLS_HELLO_VERIFY defined, but not all prerequisites"
569#endif
570
571#if defined(MBEDTLS_SSL_DTLS_CLIENT_PORT_REUSE) && \
572 !defined(MBEDTLS_SSL_DTLS_HELLO_VERIFY)
573#error "MBEDTLS_SSL_DTLS_CLIENT_PORT_REUSE defined, but not all prerequisites"
574#endif
575
576#if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY) && \
577 ( !defined(MBEDTLS_SSL_TLS_C) || !defined(MBEDTLS_SSL_PROTO_DTLS) )
578#error "MBEDTLS_SSL_DTLS_ANTI_REPLAY defined, but not all prerequisites"
579#endif
580
581#if defined(MBEDTLS_SSL_DTLS_BADMAC_LIMIT) && \
582 ( !defined(MBEDTLS_SSL_TLS_C) || !defined(MBEDTLS_SSL_PROTO_DTLS) )
583#error "MBEDTLS_SSL_DTLS_BADMAC_LIMIT defined, but not all prerequisites"
584#endif
585
586#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC) && \
587 !defined(MBEDTLS_SSL_PROTO_TLS1) && \
588 !defined(MBEDTLS_SSL_PROTO_TLS1_1) && \
589 !defined(MBEDTLS_SSL_PROTO_TLS1_2)
590#error "MBEDTLS_SSL_ENCRYPT_THEN_MAC defined, but not all prerequsites"
591#endif
592
593#if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET) && \
594 !defined(MBEDTLS_SSL_PROTO_TLS1) && \
595 !defined(MBEDTLS_SSL_PROTO_TLS1_1) && \
596 !defined(MBEDTLS_SSL_PROTO_TLS1_2)
597#error "MBEDTLS_SSL_EXTENDED_MASTER_SECRET defined, but not all prerequsites"
598#endif
599
600#if defined(MBEDTLS_SSL_TICKET_C) && !defined(MBEDTLS_CIPHER_C)
601#error "MBEDTLS_SSL_TICKET_C defined, but not all prerequisites"
602#endif
603
604#if defined(MBEDTLS_SSL_CBC_RECORD_SPLITTING) && \
605 !defined(MBEDTLS_SSL_PROTO_SSL3) && !defined(MBEDTLS_SSL_PROTO_TLS1)
606#error "MBEDTLS_SSL_CBC_RECORD_SPLITTING defined, but not all prerequisites"
607#endif
608
609#if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION) && \
610 !defined(MBEDTLS_X509_CRT_PARSE_C)
611#error "MBEDTLS_SSL_SERVER_NAME_INDICATION defined, but not all prerequisites"
612#endif
613
614#if defined(MBEDTLS_THREADING_PTHREAD)
615#if !defined(MBEDTLS_THREADING_C) || defined(MBEDTLS_THREADING_IMPL)
616#error "MBEDTLS_THREADING_PTHREAD defined, but not all prerequisites"
617#endif
618#define MBEDTLS_THREADING_IMPL
619#endif
620
621#if defined(MBEDTLS_THREADING_ALT)
622#if !defined(MBEDTLS_THREADING_C) || defined(MBEDTLS_THREADING_IMPL)
623#error "MBEDTLS_THREADING_ALT defined, but not all prerequisites"
624#endif
625#define MBEDTLS_THREADING_IMPL
626#endif
627
628#if defined(MBEDTLS_THREADING_C) && !defined(MBEDTLS_THREADING_IMPL)
629#error "MBEDTLS_THREADING_C defined, single threading implementation required"
630#endif
631#undef MBEDTLS_THREADING_IMPL
632
633#if defined(MBEDTLS_VERSION_FEATURES) && !defined(MBEDTLS_VERSION_C)
634#error "MBEDTLS_VERSION_FEATURES defined, but not all prerequisites"
635#endif
636
637#if defined(MBEDTLS_X509_USE_C) && ( !defined(MBEDTLS_BIGNUM_C) || \
638 !defined(MBEDTLS_OID_C) || !defined(MBEDTLS_ASN1_PARSE_C) || \
639 !defined(MBEDTLS_PK_PARSE_C) )
640#error "MBEDTLS_X509_USE_C defined, but not all prerequisites"
641#endif
642
643#if defined(MBEDTLS_X509_CREATE_C) && ( !defined(MBEDTLS_BIGNUM_C) || \
644 !defined(MBEDTLS_OID_C) || !defined(MBEDTLS_ASN1_WRITE_C) || \
645 !defined(MBEDTLS_PK_WRITE_C) )
646#error "MBEDTLS_X509_CREATE_C defined, but not all prerequisites"
647#endif
648
649#if defined(MBEDTLS_X509_CRT_PARSE_C) && ( !defined(MBEDTLS_X509_USE_C) )
650#error "MBEDTLS_X509_CRT_PARSE_C defined, but not all prerequisites"
651#endif
652
653#if defined(MBEDTLS_X509_CRL_PARSE_C) && ( !defined(MBEDTLS_X509_USE_C) )
654#error "MBEDTLS_X509_CRL_PARSE_C defined, but not all prerequisites"
655#endif
656
657#if defined(MBEDTLS_X509_CSR_PARSE_C) && ( !defined(MBEDTLS_X509_USE_C) )
658#error "MBEDTLS_X509_CSR_PARSE_C defined, but not all prerequisites"
659#endif
660
661#if defined(MBEDTLS_X509_CRT_WRITE_C) && ( !defined(MBEDTLS_X509_CREATE_C) )
662#error "MBEDTLS_X509_CRT_WRITE_C defined, but not all prerequisites"
663#endif
664
665#if defined(MBEDTLS_X509_CSR_WRITE_C) && ( !defined(MBEDTLS_X509_CREATE_C) )
666#error "MBEDTLS_X509_CSR_WRITE_C defined, but not all prerequisites"
667#endif
668
669#if defined(MBEDTLS_HAVE_INT32) && defined(MBEDTLS_HAVE_INT64)
670#error "MBEDTLS_HAVE_INT32 and MBEDTLS_HAVE_INT64 cannot be defined simultaneously"
671#endif /* MBEDTLS_HAVE_INT32 && MBEDTLS_HAVE_INT64 */
672
673#if ( defined(MBEDTLS_HAVE_INT32) || defined(MBEDTLS_HAVE_INT64) ) && \
674 defined(MBEDTLS_HAVE_ASM)
675#error "MBEDTLS_HAVE_INT32/MBEDTLS_HAVE_INT64 and MBEDTLS_HAVE_ASM cannot be defined simultaneously"
676#endif /* (MBEDTLS_HAVE_INT32 || MBEDTLS_HAVE_INT64) && MBEDTLS_HAVE_ASM */
677
678/*
679 * Avoid warning from -pedantic. This is a convenient place for this
680 * workaround since this is included by every single file before the
681 * #if defined(MBEDTLS_xxx_C) that results in emtpy translation units.
682 */
683typedef int mbedtls_iso_c_forbids_empty_translation_units;
684
685#endif /* MBEDTLS_CHECK_CONFIG_H */
diff --git a/source/mbedtls/include/mbedtls/cipher.h b/source/mbedtls/include/mbedtls/cipher.h
deleted file mode 100644
index 9e3832d..0000000
--- a/source/mbedtls/include/mbedtls/cipher.h
+++ /dev/null
@@ -1,808 +0,0 @@
1/**
2 * \file cipher.h
3 *
4 * \brief This file contains an abstraction interface for use with the cipher
5 * primitives provided by the library. It provides a common interface to all of
6 * the available cipher operations.
7 *
8 * \author Adriaan de Jong <dejong@fox-it.com>
9 */
10/*
11 * Copyright (C) 2006-2018, Arm Limited (or its affiliates), All Rights Reserved
12 * SPDX-License-Identifier: GPL-2.0
13 *
14 * This program is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; either version 2 of the License, or
17 * (at your option) any later version.
18 *
19 * This program is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details.
23 *
24 * You should have received a copy of the GNU General Public License along
25 * with this program; if not, write to the Free Software Foundation, Inc.,
26 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
27 *
28 * This file is part of Mbed TLS (https://tls.mbed.org)
29 */
30
31#ifndef MBEDTLS_CIPHER_H
32#define MBEDTLS_CIPHER_H
33
34#if !defined(MBEDTLS_CONFIG_FILE)
35#include "config.h"
36#else
37#include MBEDTLS_CONFIG_FILE
38#endif
39
40#include <stddef.h>
41
42#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
43#define MBEDTLS_CIPHER_MODE_AEAD
44#endif
45
46#if defined(MBEDTLS_CIPHER_MODE_CBC)
47#define MBEDTLS_CIPHER_MODE_WITH_PADDING
48#endif
49
50#if defined(MBEDTLS_ARC4_C) || defined(MBEDTLS_CIPHER_NULL_CIPHER) || \
51 defined(MBEDTLS_CHACHA20_C)
52#define MBEDTLS_CIPHER_MODE_STREAM
53#endif
54
55#if ( defined(__ARMCC_VERSION) || defined(_MSC_VER) ) && \
56 !defined(inline) && !defined(__cplusplus)
57#define inline __inline
58#endif
59
60#define MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE -0x6080 /**< The selected feature is not available. */
61#define MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA -0x6100 /**< Bad input parameters. */
62#define MBEDTLS_ERR_CIPHER_ALLOC_FAILED -0x6180 /**< Failed to allocate memory. */
63#define MBEDTLS_ERR_CIPHER_INVALID_PADDING -0x6200 /**< Input data contains invalid padding and is rejected. */
64#define MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED -0x6280 /**< Decryption of block requires a full block. */
65#define MBEDTLS_ERR_CIPHER_AUTH_FAILED -0x6300 /**< Authentication failed (for AEAD modes). */
66#define MBEDTLS_ERR_CIPHER_INVALID_CONTEXT -0x6380 /**< The context is invalid. For example, because it was freed. */
67#define MBEDTLS_ERR_CIPHER_HW_ACCEL_FAILED -0x6400 /**< Cipher hardware accelerator failed. */
68
69#define MBEDTLS_CIPHER_VARIABLE_IV_LEN 0x01 /**< Cipher accepts IVs of variable length. */
70#define MBEDTLS_CIPHER_VARIABLE_KEY_LEN 0x02 /**< Cipher accepts keys of variable length. */
71
72#ifdef __cplusplus
73extern "C" {
74#endif
75
76/**
77 * \brief Supported cipher types.
78 *
79 * \warning RC4 and DES are considered weak ciphers and their use
80 * constitutes a security risk. Arm recommends considering stronger
81 * ciphers instead.
82 */
83typedef enum {
84 MBEDTLS_CIPHER_ID_NONE = 0, /**< Placeholder to mark the end of cipher ID lists. */
85 MBEDTLS_CIPHER_ID_NULL, /**< The identity cipher, treated as a stream cipher. */
86 MBEDTLS_CIPHER_ID_AES, /**< The AES cipher. */
87 MBEDTLS_CIPHER_ID_DES, /**< The DES cipher. */
88 MBEDTLS_CIPHER_ID_3DES, /**< The Triple DES cipher. */
89 MBEDTLS_CIPHER_ID_CAMELLIA, /**< The Camellia cipher. */
90 MBEDTLS_CIPHER_ID_BLOWFISH, /**< The Blowfish cipher. */
91 MBEDTLS_CIPHER_ID_ARC4, /**< The RC4 cipher. */
92 MBEDTLS_CIPHER_ID_ARIA, /**< The Aria cipher. */
93 MBEDTLS_CIPHER_ID_CHACHA20, /**< The ChaCha20 cipher. */
94} mbedtls_cipher_id_t;
95
96/**
97 * \brief Supported {cipher type, cipher mode} pairs.
98 *
99 * \warning RC4 and DES are considered weak ciphers and their use
100 * constitutes a security risk. Arm recommends considering stronger
101 * ciphers instead.
102 */
103typedef enum {
104 MBEDTLS_CIPHER_NONE = 0, /**< Placeholder to mark the end of cipher-pair lists. */
105 MBEDTLS_CIPHER_NULL, /**< The identity stream cipher. */
106 MBEDTLS_CIPHER_AES_128_ECB, /**< AES cipher with 128-bit ECB mode. */
107 MBEDTLS_CIPHER_AES_192_ECB, /**< AES cipher with 192-bit ECB mode. */
108 MBEDTLS_CIPHER_AES_256_ECB, /**< AES cipher with 256-bit ECB mode. */
109 MBEDTLS_CIPHER_AES_128_CBC, /**< AES cipher with 128-bit CBC mode. */
110 MBEDTLS_CIPHER_AES_192_CBC, /**< AES cipher with 192-bit CBC mode. */
111 MBEDTLS_CIPHER_AES_256_CBC, /**< AES cipher with 256-bit CBC mode. */
112 MBEDTLS_CIPHER_AES_128_CFB128, /**< AES cipher with 128-bit CFB128 mode. */
113 MBEDTLS_CIPHER_AES_192_CFB128, /**< AES cipher with 192-bit CFB128 mode. */
114 MBEDTLS_CIPHER_AES_256_CFB128, /**< AES cipher with 256-bit CFB128 mode. */
115 MBEDTLS_CIPHER_AES_128_CTR, /**< AES cipher with 128-bit CTR mode. */
116 MBEDTLS_CIPHER_AES_192_CTR, /**< AES cipher with 192-bit CTR mode. */
117 MBEDTLS_CIPHER_AES_256_CTR, /**< AES cipher with 256-bit CTR mode. */
118 MBEDTLS_CIPHER_AES_128_GCM, /**< AES cipher with 128-bit GCM mode. */
119 MBEDTLS_CIPHER_AES_192_GCM, /**< AES cipher with 192-bit GCM mode. */
120 MBEDTLS_CIPHER_AES_256_GCM, /**< AES cipher with 256-bit GCM mode. */
121 MBEDTLS_CIPHER_CAMELLIA_128_ECB, /**< Camellia cipher with 128-bit ECB mode. */
122 MBEDTLS_CIPHER_CAMELLIA_192_ECB, /**< Camellia cipher with 192-bit ECB mode. */
123 MBEDTLS_CIPHER_CAMELLIA_256_ECB, /**< Camellia cipher with 256-bit ECB mode. */
124 MBEDTLS_CIPHER_CAMELLIA_128_CBC, /**< Camellia cipher with 128-bit CBC mode. */
125 MBEDTLS_CIPHER_CAMELLIA_192_CBC, /**< Camellia cipher with 192-bit CBC mode. */
126 MBEDTLS_CIPHER_CAMELLIA_256_CBC, /**< Camellia cipher with 256-bit CBC mode. */
127 MBEDTLS_CIPHER_CAMELLIA_128_CFB128, /**< Camellia cipher with 128-bit CFB128 mode. */
128 MBEDTLS_CIPHER_CAMELLIA_192_CFB128, /**< Camellia cipher with 192-bit CFB128 mode. */
129 MBEDTLS_CIPHER_CAMELLIA_256_CFB128, /**< Camellia cipher with 256-bit CFB128 mode. */
130 MBEDTLS_CIPHER_CAMELLIA_128_CTR, /**< Camellia cipher with 128-bit CTR mode. */
131 MBEDTLS_CIPHER_CAMELLIA_192_CTR, /**< Camellia cipher with 192-bit CTR mode. */
132 MBEDTLS_CIPHER_CAMELLIA_256_CTR, /**< Camellia cipher with 256-bit CTR mode. */
133 MBEDTLS_CIPHER_CAMELLIA_128_GCM, /**< Camellia cipher with 128-bit GCM mode. */
134 MBEDTLS_CIPHER_CAMELLIA_192_GCM, /**< Camellia cipher with 192-bit GCM mode. */
135 MBEDTLS_CIPHER_CAMELLIA_256_GCM, /**< Camellia cipher with 256-bit GCM mode. */
136 MBEDTLS_CIPHER_DES_ECB, /**< DES cipher with ECB mode. */
137 MBEDTLS_CIPHER_DES_CBC, /**< DES cipher with CBC mode. */
138 MBEDTLS_CIPHER_DES_EDE_ECB, /**< DES cipher with EDE ECB mode. */
139 MBEDTLS_CIPHER_DES_EDE_CBC, /**< DES cipher with EDE CBC mode. */
140 MBEDTLS_CIPHER_DES_EDE3_ECB, /**< DES cipher with EDE3 ECB mode. */
141 MBEDTLS_CIPHER_DES_EDE3_CBC, /**< DES cipher with EDE3 CBC mode. */
142 MBEDTLS_CIPHER_BLOWFISH_ECB, /**< Blowfish cipher with ECB mode. */
143 MBEDTLS_CIPHER_BLOWFISH_CBC, /**< Blowfish cipher with CBC mode. */
144 MBEDTLS_CIPHER_BLOWFISH_CFB64, /**< Blowfish cipher with CFB64 mode. */
145 MBEDTLS_CIPHER_BLOWFISH_CTR, /**< Blowfish cipher with CTR mode. */
146 MBEDTLS_CIPHER_ARC4_128, /**< RC4 cipher with 128-bit mode. */
147 MBEDTLS_CIPHER_AES_128_CCM, /**< AES cipher with 128-bit CCM mode. */
148 MBEDTLS_CIPHER_AES_192_CCM, /**< AES cipher with 192-bit CCM mode. */
149 MBEDTLS_CIPHER_AES_256_CCM, /**< AES cipher with 256-bit CCM mode. */
150 MBEDTLS_CIPHER_CAMELLIA_128_CCM, /**< Camellia cipher with 128-bit CCM mode. */
151 MBEDTLS_CIPHER_CAMELLIA_192_CCM, /**< Camellia cipher with 192-bit CCM mode. */
152 MBEDTLS_CIPHER_CAMELLIA_256_CCM, /**< Camellia cipher with 256-bit CCM mode. */
153 MBEDTLS_CIPHER_ARIA_128_ECB, /**< Aria cipher with 128-bit key and ECB mode. */
154 MBEDTLS_CIPHER_ARIA_192_ECB, /**< Aria cipher with 192-bit key and ECB mode. */
155 MBEDTLS_CIPHER_ARIA_256_ECB, /**< Aria cipher with 256-bit key and ECB mode. */
156 MBEDTLS_CIPHER_ARIA_128_CBC, /**< Aria cipher with 128-bit key and CBC mode. */
157 MBEDTLS_CIPHER_ARIA_192_CBC, /**< Aria cipher with 192-bit key and CBC mode. */
158 MBEDTLS_CIPHER_ARIA_256_CBC, /**< Aria cipher with 256-bit key and CBC mode. */
159 MBEDTLS_CIPHER_ARIA_128_CFB128, /**< Aria cipher with 128-bit key and CFB-128 mode. */
160 MBEDTLS_CIPHER_ARIA_192_CFB128, /**< Aria cipher with 192-bit key and CFB-128 mode. */
161 MBEDTLS_CIPHER_ARIA_256_CFB128, /**< Aria cipher with 256-bit key and CFB-128 mode. */
162 MBEDTLS_CIPHER_ARIA_128_CTR, /**< Aria cipher with 128-bit key and CTR mode. */
163 MBEDTLS_CIPHER_ARIA_192_CTR, /**< Aria cipher with 192-bit key and CTR mode. */
164 MBEDTLS_CIPHER_ARIA_256_CTR, /**< Aria cipher with 256-bit key and CTR mode. */
165 MBEDTLS_CIPHER_ARIA_128_GCM, /**< Aria cipher with 128-bit key and GCM mode. */
166 MBEDTLS_CIPHER_ARIA_192_GCM, /**< Aria cipher with 192-bit key and GCM mode. */
167 MBEDTLS_CIPHER_ARIA_256_GCM, /**< Aria cipher with 256-bit key and GCM mode. */
168 MBEDTLS_CIPHER_ARIA_128_CCM, /**< Aria cipher with 128-bit key and CCM mode. */
169 MBEDTLS_CIPHER_ARIA_192_CCM, /**< Aria cipher with 192-bit key and CCM mode. */
170 MBEDTLS_CIPHER_ARIA_256_CCM, /**< Aria cipher with 256-bit key and CCM mode. */
171 MBEDTLS_CIPHER_AES_128_OFB, /**< AES 128-bit cipher in OFB mode. */
172 MBEDTLS_CIPHER_AES_192_OFB, /**< AES 192-bit cipher in OFB mode. */
173 MBEDTLS_CIPHER_AES_256_OFB, /**< AES 256-bit cipher in OFB mode. */
174 MBEDTLS_CIPHER_AES_128_XTS, /**< AES 128-bit cipher in XTS block mode. */
175 MBEDTLS_CIPHER_AES_256_XTS, /**< AES 256-bit cipher in XTS block mode. */
176 MBEDTLS_CIPHER_CHACHA20, /**< ChaCha20 stream cipher. */
177 MBEDTLS_CIPHER_CHACHA20_POLY1305, /**< ChaCha20-Poly1305 AEAD cipher. */
178} mbedtls_cipher_type_t;
179
180/** Supported cipher modes. */
181typedef enum {
182 MBEDTLS_MODE_NONE = 0, /**< None. */
183 MBEDTLS_MODE_ECB, /**< The ECB cipher mode. */
184 MBEDTLS_MODE_CBC, /**< The CBC cipher mode. */
185 MBEDTLS_MODE_CFB, /**< The CFB cipher mode. */
186 MBEDTLS_MODE_OFB, /**< The OFB cipher mode. */
187 MBEDTLS_MODE_CTR, /**< The CTR cipher mode. */
188 MBEDTLS_MODE_GCM, /**< The GCM cipher mode. */
189 MBEDTLS_MODE_STREAM, /**< The stream cipher mode. */
190 MBEDTLS_MODE_CCM, /**< The CCM cipher mode. */
191 MBEDTLS_MODE_XTS, /**< The XTS cipher mode. */
192 MBEDTLS_MODE_CHACHAPOLY, /**< The ChaCha-Poly cipher mode. */
193} mbedtls_cipher_mode_t;
194
195/** Supported cipher padding types. */
196typedef enum {
197 MBEDTLS_PADDING_PKCS7 = 0, /**< PKCS7 padding (default). */
198 MBEDTLS_PADDING_ONE_AND_ZEROS, /**< ISO/IEC 7816-4 padding. */
199 MBEDTLS_PADDING_ZEROS_AND_LEN, /**< ANSI X.923 padding. */
200 MBEDTLS_PADDING_ZEROS, /**< Zero padding (not reversible). */
201 MBEDTLS_PADDING_NONE, /**< Never pad (full blocks only). */
202} mbedtls_cipher_padding_t;
203
204/** Type of operation. */
205typedef enum {
206 MBEDTLS_OPERATION_NONE = -1,
207 MBEDTLS_DECRYPT = 0,
208 MBEDTLS_ENCRYPT,
209} mbedtls_operation_t;
210
211enum {
212 /** Undefined key length. */
213 MBEDTLS_KEY_LENGTH_NONE = 0,
214 /** Key length, in bits (including parity), for DES keys. */
215 MBEDTLS_KEY_LENGTH_DES = 64,
216 /** Key length in bits, including parity, for DES in two-key EDE. */
217 MBEDTLS_KEY_LENGTH_DES_EDE = 128,
218 /** Key length in bits, including parity, for DES in three-key EDE. */
219 MBEDTLS_KEY_LENGTH_DES_EDE3 = 192,
220};
221
222/** Maximum length of any IV, in Bytes. */
223#define MBEDTLS_MAX_IV_LENGTH 16
224/** Maximum block size of any cipher, in Bytes. */
225#define MBEDTLS_MAX_BLOCK_LENGTH 16
226
227/**
228 * Base cipher information (opaque struct).
229 */
230typedef struct mbedtls_cipher_base_t mbedtls_cipher_base_t;
231
232/**
233 * CMAC context (opaque struct).
234 */
235typedef struct mbedtls_cmac_context_t mbedtls_cmac_context_t;
236
237/**
238 * Cipher information. Allows calling cipher functions
239 * in a generic way.
240 */
241typedef struct mbedtls_cipher_info_t
242{
243 /** Full cipher identifier. For example,
244 * MBEDTLS_CIPHER_AES_256_CBC.
245 */
246 mbedtls_cipher_type_t type;
247
248 /** The cipher mode. For example, MBEDTLS_MODE_CBC. */
249 mbedtls_cipher_mode_t mode;
250
251 /** The cipher key length, in bits. This is the
252 * default length for variable sized ciphers.
253 * Includes parity bits for ciphers like DES.
254 */
255 unsigned int key_bitlen;
256
257 /** Name of the cipher. */
258 const char * name;
259
260 /** IV or nonce size, in Bytes.
261 * For ciphers that accept variable IV sizes,
262 * this is the recommended size.
263 */
264 unsigned int iv_size;
265
266 /** Bitflag comprised of MBEDTLS_CIPHER_VARIABLE_IV_LEN and
267 * MBEDTLS_CIPHER_VARIABLE_KEY_LEN indicating whether the
268 * cipher supports variable IV or variable key sizes, respectively.
269 */
270 int flags;
271
272 /** The block size, in Bytes. */
273 unsigned int block_size;
274
275 /** Struct for base cipher information and functions. */
276 const mbedtls_cipher_base_t *base;
277
278} mbedtls_cipher_info_t;
279
280/**
281 * Generic cipher context.
282 */
283typedef struct mbedtls_cipher_context_t
284{
285 /** Information about the associated cipher. */
286 const mbedtls_cipher_info_t *cipher_info;
287
288 /** Key length to use. */
289 int key_bitlen;
290
291 /** Operation that the key of the context has been
292 * initialized for.
293 */
294 mbedtls_operation_t operation;
295
296#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
297 /** Padding functions to use, if relevant for
298 * the specific cipher mode.
299 */
300 void (*add_padding)( unsigned char *output, size_t olen, size_t data_len );
301 int (*get_padding)( unsigned char *input, size_t ilen, size_t *data_len );
302#endif
303
304 /** Buffer for input that has not been processed yet. */
305 unsigned char unprocessed_data[MBEDTLS_MAX_BLOCK_LENGTH];
306
307 /** Number of Bytes that have not been processed yet. */
308 size_t unprocessed_len;
309
310 /** Current IV or NONCE_COUNTER for CTR-mode, data unit (or sector) number
311 * for XTS-mode. */
312 unsigned char iv[MBEDTLS_MAX_IV_LENGTH];
313
314 /** IV size in Bytes, for ciphers with variable-length IVs. */
315 size_t iv_size;
316
317 /** The cipher-specific context. */
318 void *cipher_ctx;
319
320#if defined(MBEDTLS_CMAC_C)
321 /** CMAC-specific context. */
322 mbedtls_cmac_context_t *cmac_ctx;
323#endif
324} mbedtls_cipher_context_t;
325
326/**
327 * \brief This function retrieves the list of ciphers supported by the generic
328 * cipher module.
329 *
330 * \return A statically-allocated array of ciphers. The last entry
331 * is zero.
332 */
333const int *mbedtls_cipher_list( void );
334
335/**
336 * \brief This function retrieves the cipher-information
337 * structure associated with the given cipher name.
338 *
339 * \param cipher_name Name of the cipher to search for.
340 *
341 * \return The cipher information structure associated with the
342 * given \p cipher_name.
343 * \return NULL if the associated cipher information is not found.
344 */
345const mbedtls_cipher_info_t *mbedtls_cipher_info_from_string( const char *cipher_name );
346
347/**
348 * \brief This function retrieves the cipher-information
349 * structure associated with the given cipher type.
350 *
351 * \param cipher_type Type of the cipher to search for.
352 *
353 * \return The cipher information structure associated with the
354 * given \p cipher_type.
355 * \return NULL if the associated cipher information is not found.
356 */
357const mbedtls_cipher_info_t *mbedtls_cipher_info_from_type( const mbedtls_cipher_type_t cipher_type );
358
359/**
360 * \brief This function retrieves the cipher-information
361 * structure associated with the given cipher ID,
362 * key size and mode.
363 *
364 * \param cipher_id The ID of the cipher to search for. For example,
365 * #MBEDTLS_CIPHER_ID_AES.
366 * \param key_bitlen The length of the key in bits.
367 * \param mode The cipher mode. For example, #MBEDTLS_MODE_CBC.
368 *
369 * \return The cipher information structure associated with the
370 * given \p cipher_id.
371 * \return NULL if the associated cipher information is not found.
372 */
373const mbedtls_cipher_info_t *mbedtls_cipher_info_from_values( const mbedtls_cipher_id_t cipher_id,
374 int key_bitlen,
375 const mbedtls_cipher_mode_t mode );
376
377/**
378 * \brief This function initializes a \p cipher_context as NONE.
379 */
380void mbedtls_cipher_init( mbedtls_cipher_context_t *ctx );
381
382/**
383 * \brief This function frees and clears the cipher-specific
384 * context of \p ctx. Freeing \p ctx itself remains the
385 * responsibility of the caller.
386 */
387void mbedtls_cipher_free( mbedtls_cipher_context_t *ctx );
388
389
390/**
391 * \brief This function initializes and fills the cipher-context
392 * structure with the appropriate values. It also clears
393 * the structure.
394 *
395 * \param ctx The context to initialize. May not be NULL.
396 * \param cipher_info The cipher to use.
397 *
398 * \return \c 0 on success.
399 * \return #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on
400 * parameter-verification failure.
401 * \return #MBEDTLS_ERR_CIPHER_ALLOC_FAILED if allocation of the
402 * cipher-specific context fails.
403 *
404 * \internal Currently, the function also clears the structure.
405 * In future versions, the caller will be required to call
406 * mbedtls_cipher_init() on the structure first.
407 */
408int mbedtls_cipher_setup( mbedtls_cipher_context_t *ctx, const mbedtls_cipher_info_t *cipher_info );
409
410/**
411 * \brief This function returns the block size of the given cipher.
412 *
413 * \param ctx The context of the cipher. Must be initialized.
414 *
415 * \return The size of the blocks of the cipher.
416 * \return 0 if \p ctx has not been initialized.
417 */
418static inline unsigned int mbedtls_cipher_get_block_size( const mbedtls_cipher_context_t *ctx )
419{
420 if( NULL == ctx || NULL == ctx->cipher_info )
421 return 0;
422
423 return ctx->cipher_info->block_size;
424}
425
426/**
427 * \brief This function returns the mode of operation for
428 * the cipher. For example, MBEDTLS_MODE_CBC.
429 *
430 * \param ctx The context of the cipher. Must be initialized.
431 *
432 * \return The mode of operation.
433 * \return #MBEDTLS_MODE_NONE if \p ctx has not been initialized.
434 */
435static inline mbedtls_cipher_mode_t mbedtls_cipher_get_cipher_mode( const mbedtls_cipher_context_t *ctx )
436{
437 if( NULL == ctx || NULL == ctx->cipher_info )
438 return MBEDTLS_MODE_NONE;
439
440 return ctx->cipher_info->mode;
441}
442
443/**
444 * \brief This function returns the size of the IV or nonce
445 * of the cipher, in Bytes.
446 *
447 * \param ctx The context of the cipher. Must be initialized.
448 *
449 * \return The recommended IV size if no IV has been set.
450 * \return \c 0 for ciphers not using an IV or a nonce.
451 * \return The actual size if an IV has been set.
452 */
453static inline int mbedtls_cipher_get_iv_size( const mbedtls_cipher_context_t *ctx )
454{
455 if( NULL == ctx || NULL == ctx->cipher_info )
456 return 0;
457
458 if( ctx->iv_size != 0 )
459 return (int) ctx->iv_size;
460
461 return (int) ctx->cipher_info->iv_size;
462}
463
464/**
465 * \brief This function returns the type of the given cipher.
466 *
467 * \param ctx The context of the cipher. Must be initialized.
468 *
469 * \return The type of the cipher.
470 * \return #MBEDTLS_CIPHER_NONE if \p ctx has not been initialized.
471 */
472static inline mbedtls_cipher_type_t mbedtls_cipher_get_type( const mbedtls_cipher_context_t *ctx )
473{
474 if( NULL == ctx || NULL == ctx->cipher_info )
475 return MBEDTLS_CIPHER_NONE;
476
477 return ctx->cipher_info->type;
478}
479
480/**
481 * \brief This function returns the name of the given cipher
482 * as a string.
483 *
484 * \param ctx The context of the cipher. Must be initialized.
485 *
486 * \return The name of the cipher.
487 * \return NULL if \p ctx has not been not initialized.
488 */
489static inline const char *mbedtls_cipher_get_name( const mbedtls_cipher_context_t *ctx )
490{
491 if( NULL == ctx || NULL == ctx->cipher_info )
492 return 0;
493
494 return ctx->cipher_info->name;
495}
496
497/**
498 * \brief This function returns the key length of the cipher.
499 *
500 * \param ctx The context of the cipher. Must be initialized.
501 *
502 * \return The key length of the cipher in bits.
503 * \return #MBEDTLS_KEY_LENGTH_NONE if ctx \p has not been
504 * initialized.
505 */
506static inline int mbedtls_cipher_get_key_bitlen( const mbedtls_cipher_context_t *ctx )
507{
508 if( NULL == ctx || NULL == ctx->cipher_info )
509 return MBEDTLS_KEY_LENGTH_NONE;
510
511 return (int) ctx->cipher_info->key_bitlen;
512}
513
514/**
515 * \brief This function returns the operation of the given cipher.
516 *
517 * \param ctx The context of the cipher. Must be initialized.
518 *
519 * \return The type of operation: #MBEDTLS_ENCRYPT or #MBEDTLS_DECRYPT.
520 * \return #MBEDTLS_OPERATION_NONE if \p ctx has not been initialized.
521 */
522static inline mbedtls_operation_t mbedtls_cipher_get_operation( const mbedtls_cipher_context_t *ctx )
523{
524 if( NULL == ctx || NULL == ctx->cipher_info )
525 return MBEDTLS_OPERATION_NONE;
526
527 return ctx->operation;
528}
529
530/**
531 * \brief This function sets the key to use with the given context.
532 *
533 * \param ctx The generic cipher context. May not be NULL. Must have
534 * been initialized using mbedtls_cipher_info_from_type()
535 * or mbedtls_cipher_info_from_string().
536 * \param key The key to use.
537 * \param key_bitlen The key length to use, in bits.
538 * \param operation The operation that the key will be used for:
539 * #MBEDTLS_ENCRYPT or #MBEDTLS_DECRYPT.
540 *
541 * \return \c 0 on success.
542 * \return #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on
543 * parameter-verification failure.
544 * \return A cipher-specific error code on failure.
545 */
546int mbedtls_cipher_setkey( mbedtls_cipher_context_t *ctx, const unsigned char *key,
547 int key_bitlen, const mbedtls_operation_t operation );
548
549#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
550/**
551 * \brief This function sets the padding mode, for cipher modes
552 * that use padding.
553 *
554 * The default passing mode is PKCS7 padding.
555 *
556 * \param ctx The generic cipher context.
557 * \param mode The padding mode.
558 *
559 * \return \c 0 on success.
560 * \return #MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE
561 * if the selected padding mode is not supported.
562 * \return #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA if the cipher mode
563 * does not support padding.
564 */
565int mbedtls_cipher_set_padding_mode( mbedtls_cipher_context_t *ctx, mbedtls_cipher_padding_t mode );
566#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
567
568/**
569 * \brief This function sets the initialization vector (IV)
570 * or nonce.
571 *
572 * \note Some ciphers do not use IVs nor nonce. For these
573 * ciphers, this function has no effect.
574 *
575 * \param ctx The generic cipher context.
576 * \param iv The IV to use, or NONCE_COUNTER for CTR-mode ciphers.
577 * \param iv_len The IV length for ciphers with variable-size IV.
578 * This parameter is discarded by ciphers with fixed-size IV.
579 *
580 * \return \c 0 on success.
581 * \return #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on
582 * parameter-verification failure.
583 */
584int mbedtls_cipher_set_iv( mbedtls_cipher_context_t *ctx,
585 const unsigned char *iv, size_t iv_len );
586
587/**
588 * \brief This function resets the cipher state.
589 *
590 * \param ctx The generic cipher context.
591 *
592 * \return \c 0 on success.
593 * \return #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on
594 * parameter-verification failure.
595 */
596int mbedtls_cipher_reset( mbedtls_cipher_context_t *ctx );
597
598#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
599/**
600 * \brief This function adds additional data for AEAD ciphers.
601 * Currently supported with GCM and ChaCha20+Poly1305.
602 * Must be called exactly once, after mbedtls_cipher_reset().
603 *
604 * \param ctx The generic cipher context.
605 * \param ad The additional data to use.
606 * \param ad_len the Length of \p ad.
607 *
608 * \return \c 0 on success.
609 * \return A specific error code on failure.
610 */
611int mbedtls_cipher_update_ad( mbedtls_cipher_context_t *ctx,
612 const unsigned char *ad, size_t ad_len );
613#endif /* MBEDTLS_GCM_C || MBEDTLS_CHACHAPOLY_C */
614
615/**
616 * \brief The generic cipher update function. It encrypts or
617 * decrypts using the given cipher context. Writes as
618 * many block-sized blocks of data as possible to output.
619 * Any data that cannot be written immediately is either
620 * added to the next block, or flushed when
621 * mbedtls_cipher_finish() is called.
622 * Exception: For MBEDTLS_MODE_ECB, expects a single block
623 * in size. For example, 16 Bytes for AES.
624 *
625 * \note If the underlying cipher is used in GCM mode, all calls
626 * to this function, except for the last one before
627 * mbedtls_cipher_finish(), must have \p ilen as a
628 * multiple of the block size of the cipher.
629 *
630 * \param ctx The generic cipher context.
631 * \param input The buffer holding the input data.
632 * \param ilen The length of the input data.
633 * \param output The buffer for the output data. Must be able to hold at
634 * least \p ilen + block_size. Must not be the same buffer
635 * as input.
636 * \param olen The length of the output data, to be updated with the
637 * actual number of Bytes written.
638 *
639 * \return \c 0 on success.
640 * \return #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on
641 * parameter-verification failure.
642 * \return #MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE on an
643 * unsupported mode for a cipher.
644 * \return A cipher-specific error code on failure.
645 */
646int mbedtls_cipher_update( mbedtls_cipher_context_t *ctx, const unsigned char *input,
647 size_t ilen, unsigned char *output, size_t *olen );
648
649/**
650 * \brief The generic cipher finalization function. If data still
651 * needs to be flushed from an incomplete block, the data
652 * contained in it is padded to the size of
653 * the last block, and written to the \p output buffer.
654 *
655 * \param ctx The generic cipher context.
656 * \param output The buffer to write data to. Needs block_size available.
657 * \param olen The length of the data written to the \p output buffer.
658 *
659 * \return \c 0 on success.
660 * \return #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on
661 * parameter-verification failure.
662 * \return #MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED on decryption
663 * expecting a full block but not receiving one.
664 * \return #MBEDTLS_ERR_CIPHER_INVALID_PADDING on invalid padding
665 * while decrypting.
666 * \return A cipher-specific error code on failure.
667 */
668int mbedtls_cipher_finish( mbedtls_cipher_context_t *ctx,
669 unsigned char *output, size_t *olen );
670
671#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
672/**
673 * \brief This function writes a tag for AEAD ciphers.
674 * Currently supported with GCM and ChaCha20+Poly1305.
675 * Must be called after mbedtls_cipher_finish().
676 *
677 * \param ctx The generic cipher context.
678 * \param tag The buffer to write the tag to.
679 * \param tag_len The length of the tag to write.
680 *
681 * \return \c 0 on success.
682 * \return A specific error code on failure.
683 */
684int mbedtls_cipher_write_tag( mbedtls_cipher_context_t *ctx,
685 unsigned char *tag, size_t tag_len );
686
687/**
688 * \brief This function checks the tag for AEAD ciphers.
689 * Currently supported with GCM and ChaCha20+Poly1305.
690 * Must be called after mbedtls_cipher_finish().
691 *
692 * \param ctx The generic cipher context.
693 * \param tag The buffer holding the tag.
694 * \param tag_len The length of the tag to check.
695 *
696 * \return \c 0 on success.
697 * \return A specific error code on failure.
698 */
699int mbedtls_cipher_check_tag( mbedtls_cipher_context_t *ctx,
700 const unsigned char *tag, size_t tag_len );
701#endif /* MBEDTLS_GCM_C || MBEDTLS_CHACHAPOLY_C */
702
703/**
704 * \brief The generic all-in-one encryption/decryption function,
705 * for all ciphers except AEAD constructs.
706 *
707 * \param ctx The generic cipher context.
708 * \param iv The IV to use, or NONCE_COUNTER for CTR-mode ciphers.
709 * \param iv_len The IV length for ciphers with variable-size IV.
710 * This parameter is discarded by ciphers with fixed-size
711 * IV.
712 * \param input The buffer holding the input data.
713 * \param ilen The length of the input data.
714 * \param output The buffer for the output data. Must be able to hold at
715 * least \p ilen + block_size. Must not be the same buffer
716 * as input.
717 * \param olen The length of the output data, to be updated with the
718 * actual number of Bytes written.
719 *
720 * \note Some ciphers do not use IVs nor nonce. For these
721 * ciphers, use \p iv = NULL and \p iv_len = 0.
722 *
723 * \return \c 0 on success.
724 * \return #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on
725 * parameter-verification failure.
726 * \return #MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED on decryption
727 * expecting a full block but not receiving one.
728 * \return #MBEDTLS_ERR_CIPHER_INVALID_PADDING on invalid padding
729 * while decrypting.
730 * \return A cipher-specific error code on failure.
731 */
732int mbedtls_cipher_crypt( mbedtls_cipher_context_t *ctx,
733 const unsigned char *iv, size_t iv_len,
734 const unsigned char *input, size_t ilen,
735 unsigned char *output, size_t *olen );
736
737#if defined(MBEDTLS_CIPHER_MODE_AEAD)
738/**
739 * \brief The generic autenticated encryption (AEAD) function.
740 *
741 * \param ctx The generic cipher context.
742 * \param iv The IV to use, or NONCE_COUNTER for CTR-mode ciphers.
743 * \param iv_len The IV length for ciphers with variable-size IV.
744 * This parameter is discarded by ciphers with fixed-size IV.
745 * \param ad The additional data to authenticate.
746 * \param ad_len The length of \p ad.
747 * \param input The buffer holding the input data.
748 * \param ilen The length of the input data.
749 * \param output The buffer for the output data.
750 * Must be able to hold at least \p ilen.
751 * \param olen The length of the output data, to be updated with the
752 * actual number of Bytes written.
753 * \param tag The buffer for the authentication tag.
754 * \param tag_len The desired length of the authentication tag.
755 *
756 * \return \c 0 on success.
757 * \return #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on
758 * parameter-verification failure.
759 * \return A cipher-specific error code on failure.
760 */
761int mbedtls_cipher_auth_encrypt( mbedtls_cipher_context_t *ctx,
762 const unsigned char *iv, size_t iv_len,
763 const unsigned char *ad, size_t ad_len,
764 const unsigned char *input, size_t ilen,
765 unsigned char *output, size_t *olen,
766 unsigned char *tag, size_t tag_len );
767
768/**
769 * \brief The generic autenticated decryption (AEAD) function.
770 *
771 * \note If the data is not authentic, then the output buffer
772 * is zeroed out to prevent the unauthentic plaintext being
773 * used, making this interface safer.
774 *
775 * \param ctx The generic cipher context.
776 * \param iv The IV to use, or NONCE_COUNTER for CTR-mode ciphers.
777 * \param iv_len The IV length for ciphers with variable-size IV.
778 * This parameter is discarded by ciphers with fixed-size IV.
779 * \param ad The additional data to be authenticated.
780 * \param ad_len The length of \p ad.
781 * \param input The buffer holding the input data.
782 * \param ilen The length of the input data.
783 * \param output The buffer for the output data.
784 * Must be able to hold at least \p ilen.
785 * \param olen The length of the output data, to be updated with the
786 * actual number of Bytes written.
787 * \param tag The buffer holding the authentication tag.
788 * \param tag_len The length of the authentication tag.
789 *
790 * \return \c 0 on success.
791 * \return #MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA on
792 * parameter-verification failure.
793 * \return #MBEDTLS_ERR_CIPHER_AUTH_FAILED if data is not authentic.
794 * \return A cipher-specific error code on failure.
795 */
796int mbedtls_cipher_auth_decrypt( mbedtls_cipher_context_t *ctx,
797 const unsigned char *iv, size_t iv_len,
798 const unsigned char *ad, size_t ad_len,
799 const unsigned char *input, size_t ilen,
800 unsigned char *output, size_t *olen,
801 const unsigned char *tag, size_t tag_len );
802#endif /* MBEDTLS_CIPHER_MODE_AEAD */
803
804#ifdef __cplusplus
805}
806#endif
807
808#endif /* MBEDTLS_CIPHER_H */
diff --git a/source/mbedtls/include/mbedtls/cipher_internal.h b/source/mbedtls/include/mbedtls/cipher_internal.h
deleted file mode 100644
index 9f2858a..0000000
--- a/source/mbedtls/include/mbedtls/cipher_internal.h
+++ /dev/null
@@ -1,127 +0,0 @@
1/**
2 * \file cipher_internal.h
3 *
4 * \brief Cipher wrappers.
5 *
6 * \author Adriaan de Jong <dejong@fox-it.com>
7 */
8/*
9 * Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
10 * SPDX-License-Identifier: GPL-2.0
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License along
23 * with this program; if not, write to the Free Software Foundation, Inc.,
24 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
25 *
26 * This file is part of mbed TLS (https://tls.mbed.org)
27 */
28#ifndef MBEDTLS_CIPHER_WRAP_H
29#define MBEDTLS_CIPHER_WRAP_H
30
31#if !defined(MBEDTLS_CONFIG_FILE)
32#include "config.h"
33#else
34#include MBEDTLS_CONFIG_FILE
35#endif
36
37#include "cipher.h"
38
39#ifdef __cplusplus
40extern "C" {
41#endif
42
43/**
44 * Base cipher information. The non-mode specific functions and values.
45 */
46struct mbedtls_cipher_base_t
47{
48 /** Base Cipher type (e.g. MBEDTLS_CIPHER_ID_AES) */
49 mbedtls_cipher_id_t cipher;
50
51 /** Encrypt using ECB */
52 int (*ecb_func)( void *ctx, mbedtls_operation_t mode,
53 const unsigned char *input, unsigned char *output );
54
55#if defined(MBEDTLS_CIPHER_MODE_CBC)
56 /** Encrypt using CBC */
57 int (*cbc_func)( void *ctx, mbedtls_operation_t mode, size_t length,
58 unsigned char *iv, const unsigned char *input,
59 unsigned char *output );
60#endif
61
62#if defined(MBEDTLS_CIPHER_MODE_CFB)
63 /** Encrypt using CFB (Full length) */
64 int (*cfb_func)( void *ctx, mbedtls_operation_t mode, size_t length, size_t *iv_off,
65 unsigned char *iv, const unsigned char *input,
66 unsigned char *output );
67#endif
68
69#if defined(MBEDTLS_CIPHER_MODE_OFB)
70 /** Encrypt using OFB (Full length) */
71 int (*ofb_func)( void *ctx, size_t length, size_t *iv_off,
72 unsigned char *iv,
73 const unsigned char *input,
74 unsigned char *output );
75#endif
76
77#if defined(MBEDTLS_CIPHER_MODE_CTR)
78 /** Encrypt using CTR */
79 int (*ctr_func)( void *ctx, size_t length, size_t *nc_off,
80 unsigned char *nonce_counter, unsigned char *stream_block,
81 const unsigned char *input, unsigned char *output );
82#endif
83
84#if defined(MBEDTLS_CIPHER_MODE_XTS)
85 /** Encrypt or decrypt using XTS. */
86 int (*xts_func)( void *ctx, mbedtls_operation_t mode, size_t length,
87 const unsigned char data_unit[16],
88 const unsigned char *input, unsigned char *output );
89#endif
90
91#if defined(MBEDTLS_CIPHER_MODE_STREAM)
92 /** Encrypt using STREAM */
93 int (*stream_func)( void *ctx, size_t length,
94 const unsigned char *input, unsigned char *output );
95#endif
96
97 /** Set key for encryption purposes */
98 int (*setkey_enc_func)( void *ctx, const unsigned char *key,
99 unsigned int key_bitlen );
100
101 /** Set key for decryption purposes */
102 int (*setkey_dec_func)( void *ctx, const unsigned char *key,
103 unsigned int key_bitlen);
104
105 /** Allocate a new context */
106 void * (*ctx_alloc_func)( void );
107
108 /** Free the given context */
109 void (*ctx_free_func)( void *ctx );
110
111};
112
113typedef struct
114{
115 mbedtls_cipher_type_t type;
116 const mbedtls_cipher_info_t *info;
117} mbedtls_cipher_definition_t;
118
119extern const mbedtls_cipher_definition_t mbedtls_cipher_definitions[];
120
121extern int mbedtls_cipher_supported[];
122
123#ifdef __cplusplus
124}
125#endif
126
127#endif /* MBEDTLS_CIPHER_WRAP_H */
diff --git a/source/mbedtls/include/mbedtls/cmac.h b/source/mbedtls/include/mbedtls/cmac.h
deleted file mode 100644
index f6fc79b..0000000
--- a/source/mbedtls/include/mbedtls/cmac.h
+++ /dev/null
@@ -1,208 +0,0 @@
1/**
2 * \file cmac.h
3 *
4 * \brief This file contains CMAC definitions and functions.
5 *
6 * The Cipher-based Message Authentication Code (CMAC) Mode for
7 * Authentication is defined in <em>RFC-4493: The AES-CMAC Algorithm</em>.
8 */
9/*
10 * Copyright (C) 2015-2018, Arm Limited (or its affiliates), All Rights Reserved
11 * SPDX-License-Identifier: GPL-2.0
12 *
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or
16 * (at your option) any later version.
17 *
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License along
24 * with this program; if not, write to the Free Software Foundation, Inc.,
25 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
26 *
27 * This file is part of Mbed TLS (https://tls.mbed.org)
28 */
29
30#ifndef MBEDTLS_CMAC_H
31#define MBEDTLS_CMAC_H
32
33#include "cipher.h"
34
35#ifdef __cplusplus
36extern "C" {
37#endif
38
39#define MBEDTLS_ERR_CMAC_HW_ACCEL_FAILED -0x007A /**< CMAC hardware accelerator failed. */
40
41#define MBEDTLS_AES_BLOCK_SIZE 16
42#define MBEDTLS_DES3_BLOCK_SIZE 8
43
44#if defined(MBEDTLS_AES_C)
45#define MBEDTLS_CIPHER_BLKSIZE_MAX 16 /**< The longest block used by CMAC is that of AES. */
46#else
47#define MBEDTLS_CIPHER_BLKSIZE_MAX 8 /**< The longest block used by CMAC is that of 3DES. */
48#endif
49
50#if !defined(MBEDTLS_CMAC_ALT)
51
52/**
53 * The CMAC context structure.
54 */
55struct mbedtls_cmac_context_t
56{
57 /** The internal state of the CMAC algorithm. */
58 unsigned char state[MBEDTLS_CIPHER_BLKSIZE_MAX];
59
60 /** Unprocessed data - either data that was not block aligned and is still
61 * pending processing, or the final block. */
62 unsigned char unprocessed_block[MBEDTLS_CIPHER_BLKSIZE_MAX];
63
64 /** The length of data pending processing. */
65 size_t unprocessed_len;
66};
67
68#else /* !MBEDTLS_CMAC_ALT */
69#include "cmac_alt.h"
70#endif /* !MBEDTLS_CMAC_ALT */
71
72/**
73 * \brief This function sets the CMAC key, and prepares to authenticate
74 * the input data.
75 * Must be called with an initialized cipher context.
76 *
77 * \param ctx The cipher context used for the CMAC operation, initialized
78 * as one of the following types: MBEDTLS_CIPHER_AES_128_ECB,
79 * MBEDTLS_CIPHER_AES_192_ECB, MBEDTLS_CIPHER_AES_256_ECB,
80 * or MBEDTLS_CIPHER_DES_EDE3_ECB.
81 * \param key The CMAC key.
82 * \param keybits The length of the CMAC key in bits.
83 * Must be supported by the cipher.
84 *
85 * \return \c 0 on success.
86 * \return A cipher-specific error code on failure.
87 */
88int mbedtls_cipher_cmac_starts( mbedtls_cipher_context_t *ctx,
89 const unsigned char *key, size_t keybits );
90
91/**
92 * \brief This function feeds an input buffer into an ongoing CMAC
93 * computation.
94 *
95 * It is called between mbedtls_cipher_cmac_starts() or
96 * mbedtls_cipher_cmac_reset(), and mbedtls_cipher_cmac_finish().
97 * Can be called repeatedly.
98 *
99 * \param ctx The cipher context used for the CMAC operation.
100 * \param input The buffer holding the input data.
101 * \param ilen The length of the input data.
102 *
103 * \return \c 0 on success.
104 * \return #MBEDTLS_ERR_MD_BAD_INPUT_DATA
105 * if parameter verification fails.
106 */
107int mbedtls_cipher_cmac_update( mbedtls_cipher_context_t *ctx,
108 const unsigned char *input, size_t ilen );
109
110/**
111 * \brief This function finishes the CMAC operation, and writes
112 * the result to the output buffer.
113 *
114 * It is called after mbedtls_cipher_cmac_update().
115 * It can be followed by mbedtls_cipher_cmac_reset() and
116 * mbedtls_cipher_cmac_update(), or mbedtls_cipher_free().
117 *
118 * \param ctx The cipher context used for the CMAC operation.
119 * \param output The output buffer for the CMAC checksum result.
120 *
121 * \return \c 0 on success.
122 * \return #MBEDTLS_ERR_MD_BAD_INPUT_DATA
123 * if parameter verification fails.
124 */
125int mbedtls_cipher_cmac_finish( mbedtls_cipher_context_t *ctx,
126 unsigned char *output );
127
128/**
129 * \brief This function prepares the authentication of another
130 * message with the same key as the previous CMAC
131 * operation.
132 *
133 * It is called after mbedtls_cipher_cmac_finish()
134 * and before mbedtls_cipher_cmac_update().
135 *
136 * \param ctx The cipher context used for the CMAC operation.
137 *
138 * \return \c 0 on success.
139 * \return #MBEDTLS_ERR_MD_BAD_INPUT_DATA
140 * if parameter verification fails.
141 */
142int mbedtls_cipher_cmac_reset( mbedtls_cipher_context_t *ctx );
143
144/**
145 * \brief This function calculates the full generic CMAC
146 * on the input buffer with the provided key.
147 *
148 * The function allocates the context, performs the
149 * calculation, and frees the context.
150 *
151 * The CMAC result is calculated as
152 * output = generic CMAC(cmac key, input buffer).
153 *
154 *
155 * \param cipher_info The cipher information.
156 * \param key The CMAC key.
157 * \param keylen The length of the CMAC key in bits.
158 * \param input The buffer holding the input data.
159 * \param ilen The length of the input data.
160 * \param output The buffer for the generic CMAC result.
161 *
162 * \return \c 0 on success.
163 * \return #MBEDTLS_ERR_MD_BAD_INPUT_DATA
164 * if parameter verification fails.
165 */
166int mbedtls_cipher_cmac( const mbedtls_cipher_info_t *cipher_info,
167 const unsigned char *key, size_t keylen,
168 const unsigned char *input, size_t ilen,
169 unsigned char *output );
170
171#if defined(MBEDTLS_AES_C)
172/**
173 * \brief This function implements the AES-CMAC-PRF-128 pseudorandom
174 * function, as defined in
175 * <em>RFC-4615: The Advanced Encryption Standard-Cipher-based
176 * Message Authentication Code-Pseudo-Random Function-128
177 * (AES-CMAC-PRF-128) Algorithm for the Internet Key
178 * Exchange Protocol (IKE).</em>
179 *
180 * \param key The key to use.
181 * \param key_len The key length in Bytes.
182 * \param input The buffer holding the input data.
183 * \param in_len The length of the input data in Bytes.
184 * \param output The buffer holding the generated 16 Bytes of
185 * pseudorandom output.
186 *
187 * \return \c 0 on success.
188 */
189int mbedtls_aes_cmac_prf_128( const unsigned char *key, size_t key_len,
190 const unsigned char *input, size_t in_len,
191 unsigned char output[16] );
192#endif /* MBEDTLS_AES_C */
193
194#if defined(MBEDTLS_SELF_TEST) && ( defined(MBEDTLS_AES_C) || defined(MBEDTLS_DES_C) )
195/**
196 * \brief The CMAC checkup routine.
197 *
198 * \return \c 0 on success.
199 * \return \c 1 on failure.
200 */
201int mbedtls_cmac_self_test( int verbose );
202#endif /* MBEDTLS_SELF_TEST && ( MBEDTLS_AES_C || MBEDTLS_DES_C ) */
203
204#ifdef __cplusplus
205}
206#endif
207
208#endif /* MBEDTLS_CMAC_H */
diff --git a/source/mbedtls/include/mbedtls/config.h b/source/mbedtls/include/mbedtls/config.h
deleted file mode 100644
index c152c82..0000000
--- a/source/mbedtls/include/mbedtls/config.h
+++ /dev/null
@@ -1,49 +0,0 @@
1/**
2 * \file config.h
3 *
4 * \brief Configuration options (set of defines)
5 *
6 * This set of compile-time options may be used to enable
7 * or disable features selectively, and reduce the global
8 * memory footprint.
9 */
10/*
11 * Copyright (C) 2006-2018, ARM Limited, All Rights Reserved
12 * SPDX-License-Identifier: GPL-2.0
13 *
14 * This program is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; either version 2 of the License, or
17 * (at your option) any later version.
18 *
19 * This program is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details.
23 *
24 * You should have received a copy of the GNU General Public License along
25 * with this program; if not, write to the Free Software Foundation, Inc.,
26 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
27 *
28 * This file is part of mbed TLS (https://tls.mbed.org)
29 */
30
31/////////////////////////////////////
32// modified 13 nov 2018 by shchmue // -> pared down to essentials
33/////////////////////////////////////
34
35#ifndef MBEDTLS_CONFIG_H
36#define MBEDTLS_CONFIG_H
37
38#define MBEDTLS_HAVE_ASM
39
40#define MBEDTLS_AES_C
41
42#define MBEDTLS_CIPHER_C
43#define MBEDTLS_CMAC_C
44
45#define MBEDTLS_CIPHER_MODE_CTR
46
47#include "check_config.h"
48
49#endif /* MBEDTLS_CONFIG_H */ \ No newline at end of file
diff --git a/source/mbedtls/include/mbedtls/platform_util.h b/source/mbedtls/include/mbedtls/platform_util.h
deleted file mode 100644
index 79404ce..0000000
--- a/source/mbedtls/include/mbedtls/platform_util.h
+++ /dev/null
@@ -1,64 +0,0 @@
1/**
2 * \file platform_util.h
3 *
4 * \brief Common and shared functions used by multiple modules in the Mbed TLS
5 * library.
6 */
7/*
8 * Copyright (C) 2018, Arm Limited, All Rights Reserved
9 * SPDX-License-Identifier: GPL-2.0
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License along
22 * with this program; if not, write to the Free Software Foundation, Inc.,
23 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
24 *
25 * This file is part of Mbed TLS (https://tls.mbed.org)
26 */
27#ifndef MBEDTLS_PLATFORM_UTIL_H
28#define MBEDTLS_PLATFORM_UTIL_H
29
30#include <stddef.h>
31
32#ifdef __cplusplus
33extern "C" {
34#endif
35
36/**
37 * \brief Securely zeroize a buffer
38 *
39 * The function is meant to wipe the data contained in a buffer so
40 * that it can no longer be recovered even if the program memory
41 * is later compromised. Call this function on sensitive data
42 * stored on the stack before returning from a function, and on
43 * sensitive data stored on the heap before freeing the heap
44 * object.
45 *
46 * It is extremely difficult to guarantee that calls to
47 * mbedtls_platform_zeroize() are not removed by aggressive
48 * compiler optimizations in a portable way. For this reason, Mbed
49 * TLS provides the configuration option
50 * MBEDTLS_PLATFORM_ZEROIZE_ALT, which allows users to configure
51 * mbedtls_platform_zeroize() to use a suitable implementation for
52 * their platform and needs
53 *
54 * \param buf Buffer to be zeroized
55 * \param len Length of the buffer in bytes
56 *
57 */
58void mbedtls_platform_zeroize( void *buf, size_t len );
59
60#ifdef __cplusplus
61}
62#endif
63
64#endif /* MBEDTLS_PLATFORM_UTIL_H */
diff --git a/source/mbedtls/lib/.gitignore b/source/mbedtls/lib/.gitignore
deleted file mode 100644
index 3a63a63..0000000
--- a/source/mbedtls/lib/.gitignore
+++ /dev/null
@@ -1,4 +0,0 @@
1*.o
2libmbed*
3*.sln
4*.vcxproj
diff --git a/source/mbedtls/lib/CMakeLists.txt b/source/mbedtls/lib/CMakeLists.txt
deleted file mode 100644
index 6a280fe..0000000
--- a/source/mbedtls/lib/CMakeLists.txt
+++ /dev/null
@@ -1,181 +0,0 @@
1option(USE_STATIC_MBEDTLS_LIBRARY "Build mbed TLS static library." ON)
2option(USE_SHARED_MBEDTLS_LIBRARY "Build mbed TLS shared library." OFF)
3option(LINK_WITH_PTHREAD "Explicitly link mbed TLS library to pthread." OFF)
4
5set(src_crypto
6 aes.c
7 aesni.c
8 arc4.c
9 aria.c
10 asn1parse.c
11 asn1write.c
12 base64.c
13 bignum.c
14 blowfish.c
15 camellia.c
16 ccm.c
17 chacha20.c
18 chachapoly.c
19 cipher.c
20 cipher_wrap.c
21 cmac.c
22 ctr_drbg.c
23 des.c
24 dhm.c
25 ecdh.c
26 ecdsa.c
27 ecjpake.c
28 ecp.c
29 ecp_curves.c
30 entropy.c
31 entropy_poll.c
32 error.c
33 gcm.c
34 havege.c
35 hkdf.c
36 hmac_drbg.c
37 md.c
38 md2.c
39 md4.c
40 md5.c
41 md_wrap.c
42 memory_buffer_alloc.c
43 nist_kw.c
44 oid.c
45 padlock.c
46 pem.c
47 pk.c
48 pk_wrap.c
49 pkcs12.c
50 pkcs5.c
51 pkparse.c
52 pkwrite.c
53 platform.c
54 platform_util.c
55 poly1305.c
56 ripemd160.c
57 rsa.c
58 rsa_internal.c
59 sha1.c
60 sha256.c
61 sha512.c
62 threading.c
63 timing.c
64 version.c
65 version_features.c
66 xtea.c
67)
68
69set(src_x509
70 certs.c
71 pkcs11.c
72 x509.c
73 x509_create.c
74 x509_crl.c
75 x509_crt.c
76 x509_csr.c
77 x509write_crt.c
78 x509write_csr.c
79)
80
81set(src_tls
82 debug.c
83 net_sockets.c
84 ssl_cache.c
85 ssl_ciphersuites.c
86 ssl_cli.c
87 ssl_cookie.c
88 ssl_srv.c
89 ssl_ticket.c
90 ssl_tls.c
91)
92
93if(CMAKE_COMPILER_IS_GNUCC)
94 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wmissing-declarations -Wmissing-prototypes")
95endif(CMAKE_COMPILER_IS_GNUCC)
96
97if(CMAKE_COMPILER_IS_CLANG)
98 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wmissing-declarations -Wmissing-prototypes -Wdocumentation -Wno-documentation-deprecated-sync -Wunreachable-code")
99endif(CMAKE_COMPILER_IS_CLANG)
100
101if(WIN32)
102 set(libs ${libs} ws2_32)
103endif(WIN32)
104
105if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
106 SET(CMAKE_C_ARCHIVE_CREATE "<CMAKE_AR> Scr <TARGET> <LINK_FLAGS> <OBJECTS>")
107 SET(CMAKE_CXX_ARCHIVE_CREATE "<CMAKE_AR> Scr <TARGET> <LINK_FLAGS> <OBJECTS>")
108 SET(CMAKE_C_ARCHIVE_FINISH "<CMAKE_RANLIB> -no_warning_for_no_symbols -c <TARGET>")
109 SET(CMAKE_CXX_ARCHIVE_FINISH "<CMAKE_RANLIB> -no_warning_for_no_symbols -c <TARGET>")
110endif()
111
112if(HAIKU)
113 set(libs ${libs} network)
114endif(HAIKU)
115
116if(USE_PKCS11_HELPER_LIBRARY)
117 set(libs ${libs} pkcs11-helper)
118endif(USE_PKCS11_HELPER_LIBRARY)
119
120if(ENABLE_ZLIB_SUPPORT)
121 set(libs ${libs} ${ZLIB_LIBRARIES})
122endif(ENABLE_ZLIB_SUPPORT)
123
124if(LINK_WITH_PTHREAD)
125 set(libs ${libs} pthread)
126endif()
127
128if (NOT USE_STATIC_MBEDTLS_LIBRARY AND NOT USE_SHARED_MBEDTLS_LIBRARY)
129 message(FATAL_ERROR "Need to choose static or shared mbedtls build!")
130endif(NOT USE_STATIC_MBEDTLS_LIBRARY AND NOT USE_SHARED_MBEDTLS_LIBRARY)
131
132if(USE_STATIC_MBEDTLS_LIBRARY AND USE_SHARED_MBEDTLS_LIBRARY)
133 set(mbedtls_static_target "mbedtls_static")
134 set(mbedx509_static_target "mbedx509_static")
135 set(mbedcrypto_static_target "mbedcrypto_static")
136elseif(USE_STATIC_MBEDTLS_LIBRARY)
137 set(mbedtls_static_target "mbedtls")
138 set(mbedx509_static_target "mbedx509")
139 set(mbedcrypto_static_target "mbedcrypto")
140endif()
141
142if(USE_STATIC_MBEDTLS_LIBRARY)
143 add_library(${mbedcrypto_static_target} STATIC ${src_crypto})
144 set_target_properties(${mbedcrypto_static_target} PROPERTIES OUTPUT_NAME mbedcrypto)
145 target_link_libraries(${mbedcrypto_static_target} ${libs})
146
147 add_library(${mbedx509_static_target} STATIC ${src_x509})
148 set_target_properties(${mbedx509_static_target} PROPERTIES OUTPUT_NAME mbedx509)
149 target_link_libraries(${mbedx509_static_target} ${libs} ${mbedcrypto_static_target})
150
151 add_library(${mbedtls_static_target} STATIC ${src_tls})
152 set_target_properties(${mbedtls_static_target} PROPERTIES OUTPUT_NAME mbedtls)
153 target_link_libraries(${mbedtls_static_target} ${libs} ${mbedx509_static_target})
154
155 install(TARGETS ${mbedtls_static_target} ${mbedx509_static_target} ${mbedcrypto_static_target}
156 DESTINATION ${LIB_INSTALL_DIR}
157 PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE)
158endif(USE_STATIC_MBEDTLS_LIBRARY)
159
160if(USE_SHARED_MBEDTLS_LIBRARY)
161 add_library(mbedcrypto SHARED ${src_crypto})
162 set_target_properties(mbedcrypto PROPERTIES VERSION 2.13.0 SOVERSION 3)
163 target_link_libraries(mbedcrypto ${libs})
164
165 add_library(mbedx509 SHARED ${src_x509})
166 set_target_properties(mbedx509 PROPERTIES VERSION 2.13.0 SOVERSION 0)
167 target_link_libraries(mbedx509 ${libs} mbedcrypto)
168
169 add_library(mbedtls SHARED ${src_tls})
170 set_target_properties(mbedtls PROPERTIES VERSION 2.13.0 SOVERSION 12)
171 target_link_libraries(mbedtls ${libs} mbedx509)
172
173 install(TARGETS mbedtls mbedx509 mbedcrypto
174 DESTINATION ${LIB_INSTALL_DIR}
175 PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE)
176endif(USE_SHARED_MBEDTLS_LIBRARY)
177
178add_custom_target(lib DEPENDS mbedcrypto mbedx509 mbedtls)
179if(USE_STATIC_MBEDTLS_LIBRARY AND USE_SHARED_MBEDTLS_LIBRARY)
180 add_dependencies(lib mbedcrypto_static mbedx509_static mbedtls_static)
181endif()
diff --git a/source/mbedtls/lib/Makefile b/source/mbedtls/lib/Makefile
deleted file mode 100644
index 88c94fb..0000000
--- a/source/mbedtls/lib/Makefile
+++ /dev/null
@@ -1,46 +0,0 @@
1#---------------------------------------------------------------------------------
2.SUFFIXES:
3#---------------------------------------------------------------------------------
4
5ifeq ($(strip $(DEVKITPRO)),)
6$(error "Please set DEVKITPRO in your environment. export DEVKITPRO=<path to>/devkitpro")
7endif
8
9TOPDIR ?= $(CURDIR)
10include $(DEVKITPRO)/libnx/switch_rules
11
12# Also see "include/mbedtls/config.h"
13
14ARCH := -march=armv8-a+crypto -mtune=cortex-a57 -mtp=soft -fPIE
15CFLAGS := -g -Wall -O3 -ffunction-sections $(ARCH) $(DEFINES)
16CFLAGS += -I ../include -D__SWITCH__
17CXXFLAGS := $(CFLAGS) -fno-rtti -fno-exceptions -std=gnu++11
18ASFLAGS := -g $(ARCH)
19LDFLAGS ?= -specs=$(DEVKITPRO)/libnx/switch.specs -g $(ARCH) -Wl,-Map,$(notdir $*.map)
20
21
22OBJS_CRYPTO= aes.o cipher.o cipher_wrap.o \
23 cmac.o platform_util.o
24
25.SILENT:
26
27.PHONY: all static clean
28
29all: static
30
31static: libmbedcrypto.a
32
33# crypto
34libmbedcrypto.a: $(OBJS_CRYPTO)
35 echo " AR $@"
36 $(AR) -rc $@ $(OBJS_CRYPTO)
37 echo " RL $@"
38 $(AR) -s $@
39
40
41.c.o:
42 echo " CC $<"
43 $(CC) $(CFLAGS) $(LDFLAGS) -c $<
44
45clean:
46 rm -f *.o libmbed* \ No newline at end of file
diff --git a/source/mbedtls/lib/aes.c b/source/mbedtls/lib/aes.c
deleted file mode 100644
index 07391ec..0000000
--- a/source/mbedtls/lib/aes.c
+++ /dev/null
@@ -1,2125 +0,0 @@
1/*
2 * FIPS-197 compliant AES implementation
3 *
4 * Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
5 * SPDX-License-Identifier: GPL-2.0
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * This file is part of mbed TLS (https://tls.mbed.org)
22 */
23/*
24 * The AES block cipher was designed by Vincent Rijmen and Joan Daemen.
25 *
26 * http://csrc.nist.gov/encryption/aes/rijndael/Rijndael.pdf
27 * http://csrc.nist.gov/publications/fips/fips197/fips-197.pdf
28 */
29
30#if !defined(MBEDTLS_CONFIG_FILE)
31#include "mbedtls/config.h"
32#else
33#include MBEDTLS_CONFIG_FILE
34#endif
35
36#if defined(MBEDTLS_AES_C)
37
38#include <string.h>
39
40#include "mbedtls/aes.h"
41#include "mbedtls/platform_util.h"
42#if defined(MBEDTLS_PADLOCK_C)
43#include "mbedtls/padlock.h"
44#endif
45#if defined(MBEDTLS_AESNI_C)
46#include "mbedtls/aesni.h"
47#endif
48
49#if defined(MBEDTLS_SELF_TEST)
50#if defined(MBEDTLS_PLATFORM_C)
51#include "mbedtls/platform.h"
52#else
53#include <stdio.h>
54#define mbedtls_printf printf
55#endif /* MBEDTLS_PLATFORM_C */
56#endif /* MBEDTLS_SELF_TEST */
57
58#if !defined(MBEDTLS_AES_ALT)
59
60/*
61 * 32-bit integer manipulation macros (little endian)
62 */
63#ifndef GET_UINT32_LE
64#define GET_UINT32_LE(n,b,i) \
65{ \
66 (n) = ( (uint32_t) (b)[(i) ] ) \
67 | ( (uint32_t) (b)[(i) + 1] << 8 ) \
68 | ( (uint32_t) (b)[(i) + 2] << 16 ) \
69 | ( (uint32_t) (b)[(i) + 3] << 24 ); \
70}
71#endif
72
73#ifndef PUT_UINT32_LE
74#define PUT_UINT32_LE(n,b,i) \
75{ \
76 (b)[(i) ] = (unsigned char) ( ( (n) ) & 0xFF ); \
77 (b)[(i) + 1] = (unsigned char) ( ( (n) >> 8 ) & 0xFF ); \
78 (b)[(i) + 2] = (unsigned char) ( ( (n) >> 16 ) & 0xFF ); \
79 (b)[(i) + 3] = (unsigned char) ( ( (n) >> 24 ) & 0xFF ); \
80}
81#endif
82
83#if defined(MBEDTLS_PADLOCK_C) && \
84 ( defined(MBEDTLS_HAVE_X86) || defined(MBEDTLS_PADLOCK_ALIGN16) )
85static int aes_padlock_ace = -1;
86#endif
87
88#if defined(MBEDTLS_AES_ROM_TABLES)
89/*
90 * Forward S-box
91 */
92static const unsigned char FSb[256] =
93{
94 0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5,
95 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
96 0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0,
97 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
98 0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC,
99 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
100 0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A,
101 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
102 0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0,
103 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
104 0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B,
105 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
106 0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85,
107 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
108 0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5,
109 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
110 0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17,
111 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
112 0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88,
113 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
114 0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C,
115 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
116 0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9,
117 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
118 0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6,
119 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
120 0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E,
121 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
122 0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94,
123 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
124 0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68,
125 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16
126};
127
128/*
129 * Forward tables
130 */
131#define FT \
132\
133 V(A5,63,63,C6), V(84,7C,7C,F8), V(99,77,77,EE), V(8D,7B,7B,F6), \
134 V(0D,F2,F2,FF), V(BD,6B,6B,D6), V(B1,6F,6F,DE), V(54,C5,C5,91), \
135 V(50,30,30,60), V(03,01,01,02), V(A9,67,67,CE), V(7D,2B,2B,56), \
136 V(19,FE,FE,E7), V(62,D7,D7,B5), V(E6,AB,AB,4D), V(9A,76,76,EC), \
137 V(45,CA,CA,8F), V(9D,82,82,1F), V(40,C9,C9,89), V(87,7D,7D,FA), \
138 V(15,FA,FA,EF), V(EB,59,59,B2), V(C9,47,47,8E), V(0B,F0,F0,FB), \
139 V(EC,AD,AD,41), V(67,D4,D4,B3), V(FD,A2,A2,5F), V(EA,AF,AF,45), \
140 V(BF,9C,9C,23), V(F7,A4,A4,53), V(96,72,72,E4), V(5B,C0,C0,9B), \
141 V(C2,B7,B7,75), V(1C,FD,FD,E1), V(AE,93,93,3D), V(6A,26,26,4C), \
142 V(5A,36,36,6C), V(41,3F,3F,7E), V(02,F7,F7,F5), V(4F,CC,CC,83), \
143 V(5C,34,34,68), V(F4,A5,A5,51), V(34,E5,E5,D1), V(08,F1,F1,F9), \
144 V(93,71,71,E2), V(73,D8,D8,AB), V(53,31,31,62), V(3F,15,15,2A), \
145 V(0C,04,04,08), V(52,C7,C7,95), V(65,23,23,46), V(5E,C3,C3,9D), \
146 V(28,18,18,30), V(A1,96,96,37), V(0F,05,05,0A), V(B5,9A,9A,2F), \
147 V(09,07,07,0E), V(36,12,12,24), V(9B,80,80,1B), V(3D,E2,E2,DF), \
148 V(26,EB,EB,CD), V(69,27,27,4E), V(CD,B2,B2,7F), V(9F,75,75,EA), \
149 V(1B,09,09,12), V(9E,83,83,1D), V(74,2C,2C,58), V(2E,1A,1A,34), \
150 V(2D,1B,1B,36), V(B2,6E,6E,DC), V(EE,5A,5A,B4), V(FB,A0,A0,5B), \
151 V(F6,52,52,A4), V(4D,3B,3B,76), V(61,D6,D6,B7), V(CE,B3,B3,7D), \
152 V(7B,29,29,52), V(3E,E3,E3,DD), V(71,2F,2F,5E), V(97,84,84,13), \
153 V(F5,53,53,A6), V(68,D1,D1,B9), V(00,00,00,00), V(2C,ED,ED,C1), \
154 V(60,20,20,40), V(1F,FC,FC,E3), V(C8,B1,B1,79), V(ED,5B,5B,B6), \
155 V(BE,6A,6A,D4), V(46,CB,CB,8D), V(D9,BE,BE,67), V(4B,39,39,72), \
156 V(DE,4A,4A,94), V(D4,4C,4C,98), V(E8,58,58,B0), V(4A,CF,CF,85), \
157 V(6B,D0,D0,BB), V(2A,EF,EF,C5), V(E5,AA,AA,4F), V(16,FB,FB,ED), \
158 V(C5,43,43,86), V(D7,4D,4D,9A), V(55,33,33,66), V(94,85,85,11), \
159 V(CF,45,45,8A), V(10,F9,F9,E9), V(06,02,02,04), V(81,7F,7F,FE), \
160 V(F0,50,50,A0), V(44,3C,3C,78), V(BA,9F,9F,25), V(E3,A8,A8,4B), \
161 V(F3,51,51,A2), V(FE,A3,A3,5D), V(C0,40,40,80), V(8A,8F,8F,05), \
162 V(AD,92,92,3F), V(BC,9D,9D,21), V(48,38,38,70), V(04,F5,F5,F1), \
163 V(DF,BC,BC,63), V(C1,B6,B6,77), V(75,DA,DA,AF), V(63,21,21,42), \
164 V(30,10,10,20), V(1A,FF,FF,E5), V(0E,F3,F3,FD), V(6D,D2,D2,BF), \
165 V(4C,CD,CD,81), V(14,0C,0C,18), V(35,13,13,26), V(2F,EC,EC,C3), \
166 V(E1,5F,5F,BE), V(A2,97,97,35), V(CC,44,44,88), V(39,17,17,2E), \
167 V(57,C4,C4,93), V(F2,A7,A7,55), V(82,7E,7E,FC), V(47,3D,3D,7A), \
168 V(AC,64,64,C8), V(E7,5D,5D,BA), V(2B,19,19,32), V(95,73,73,E6), \
169 V(A0,60,60,C0), V(98,81,81,19), V(D1,4F,4F,9E), V(7F,DC,DC,A3), \
170 V(66,22,22,44), V(7E,2A,2A,54), V(AB,90,90,3B), V(83,88,88,0B), \
171 V(CA,46,46,8C), V(29,EE,EE,C7), V(D3,B8,B8,6B), V(3C,14,14,28), \
172 V(79,DE,DE,A7), V(E2,5E,5E,BC), V(1D,0B,0B,16), V(76,DB,DB,AD), \
173 V(3B,E0,E0,DB), V(56,32,32,64), V(4E,3A,3A,74), V(1E,0A,0A,14), \
174 V(DB,49,49,92), V(0A,06,06,0C), V(6C,24,24,48), V(E4,5C,5C,B8), \
175 V(5D,C2,C2,9F), V(6E,D3,D3,BD), V(EF,AC,AC,43), V(A6,62,62,C4), \
176 V(A8,91,91,39), V(A4,95,95,31), V(37,E4,E4,D3), V(8B,79,79,F2), \
177 V(32,E7,E7,D5), V(43,C8,C8,8B), V(59,37,37,6E), V(B7,6D,6D,DA), \
178 V(8C,8D,8D,01), V(64,D5,D5,B1), V(D2,4E,4E,9C), V(E0,A9,A9,49), \
179 V(B4,6C,6C,D8), V(FA,56,56,AC), V(07,F4,F4,F3), V(25,EA,EA,CF), \
180 V(AF,65,65,CA), V(8E,7A,7A,F4), V(E9,AE,AE,47), V(18,08,08,10), \
181 V(D5,BA,BA,6F), V(88,78,78,F0), V(6F,25,25,4A), V(72,2E,2E,5C), \
182 V(24,1C,1C,38), V(F1,A6,A6,57), V(C7,B4,B4,73), V(51,C6,C6,97), \
183 V(23,E8,E8,CB), V(7C,DD,DD,A1), V(9C,74,74,E8), V(21,1F,1F,3E), \
184 V(DD,4B,4B,96), V(DC,BD,BD,61), V(86,8B,8B,0D), V(85,8A,8A,0F), \
185 V(90,70,70,E0), V(42,3E,3E,7C), V(C4,B5,B5,71), V(AA,66,66,CC), \
186 V(D8,48,48,90), V(05,03,03,06), V(01,F6,F6,F7), V(12,0E,0E,1C), \
187 V(A3,61,61,C2), V(5F,35,35,6A), V(F9,57,57,AE), V(D0,B9,B9,69), \
188 V(91,86,86,17), V(58,C1,C1,99), V(27,1D,1D,3A), V(B9,9E,9E,27), \
189 V(38,E1,E1,D9), V(13,F8,F8,EB), V(B3,98,98,2B), V(33,11,11,22), \
190 V(BB,69,69,D2), V(70,D9,D9,A9), V(89,8E,8E,07), V(A7,94,94,33), \
191 V(B6,9B,9B,2D), V(22,1E,1E,3C), V(92,87,87,15), V(20,E9,E9,C9), \
192 V(49,CE,CE,87), V(FF,55,55,AA), V(78,28,28,50), V(7A,DF,DF,A5), \
193 V(8F,8C,8C,03), V(F8,A1,A1,59), V(80,89,89,09), V(17,0D,0D,1A), \
194 V(DA,BF,BF,65), V(31,E6,E6,D7), V(C6,42,42,84), V(B8,68,68,D0), \
195 V(C3,41,41,82), V(B0,99,99,29), V(77,2D,2D,5A), V(11,0F,0F,1E), \
196 V(CB,B0,B0,7B), V(FC,54,54,A8), V(D6,BB,BB,6D), V(3A,16,16,2C)
197
198#define V(a,b,c,d) 0x##a##b##c##d
199static const uint32_t FT0[256] = { FT };
200#undef V
201
202#if !defined(MBEDTLS_AES_FEWER_TABLES)
203
204#define V(a,b,c,d) 0x##b##c##d##a
205static const uint32_t FT1[256] = { FT };
206#undef V
207
208#define V(a,b,c,d) 0x##c##d##a##b
209static const uint32_t FT2[256] = { FT };
210#undef V
211
212#define V(a,b,c,d) 0x##d##a##b##c
213static const uint32_t FT3[256] = { FT };
214#undef V
215
216#endif /* !MBEDTLS_AES_FEWER_TABLES */
217
218#undef FT
219
220/*
221 * Reverse S-box
222 */
223static const unsigned char RSb[256] =
224{
225 0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38,
226 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
227 0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87,
228 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
229 0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D,
230 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
231 0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2,
232 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
233 0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16,
234 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
235 0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA,
236 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
237 0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A,
238 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
239 0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02,
240 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
241 0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA,
242 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
243 0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85,
244 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
245 0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89,
246 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
247 0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20,
248 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
249 0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31,
250 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
251 0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D,
252 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
253 0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0,
254 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
255 0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26,
256 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D
257};
258
259/*
260 * Reverse tables
261 */
262#define RT \
263\
264 V(50,A7,F4,51), V(53,65,41,7E), V(C3,A4,17,1A), V(96,5E,27,3A), \
265 V(CB,6B,AB,3B), V(F1,45,9D,1F), V(AB,58,FA,AC), V(93,03,E3,4B), \
266 V(55,FA,30,20), V(F6,6D,76,AD), V(91,76,CC,88), V(25,4C,02,F5), \
267 V(FC,D7,E5,4F), V(D7,CB,2A,C5), V(80,44,35,26), V(8F,A3,62,B5), \
268 V(49,5A,B1,DE), V(67,1B,BA,25), V(98,0E,EA,45), V(E1,C0,FE,5D), \
269 V(02,75,2F,C3), V(12,F0,4C,81), V(A3,97,46,8D), V(C6,F9,D3,6B), \
270 V(E7,5F,8F,03), V(95,9C,92,15), V(EB,7A,6D,BF), V(DA,59,52,95), \
271 V(2D,83,BE,D4), V(D3,21,74,58), V(29,69,E0,49), V(44,C8,C9,8E), \
272 V(6A,89,C2,75), V(78,79,8E,F4), V(6B,3E,58,99), V(DD,71,B9,27), \
273 V(B6,4F,E1,BE), V(17,AD,88,F0), V(66,AC,20,C9), V(B4,3A,CE,7D), \
274 V(18,4A,DF,63), V(82,31,1A,E5), V(60,33,51,97), V(45,7F,53,62), \
275 V(E0,77,64,B1), V(84,AE,6B,BB), V(1C,A0,81,FE), V(94,2B,08,F9), \
276 V(58,68,48,70), V(19,FD,45,8F), V(87,6C,DE,94), V(B7,F8,7B,52), \
277 V(23,D3,73,AB), V(E2,02,4B,72), V(57,8F,1F,E3), V(2A,AB,55,66), \
278 V(07,28,EB,B2), V(03,C2,B5,2F), V(9A,7B,C5,86), V(A5,08,37,D3), \
279 V(F2,87,28,30), V(B2,A5,BF,23), V(BA,6A,03,02), V(5C,82,16,ED), \
280 V(2B,1C,CF,8A), V(92,B4,79,A7), V(F0,F2,07,F3), V(A1,E2,69,4E), \
281 V(CD,F4,DA,65), V(D5,BE,05,06), V(1F,62,34,D1), V(8A,FE,A6,C4), \
282 V(9D,53,2E,34), V(A0,55,F3,A2), V(32,E1,8A,05), V(75,EB,F6,A4), \
283 V(39,EC,83,0B), V(AA,EF,60,40), V(06,9F,71,5E), V(51,10,6E,BD), \
284 V(F9,8A,21,3E), V(3D,06,DD,96), V(AE,05,3E,DD), V(46,BD,E6,4D), \
285 V(B5,8D,54,91), V(05,5D,C4,71), V(6F,D4,06,04), V(FF,15,50,60), \
286 V(24,FB,98,19), V(97,E9,BD,D6), V(CC,43,40,89), V(77,9E,D9,67), \
287 V(BD,42,E8,B0), V(88,8B,89,07), V(38,5B,19,E7), V(DB,EE,C8,79), \
288 V(47,0A,7C,A1), V(E9,0F,42,7C), V(C9,1E,84,F8), V(00,00,00,00), \
289 V(83,86,80,09), V(48,ED,2B,32), V(AC,70,11,1E), V(4E,72,5A,6C), \
290 V(FB,FF,0E,FD), V(56,38,85,0F), V(1E,D5,AE,3D), V(27,39,2D,36), \
291 V(64,D9,0F,0A), V(21,A6,5C,68), V(D1,54,5B,9B), V(3A,2E,36,24), \
292 V(B1,67,0A,0C), V(0F,E7,57,93), V(D2,96,EE,B4), V(9E,91,9B,1B), \
293 V(4F,C5,C0,80), V(A2,20,DC,61), V(69,4B,77,5A), V(16,1A,12,1C), \
294 V(0A,BA,93,E2), V(E5,2A,A0,C0), V(43,E0,22,3C), V(1D,17,1B,12), \
295 V(0B,0D,09,0E), V(AD,C7,8B,F2), V(B9,A8,B6,2D), V(C8,A9,1E,14), \
296 V(85,19,F1,57), V(4C,07,75,AF), V(BB,DD,99,EE), V(FD,60,7F,A3), \
297 V(9F,26,01,F7), V(BC,F5,72,5C), V(C5,3B,66,44), V(34,7E,FB,5B), \
298 V(76,29,43,8B), V(DC,C6,23,CB), V(68,FC,ED,B6), V(63,F1,E4,B8), \
299 V(CA,DC,31,D7), V(10,85,63,42), V(40,22,97,13), V(20,11,C6,84), \
300 V(7D,24,4A,85), V(F8,3D,BB,D2), V(11,32,F9,AE), V(6D,A1,29,C7), \
301 V(4B,2F,9E,1D), V(F3,30,B2,DC), V(EC,52,86,0D), V(D0,E3,C1,77), \
302 V(6C,16,B3,2B), V(99,B9,70,A9), V(FA,48,94,11), V(22,64,E9,47), \
303 V(C4,8C,FC,A8), V(1A,3F,F0,A0), V(D8,2C,7D,56), V(EF,90,33,22), \
304 V(C7,4E,49,87), V(C1,D1,38,D9), V(FE,A2,CA,8C), V(36,0B,D4,98), \
305 V(CF,81,F5,A6), V(28,DE,7A,A5), V(26,8E,B7,DA), V(A4,BF,AD,3F), \
306 V(E4,9D,3A,2C), V(0D,92,78,50), V(9B,CC,5F,6A), V(62,46,7E,54), \
307 V(C2,13,8D,F6), V(E8,B8,D8,90), V(5E,F7,39,2E), V(F5,AF,C3,82), \
308 V(BE,80,5D,9F), V(7C,93,D0,69), V(A9,2D,D5,6F), V(B3,12,25,CF), \
309 V(3B,99,AC,C8), V(A7,7D,18,10), V(6E,63,9C,E8), V(7B,BB,3B,DB), \
310 V(09,78,26,CD), V(F4,18,59,6E), V(01,B7,9A,EC), V(A8,9A,4F,83), \
311 V(65,6E,95,E6), V(7E,E6,FF,AA), V(08,CF,BC,21), V(E6,E8,15,EF), \
312 V(D9,9B,E7,BA), V(CE,36,6F,4A), V(D4,09,9F,EA), V(D6,7C,B0,29), \
313 V(AF,B2,A4,31), V(31,23,3F,2A), V(30,94,A5,C6), V(C0,66,A2,35), \
314 V(37,BC,4E,74), V(A6,CA,82,FC), V(B0,D0,90,E0), V(15,D8,A7,33), \
315 V(4A,98,04,F1), V(F7,DA,EC,41), V(0E,50,CD,7F), V(2F,F6,91,17), \
316 V(8D,D6,4D,76), V(4D,B0,EF,43), V(54,4D,AA,CC), V(DF,04,96,E4), \
317 V(E3,B5,D1,9E), V(1B,88,6A,4C), V(B8,1F,2C,C1), V(7F,51,65,46), \
318 V(04,EA,5E,9D), V(5D,35,8C,01), V(73,74,87,FA), V(2E,41,0B,FB), \
319 V(5A,1D,67,B3), V(52,D2,DB,92), V(33,56,10,E9), V(13,47,D6,6D), \
320 V(8C,61,D7,9A), V(7A,0C,A1,37), V(8E,14,F8,59), V(89,3C,13,EB), \
321 V(EE,27,A9,CE), V(35,C9,61,B7), V(ED,E5,1C,E1), V(3C,B1,47,7A), \
322 V(59,DF,D2,9C), V(3F,73,F2,55), V(79,CE,14,18), V(BF,37,C7,73), \
323 V(EA,CD,F7,53), V(5B,AA,FD,5F), V(14,6F,3D,DF), V(86,DB,44,78), \
324 V(81,F3,AF,CA), V(3E,C4,68,B9), V(2C,34,24,38), V(5F,40,A3,C2), \
325 V(72,C3,1D,16), V(0C,25,E2,BC), V(8B,49,3C,28), V(41,95,0D,FF), \
326 V(71,01,A8,39), V(DE,B3,0C,08), V(9C,E4,B4,D8), V(90,C1,56,64), \
327 V(61,84,CB,7B), V(70,B6,32,D5), V(74,5C,6C,48), V(42,57,B8,D0)
328
329#define V(a,b,c,d) 0x##a##b##c##d
330static const uint32_t RT0[256] = { RT };
331#undef V
332
333#if !defined(MBEDTLS_AES_FEWER_TABLES)
334
335#define V(a,b,c,d) 0x##b##c##d##a
336static const uint32_t RT1[256] = { RT };
337#undef V
338
339#define V(a,b,c,d) 0x##c##d##a##b
340static const uint32_t RT2[256] = { RT };
341#undef V
342
343#define V(a,b,c,d) 0x##d##a##b##c
344static const uint32_t RT3[256] = { RT };
345#undef V
346
347#endif /* !MBEDTLS_AES_FEWER_TABLES */
348
349#undef RT
350
351/*
352 * Round constants
353 */
354static const uint32_t RCON[10] =
355{
356 0x00000001, 0x00000002, 0x00000004, 0x00000008,
357 0x00000010, 0x00000020, 0x00000040, 0x00000080,
358 0x0000001B, 0x00000036
359};
360
361#else /* MBEDTLS_AES_ROM_TABLES */
362
363/*
364 * Forward S-box & tables
365 */
366static unsigned char FSb[256];
367static uint32_t FT0[256];
368#if !defined(MBEDTLS_AES_FEWER_TABLES)
369static uint32_t FT1[256];
370static uint32_t FT2[256];
371static uint32_t FT3[256];
372#endif /* !MBEDTLS_AES_FEWER_TABLES */
373
374/*
375 * Reverse S-box & tables
376 */
377static unsigned char RSb[256];
378static uint32_t RT0[256];
379#if !defined(MBEDTLS_AES_FEWER_TABLES)
380static uint32_t RT1[256];
381static uint32_t RT2[256];
382static uint32_t RT3[256];
383#endif /* !MBEDTLS_AES_FEWER_TABLES */
384
385/*
386 * Round constants
387 */
388static uint32_t RCON[10];
389
390/*
391 * Tables generation code
392 */
393#define ROTL8(x) ( ( x << 8 ) & 0xFFFFFFFF ) | ( x >> 24 )
394#define XTIME(x) ( ( x << 1 ) ^ ( ( x & 0x80 ) ? 0x1B : 0x00 ) )
395#define MUL(x,y) ( ( x && y ) ? pow[(log[x]+log[y]) % 255] : 0 )
396
397static int aes_init_done = 0;
398
399static void aes_gen_tables( void )
400{
401 int i, x, y, z;
402 int pow[256];
403 int log[256];
404
405 /*
406 * compute pow and log tables over GF(2^8)
407 */
408 for( i = 0, x = 1; i < 256; i++ )
409 {
410 pow[i] = x;
411 log[x] = i;
412 x = ( x ^ XTIME( x ) ) & 0xFF;
413 }
414
415 /*
416 * calculate the round constants
417 */
418 for( i = 0, x = 1; i < 10; i++ )
419 {
420 RCON[i] = (uint32_t) x;
421 x = XTIME( x ) & 0xFF;
422 }
423
424 /*
425 * generate the forward and reverse S-boxes
426 */
427 FSb[0x00] = 0x63;
428 RSb[0x63] = 0x00;
429
430 for( i = 1; i < 256; i++ )
431 {
432 x = pow[255 - log[i]];
433
434 y = x; y = ( ( y << 1 ) | ( y >> 7 ) ) & 0xFF;
435 x ^= y; y = ( ( y << 1 ) | ( y >> 7 ) ) & 0xFF;
436 x ^= y; y = ( ( y << 1 ) | ( y >> 7 ) ) & 0xFF;
437 x ^= y; y = ( ( y << 1 ) | ( y >> 7 ) ) & 0xFF;
438 x ^= y ^ 0x63;
439
440 FSb[i] = (unsigned char) x;
441 RSb[x] = (unsigned char) i;
442 }
443
444 /*
445 * generate the forward and reverse tables
446 */
447 for( i = 0; i < 256; i++ )
448 {
449 x = FSb[i];
450 y = XTIME( x ) & 0xFF;
451 z = ( y ^ x ) & 0xFF;
452
453 FT0[i] = ( (uint32_t) y ) ^
454 ( (uint32_t) x << 8 ) ^
455 ( (uint32_t) x << 16 ) ^
456 ( (uint32_t) z << 24 );
457
458#if !defined(MBEDTLS_AES_FEWER_TABLES)
459 FT1[i] = ROTL8( FT0[i] );
460 FT2[i] = ROTL8( FT1[i] );
461 FT3[i] = ROTL8( FT2[i] );
462#endif /* !MBEDTLS_AES_FEWER_TABLES */
463
464 x = RSb[i];
465
466 RT0[i] = ( (uint32_t) MUL( 0x0E, x ) ) ^
467 ( (uint32_t) MUL( 0x09, x ) << 8 ) ^
468 ( (uint32_t) MUL( 0x0D, x ) << 16 ) ^
469 ( (uint32_t) MUL( 0x0B, x ) << 24 );
470
471#if !defined(MBEDTLS_AES_FEWER_TABLES)
472 RT1[i] = ROTL8( RT0[i] );
473 RT2[i] = ROTL8( RT1[i] );
474 RT3[i] = ROTL8( RT2[i] );
475#endif /* !MBEDTLS_AES_FEWER_TABLES */
476 }
477}
478
479#undef ROTL8
480
481#endif /* MBEDTLS_AES_ROM_TABLES */
482
483#if defined(MBEDTLS_AES_FEWER_TABLES)
484
485#define ROTL8(x) ( (uint32_t)( ( x ) << 8 ) + (uint32_t)( ( x ) >> 24 ) )
486#define ROTL16(x) ( (uint32_t)( ( x ) << 16 ) + (uint32_t)( ( x ) >> 16 ) )
487#define ROTL24(x) ( (uint32_t)( ( x ) << 24 ) + (uint32_t)( ( x ) >> 8 ) )
488
489#define AES_RT0(idx) RT0[idx]
490#define AES_RT1(idx) ROTL8( RT0[idx] )
491#define AES_RT2(idx) ROTL16( RT0[idx] )
492#define AES_RT3(idx) ROTL24( RT0[idx] )
493
494#define AES_FT0(idx) FT0[idx]
495#define AES_FT1(idx) ROTL8( FT0[idx] )
496#define AES_FT2(idx) ROTL16( FT0[idx] )
497#define AES_FT3(idx) ROTL24( FT0[idx] )
498
499#else /* MBEDTLS_AES_FEWER_TABLES */
500
501#define AES_RT0(idx) RT0[idx]
502#define AES_RT1(idx) RT1[idx]
503#define AES_RT2(idx) RT2[idx]
504#define AES_RT3(idx) RT3[idx]
505
506#define AES_FT0(idx) FT0[idx]
507#define AES_FT1(idx) FT1[idx]
508#define AES_FT2(idx) FT2[idx]
509#define AES_FT3(idx) FT3[idx]
510
511#endif /* MBEDTLS_AES_FEWER_TABLES */
512
513void mbedtls_aes_init( mbedtls_aes_context *ctx )
514{
515 memset( ctx, 0, sizeof( mbedtls_aes_context ) );
516}
517
518void mbedtls_aes_free( mbedtls_aes_context *ctx )
519{
520 if( ctx == NULL )
521 return;
522
523 mbedtls_platform_zeroize( ctx, sizeof( mbedtls_aes_context ) );
524}
525
526#if defined(MBEDTLS_CIPHER_MODE_XTS)
527void mbedtls_aes_xts_init( mbedtls_aes_xts_context *ctx )
528{
529 mbedtls_aes_init( &ctx->crypt );
530 mbedtls_aes_init( &ctx->tweak );
531}
532
533void mbedtls_aes_xts_free( mbedtls_aes_xts_context *ctx )
534{
535 mbedtls_aes_free( &ctx->crypt );
536 mbedtls_aes_free( &ctx->tweak );
537}
538#endif /* MBEDTLS_CIPHER_MODE_XTS */
539
540/*
541 * AES key schedule (encryption)
542 */
543#if !defined(MBEDTLS_AES_SETKEY_ENC_ALT)
544int mbedtls_aes_setkey_enc( mbedtls_aes_context *ctx, const unsigned char *key,
545 unsigned int keybits )
546{
547 unsigned int i;
548 uint32_t *RK;
549
550#if !defined(MBEDTLS_AES_ROM_TABLES)
551 if( aes_init_done == 0 )
552 {
553 aes_gen_tables();
554 aes_init_done = 1;
555
556 }
557#endif
558
559 switch( keybits )
560 {
561 case 128: ctx->nr = 10; break;
562 case 192: ctx->nr = 12; break;
563 case 256: ctx->nr = 14; break;
564 default : return( MBEDTLS_ERR_AES_INVALID_KEY_LENGTH );
565 }
566
567#if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_PADLOCK_ALIGN16)
568 if( aes_padlock_ace == -1 )
569 aes_padlock_ace = mbedtls_padlock_has_support( MBEDTLS_PADLOCK_ACE );
570
571 if( aes_padlock_ace )
572 ctx->rk = RK = MBEDTLS_PADLOCK_ALIGN16( ctx->buf );
573 else
574#endif
575 ctx->rk = RK = ctx->buf;
576
577#if defined(MBEDTLS_AESNI_C) && defined(MBEDTLS_HAVE_X86_64)
578 if( mbedtls_aesni_has_support( MBEDTLS_AESNI_AES ) )
579 return( mbedtls_aesni_setkey_enc( (unsigned char *) ctx->rk, key, keybits ) );
580#endif
581
582 for( i = 0; i < ( keybits >> 5 ); i++ )
583 {
584 GET_UINT32_LE( RK[i], key, i << 2 );
585 }
586
587 switch( ctx->nr )
588 {
589 case 10:
590
591 for( i = 0; i < 10; i++, RK += 4 )
592 {
593 RK[4] = RK[0] ^ RCON[i] ^
594 ( (uint32_t) FSb[ ( RK[3] >> 8 ) & 0xFF ] ) ^
595 ( (uint32_t) FSb[ ( RK[3] >> 16 ) & 0xFF ] << 8 ) ^
596 ( (uint32_t) FSb[ ( RK[3] >> 24 ) & 0xFF ] << 16 ) ^
597 ( (uint32_t) FSb[ ( RK[3] ) & 0xFF ] << 24 );
598
599 RK[5] = RK[1] ^ RK[4];
600 RK[6] = RK[2] ^ RK[5];
601 RK[7] = RK[3] ^ RK[6];
602 }
603 break;
604
605 case 12:
606
607 for( i = 0; i < 8; i++, RK += 6 )
608 {
609 RK[6] = RK[0] ^ RCON[i] ^
610 ( (uint32_t) FSb[ ( RK[5] >> 8 ) & 0xFF ] ) ^
611 ( (uint32_t) FSb[ ( RK[5] >> 16 ) & 0xFF ] << 8 ) ^
612 ( (uint32_t) FSb[ ( RK[5] >> 24 ) & 0xFF ] << 16 ) ^
613 ( (uint32_t) FSb[ ( RK[5] ) & 0xFF ] << 24 );
614
615 RK[7] = RK[1] ^ RK[6];
616 RK[8] = RK[2] ^ RK[7];
617 RK[9] = RK[3] ^ RK[8];
618 RK[10] = RK[4] ^ RK[9];
619 RK[11] = RK[5] ^ RK[10];
620 }
621 break;
622
623 case 14:
624
625 for( i = 0; i < 7; i++, RK += 8 )
626 {
627 RK[8] = RK[0] ^ RCON[i] ^
628 ( (uint32_t) FSb[ ( RK[7] >> 8 ) & 0xFF ] ) ^
629 ( (uint32_t) FSb[ ( RK[7] >> 16 ) & 0xFF ] << 8 ) ^
630 ( (uint32_t) FSb[ ( RK[7] >> 24 ) & 0xFF ] << 16 ) ^
631 ( (uint32_t) FSb[ ( RK[7] ) & 0xFF ] << 24 );
632
633 RK[9] = RK[1] ^ RK[8];
634 RK[10] = RK[2] ^ RK[9];
635 RK[11] = RK[3] ^ RK[10];
636
637 RK[12] = RK[4] ^
638 ( (uint32_t) FSb[ ( RK[11] ) & 0xFF ] ) ^
639 ( (uint32_t) FSb[ ( RK[11] >> 8 ) & 0xFF ] << 8 ) ^
640 ( (uint32_t) FSb[ ( RK[11] >> 16 ) & 0xFF ] << 16 ) ^
641 ( (uint32_t) FSb[ ( RK[11] >> 24 ) & 0xFF ] << 24 );
642
643 RK[13] = RK[5] ^ RK[12];
644 RK[14] = RK[6] ^ RK[13];
645 RK[15] = RK[7] ^ RK[14];
646 }
647 break;
648 }
649
650 return( 0 );
651}
652#endif /* !MBEDTLS_AES_SETKEY_ENC_ALT */
653
654/*
655 * AES key schedule (decryption)
656 */
657#if !defined(MBEDTLS_AES_SETKEY_DEC_ALT)
658int mbedtls_aes_setkey_dec( mbedtls_aes_context *ctx, const unsigned char *key,
659 unsigned int keybits )
660{
661 int i, j, ret;
662 mbedtls_aes_context cty;
663 uint32_t *RK;
664 uint32_t *SK;
665
666 mbedtls_aes_init( &cty );
667
668#if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_PADLOCK_ALIGN16)
669 if( aes_padlock_ace == -1 )
670 aes_padlock_ace = mbedtls_padlock_has_support( MBEDTLS_PADLOCK_ACE );
671
672 if( aes_padlock_ace )
673 ctx->rk = RK = MBEDTLS_PADLOCK_ALIGN16( ctx->buf );
674 else
675#endif
676 ctx->rk = RK = ctx->buf;
677
678 /* Also checks keybits */
679 if( ( ret = mbedtls_aes_setkey_enc( &cty, key, keybits ) ) != 0 )
680 goto exit;
681
682 ctx->nr = cty.nr;
683
684#if defined(MBEDTLS_AESNI_C) && defined(MBEDTLS_HAVE_X86_64)
685 if( mbedtls_aesni_has_support( MBEDTLS_AESNI_AES ) )
686 {
687 mbedtls_aesni_inverse_key( (unsigned char *) ctx->rk,
688 (const unsigned char *) cty.rk, ctx->nr );
689 goto exit;
690 }
691#endif
692
693 SK = cty.rk + cty.nr * 4;
694
695 *RK++ = *SK++;
696 *RK++ = *SK++;
697 *RK++ = *SK++;
698 *RK++ = *SK++;
699
700 for( i = ctx->nr - 1, SK -= 8; i > 0; i--, SK -= 8 )
701 {
702 for( j = 0; j < 4; j++, SK++ )
703 {
704 *RK++ = AES_RT0( FSb[ ( *SK ) & 0xFF ] ) ^
705 AES_RT1( FSb[ ( *SK >> 8 ) & 0xFF ] ) ^
706 AES_RT2( FSb[ ( *SK >> 16 ) & 0xFF ] ) ^
707 AES_RT3( FSb[ ( *SK >> 24 ) & 0xFF ] );
708 }
709 }
710
711 *RK++ = *SK++;
712 *RK++ = *SK++;
713 *RK++ = *SK++;
714 *RK++ = *SK++;
715
716exit:
717 mbedtls_aes_free( &cty );
718
719 return( ret );
720}
721
722#if defined(MBEDTLS_CIPHER_MODE_XTS)
723static int mbedtls_aes_xts_decode_keys( const unsigned char *key,
724 unsigned int keybits,
725 const unsigned char **key1,
726 unsigned int *key1bits,
727 const unsigned char **key2,
728 unsigned int *key2bits )
729{
730 const unsigned int half_keybits = keybits / 2;
731 const unsigned int half_keybytes = half_keybits / 8;
732
733 switch( keybits )
734 {
735 case 256: break;
736 case 512: break;
737 default : return( MBEDTLS_ERR_AES_INVALID_KEY_LENGTH );
738 }
739
740 *key1bits = half_keybits;
741 *key2bits = half_keybits;
742 *key1 = &key[0];
743 *key2 = &key[half_keybytes];
744
745 return 0;
746}
747
748int mbedtls_aes_xts_setkey_enc( mbedtls_aes_xts_context *ctx,
749 const unsigned char *key,
750 unsigned int keybits)
751{
752 int ret;
753 const unsigned char *key1, *key2;
754 unsigned int key1bits, key2bits;
755
756 ret = mbedtls_aes_xts_decode_keys( key, keybits, &key1, &key1bits,
757 &key2, &key2bits );
758 if( ret != 0 )
759 return( ret );
760
761 /* Set the tweak key. Always set tweak key for the encryption mode. */
762 ret = mbedtls_aes_setkey_enc( &ctx->tweak, key2, key2bits );
763 if( ret != 0 )
764 return( ret );
765
766 /* Set crypt key for encryption. */
767 return mbedtls_aes_setkey_enc( &ctx->crypt, key1, key1bits );
768}
769
770int mbedtls_aes_xts_setkey_dec( mbedtls_aes_xts_context *ctx,
771 const unsigned char *key,
772 unsigned int keybits)
773{
774 int ret;
775 const unsigned char *key1, *key2;
776 unsigned int key1bits, key2bits;
777
778 ret = mbedtls_aes_xts_decode_keys( key, keybits, &key1, &key1bits,
779 &key2, &key2bits );
780 if( ret != 0 )
781 return( ret );
782
783 /* Set the tweak key. Always set tweak key for encryption. */
784 ret = mbedtls_aes_setkey_enc( &ctx->tweak, key2, key2bits );
785 if( ret != 0 )
786 return( ret );
787
788 /* Set crypt key for decryption. */
789 return mbedtls_aes_setkey_dec( &ctx->crypt, key1, key1bits );
790}
791#endif /* MBEDTLS_CIPHER_MODE_XTS */
792
793#endif /* !MBEDTLS_AES_SETKEY_DEC_ALT */
794
795#define AES_FROUND(X0,X1,X2,X3,Y0,Y1,Y2,Y3) \
796{ \
797 X0 = *RK++ ^ AES_FT0( ( Y0 ) & 0xFF ) ^ \
798 AES_FT1( ( Y1 >> 8 ) & 0xFF ) ^ \
799 AES_FT2( ( Y2 >> 16 ) & 0xFF ) ^ \
800 AES_FT3( ( Y3 >> 24 ) & 0xFF ); \
801 \
802 X1 = *RK++ ^ AES_FT0( ( Y1 ) & 0xFF ) ^ \
803 AES_FT1( ( Y2 >> 8 ) & 0xFF ) ^ \
804 AES_FT2( ( Y3 >> 16 ) & 0xFF ) ^ \
805 AES_FT3( ( Y0 >> 24 ) & 0xFF ); \
806 \
807 X2 = *RK++ ^ AES_FT0( ( Y2 ) & 0xFF ) ^ \
808 AES_FT1( ( Y3 >> 8 ) & 0xFF ) ^ \
809 AES_FT2( ( Y0 >> 16 ) & 0xFF ) ^ \
810 AES_FT3( ( Y1 >> 24 ) & 0xFF ); \
811 \
812 X3 = *RK++ ^ AES_FT0( ( Y3 ) & 0xFF ) ^ \
813 AES_FT1( ( Y0 >> 8 ) & 0xFF ) ^ \
814 AES_FT2( ( Y1 >> 16 ) & 0xFF ) ^ \
815 AES_FT3( ( Y2 >> 24 ) & 0xFF ); \
816}
817
818#define AES_RROUND(X0,X1,X2,X3,Y0,Y1,Y2,Y3) \
819{ \
820 X0 = *RK++ ^ AES_RT0( ( Y0 ) & 0xFF ) ^ \
821 AES_RT1( ( Y3 >> 8 ) & 0xFF ) ^ \
822 AES_RT2( ( Y2 >> 16 ) & 0xFF ) ^ \
823 AES_RT3( ( Y1 >> 24 ) & 0xFF ); \
824 \
825 X1 = *RK++ ^ AES_RT0( ( Y1 ) & 0xFF ) ^ \
826 AES_RT1( ( Y0 >> 8 ) & 0xFF ) ^ \
827 AES_RT2( ( Y3 >> 16 ) & 0xFF ) ^ \
828 AES_RT3( ( Y2 >> 24 ) & 0xFF ); \
829 \
830 X2 = *RK++ ^ AES_RT0( ( Y2 ) & 0xFF ) ^ \
831 AES_RT1( ( Y1 >> 8 ) & 0xFF ) ^ \
832 AES_RT2( ( Y0 >> 16 ) & 0xFF ) ^ \
833 AES_RT3( ( Y3 >> 24 ) & 0xFF ); \
834 \
835 X3 = *RK++ ^ AES_RT0( ( Y3 ) & 0xFF ) ^ \
836 AES_RT1( ( Y2 >> 8 ) & 0xFF ) ^ \
837 AES_RT2( ( Y1 >> 16 ) & 0xFF ) ^ \
838 AES_RT3( ( Y0 >> 24 ) & 0xFF ); \
839}
840
841/*
842 * AES-ECB block encryption
843 */
844#if !defined(MBEDTLS_AES_ENCRYPT_ALT)
845int mbedtls_internal_aes_encrypt( mbedtls_aes_context *ctx,
846 const unsigned char input[16],
847 unsigned char output[16] )
848{
849 int i;
850 uint32_t *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3;
851
852 RK = ctx->rk;
853
854 GET_UINT32_LE( X0, input, 0 ); X0 ^= *RK++;
855 GET_UINT32_LE( X1, input, 4 ); X1 ^= *RK++;
856 GET_UINT32_LE( X2, input, 8 ); X2 ^= *RK++;
857 GET_UINT32_LE( X3, input, 12 ); X3 ^= *RK++;
858
859 for( i = ( ctx->nr >> 1 ) - 1; i > 0; i-- )
860 {
861 AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
862 AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
863 }
864
865 AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
866
867 X0 = *RK++ ^ \
868 ( (uint32_t) FSb[ ( Y0 ) & 0xFF ] ) ^
869 ( (uint32_t) FSb[ ( Y1 >> 8 ) & 0xFF ] << 8 ) ^
870 ( (uint32_t) FSb[ ( Y2 >> 16 ) & 0xFF ] << 16 ) ^
871 ( (uint32_t) FSb[ ( Y3 >> 24 ) & 0xFF ] << 24 );
872
873 X1 = *RK++ ^ \
874 ( (uint32_t) FSb[ ( Y1 ) & 0xFF ] ) ^
875 ( (uint32_t) FSb[ ( Y2 >> 8 ) & 0xFF ] << 8 ) ^
876 ( (uint32_t) FSb[ ( Y3 >> 16 ) & 0xFF ] << 16 ) ^
877 ( (uint32_t) FSb[ ( Y0 >> 24 ) & 0xFF ] << 24 );
878
879 X2 = *RK++ ^ \
880 ( (uint32_t) FSb[ ( Y2 ) & 0xFF ] ) ^
881 ( (uint32_t) FSb[ ( Y3 >> 8 ) & 0xFF ] << 8 ) ^
882 ( (uint32_t) FSb[ ( Y0 >> 16 ) & 0xFF ] << 16 ) ^
883 ( (uint32_t) FSb[ ( Y1 >> 24 ) & 0xFF ] << 24 );
884
885 X3 = *RK++ ^ \
886 ( (uint32_t) FSb[ ( Y3 ) & 0xFF ] ) ^
887 ( (uint32_t) FSb[ ( Y0 >> 8 ) & 0xFF ] << 8 ) ^
888 ( (uint32_t) FSb[ ( Y1 >> 16 ) & 0xFF ] << 16 ) ^
889 ( (uint32_t) FSb[ ( Y2 >> 24 ) & 0xFF ] << 24 );
890
891 PUT_UINT32_LE( X0, output, 0 );
892 PUT_UINT32_LE( X1, output, 4 );
893 PUT_UINT32_LE( X2, output, 8 );
894 PUT_UINT32_LE( X3, output, 12 );
895
896 return( 0 );
897}
898#endif /* !MBEDTLS_AES_ENCRYPT_ALT */
899
900#if !defined(MBEDTLS_DEPRECATED_REMOVED)
901void mbedtls_aes_encrypt( mbedtls_aes_context *ctx,
902 const unsigned char input[16],
903 unsigned char output[16] )
904{
905 mbedtls_internal_aes_encrypt( ctx, input, output );
906}
907#endif /* !MBEDTLS_DEPRECATED_REMOVED */
908
909/*
910 * AES-ECB block decryption
911 */
912#if !defined(MBEDTLS_AES_DECRYPT_ALT)
913int mbedtls_internal_aes_decrypt( mbedtls_aes_context *ctx,
914 const unsigned char input[16],
915 unsigned char output[16] )
916{
917 int i;
918 uint32_t *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3;
919
920 RK = ctx->rk;
921
922 GET_UINT32_LE( X0, input, 0 ); X0 ^= *RK++;
923 GET_UINT32_LE( X1, input, 4 ); X1 ^= *RK++;
924 GET_UINT32_LE( X2, input, 8 ); X2 ^= *RK++;
925 GET_UINT32_LE( X3, input, 12 ); X3 ^= *RK++;
926
927 for( i = ( ctx->nr >> 1 ) - 1; i > 0; i-- )
928 {
929 AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
930 AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
931 }
932
933 AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
934
935 X0 = *RK++ ^ \
936 ( (uint32_t) RSb[ ( Y0 ) & 0xFF ] ) ^
937 ( (uint32_t) RSb[ ( Y3 >> 8 ) & 0xFF ] << 8 ) ^
938 ( (uint32_t) RSb[ ( Y2 >> 16 ) & 0xFF ] << 16 ) ^
939 ( (uint32_t) RSb[ ( Y1 >> 24 ) & 0xFF ] << 24 );
940
941 X1 = *RK++ ^ \
942 ( (uint32_t) RSb[ ( Y1 ) & 0xFF ] ) ^
943 ( (uint32_t) RSb[ ( Y0 >> 8 ) & 0xFF ] << 8 ) ^
944 ( (uint32_t) RSb[ ( Y3 >> 16 ) & 0xFF ] << 16 ) ^
945 ( (uint32_t) RSb[ ( Y2 >> 24 ) & 0xFF ] << 24 );
946
947 X2 = *RK++ ^ \
948 ( (uint32_t) RSb[ ( Y2 ) & 0xFF ] ) ^
949 ( (uint32_t) RSb[ ( Y1 >> 8 ) & 0xFF ] << 8 ) ^
950 ( (uint32_t) RSb[ ( Y0 >> 16 ) & 0xFF ] << 16 ) ^
951 ( (uint32_t) RSb[ ( Y3 >> 24 ) & 0xFF ] << 24 );
952
953 X3 = *RK++ ^ \
954 ( (uint32_t) RSb[ ( Y3 ) & 0xFF ] ) ^
955 ( (uint32_t) RSb[ ( Y2 >> 8 ) & 0xFF ] << 8 ) ^
956 ( (uint32_t) RSb[ ( Y1 >> 16 ) & 0xFF ] << 16 ) ^
957 ( (uint32_t) RSb[ ( Y0 >> 24 ) & 0xFF ] << 24 );
958
959 PUT_UINT32_LE( X0, output, 0 );
960 PUT_UINT32_LE( X1, output, 4 );
961 PUT_UINT32_LE( X2, output, 8 );
962 PUT_UINT32_LE( X3, output, 12 );
963
964 return( 0 );
965}
966#endif /* !MBEDTLS_AES_DECRYPT_ALT */
967
968#if !defined(MBEDTLS_DEPRECATED_REMOVED)
969void mbedtls_aes_decrypt( mbedtls_aes_context *ctx,
970 const unsigned char input[16],
971 unsigned char output[16] )
972{
973 mbedtls_internal_aes_decrypt( ctx, input, output );
974}
975#endif /* !MBEDTLS_DEPRECATED_REMOVED */
976
977/*
978 * AES-ECB block encryption/decryption
979 */
980int mbedtls_aes_crypt_ecb( mbedtls_aes_context *ctx,
981 int mode,
982 const unsigned char input[16],
983 unsigned char output[16] )
984{
985#if defined(MBEDTLS_AESNI_C) && defined(MBEDTLS_HAVE_X86_64)
986 if( mbedtls_aesni_has_support( MBEDTLS_AESNI_AES ) )
987 return( mbedtls_aesni_crypt_ecb( ctx, mode, input, output ) );
988#endif
989
990#if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_HAVE_X86)
991 if( aes_padlock_ace )
992 {
993 if( mbedtls_padlock_xcryptecb( ctx, mode, input, output ) == 0 )
994 return( 0 );
995
996 // If padlock data misaligned, we just fall back to
997 // unaccelerated mode
998 //
999 }
1000#endif
1001
1002 if( mode == MBEDTLS_AES_ENCRYPT )
1003 return( mbedtls_internal_aes_encrypt( ctx, input, output ) );
1004 else
1005 return( mbedtls_internal_aes_decrypt( ctx, input, output ) );
1006}
1007
1008#if defined(MBEDTLS_CIPHER_MODE_CBC)
1009/*
1010 * AES-CBC buffer encryption/decryption
1011 */
1012int mbedtls_aes_crypt_cbc( mbedtls_aes_context *ctx,
1013 int mode,
1014 size_t length,
1015 unsigned char iv[16],
1016 const unsigned char *input,
1017 unsigned char *output )
1018{
1019 int i;
1020 unsigned char temp[16];
1021
1022 if( length % 16 )
1023 return( MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH );
1024
1025#if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_HAVE_X86)
1026 if( aes_padlock_ace )
1027 {
1028 if( mbedtls_padlock_xcryptcbc( ctx, mode, length, iv, input, output ) == 0 )
1029 return( 0 );
1030
1031 // If padlock data misaligned, we just fall back to
1032 // unaccelerated mode
1033 //
1034 }
1035#endif
1036
1037 if( mode == MBEDTLS_AES_DECRYPT )
1038 {
1039 while( length > 0 )
1040 {
1041 memcpy( temp, input, 16 );
1042 mbedtls_aes_crypt_ecb( ctx, mode, input, output );
1043
1044 for( i = 0; i < 16; i++ )
1045 output[i] = (unsigned char)( output[i] ^ iv[i] );
1046
1047 memcpy( iv, temp, 16 );
1048
1049 input += 16;
1050 output += 16;
1051 length -= 16;
1052 }
1053 }
1054 else
1055 {
1056 while( length > 0 )
1057 {
1058 for( i = 0; i < 16; i++ )
1059 output[i] = (unsigned char)( input[i] ^ iv[i] );
1060
1061 mbedtls_aes_crypt_ecb( ctx, mode, output, output );
1062 memcpy( iv, output, 16 );
1063
1064 input += 16;
1065 output += 16;
1066 length -= 16;
1067 }
1068 }
1069
1070 return( 0 );
1071}
1072#endif /* MBEDTLS_CIPHER_MODE_CBC */
1073
1074#if defined(MBEDTLS_CIPHER_MODE_XTS)
1075
1076/* Endianess with 64 bits values */
1077#ifndef GET_UINT64_LE
1078#define GET_UINT64_LE(n,b,i) \
1079{ \
1080 (n) = ( (uint64_t) (b)[(i) + 7] << 56 ) \
1081 | ( (uint64_t) (b)[(i) + 6] << 48 ) \
1082 | ( (uint64_t) (b)[(i) + 5] << 40 ) \
1083 | ( (uint64_t) (b)[(i) + 4] << 32 ) \
1084 | ( (uint64_t) (b)[(i) + 3] << 24 ) \
1085 | ( (uint64_t) (b)[(i) + 2] << 16 ) \
1086 | ( (uint64_t) (b)[(i) + 1] << 8 ) \
1087 | ( (uint64_t) (b)[(i) ] ); \
1088}
1089#endif
1090
1091#ifndef PUT_UINT64_LE
1092#define PUT_UINT64_LE(n,b,i) \
1093{ \
1094 (b)[(i) + 7] = (unsigned char) ( (n) >> 56 ); \
1095 (b)[(i) + 6] = (unsigned char) ( (n) >> 48 ); \
1096 (b)[(i) + 5] = (unsigned char) ( (n) >> 40 ); \
1097 (b)[(i) + 4] = (unsigned char) ( (n) >> 32 ); \
1098 (b)[(i) + 3] = (unsigned char) ( (n) >> 24 ); \
1099 (b)[(i) + 2] = (unsigned char) ( (n) >> 16 ); \
1100 (b)[(i) + 1] = (unsigned char) ( (n) >> 8 ); \
1101 (b)[(i) ] = (unsigned char) ( (n) ); \
1102}
1103#endif
1104
1105typedef unsigned char mbedtls_be128[16];
1106
1107/*
1108 * GF(2^128) multiplication function
1109 *
1110 * This function multiplies a field element by x in the polynomial field
1111 * representation. It uses 64-bit word operations to gain speed but compensates
1112 * for machine endianess and hence works correctly on both big and little
1113 * endian machines.
1114 */
1115static void mbedtls_gf128mul_x_ble( unsigned char r[16],
1116 const unsigned char x[16] )
1117{
1118 uint64_t a, b, ra, rb;
1119
1120 GET_UINT64_LE( a, x, 0 );
1121 GET_UINT64_LE( b, x, 8 );
1122
1123 ra = ( a << 1 ) ^ 0x0087 >> ( 8 - ( ( b >> 63 ) << 3 ) );
1124 rb = ( a >> 63 ) | ( b << 1 );
1125
1126 PUT_UINT64_LE( ra, r, 0 );
1127 PUT_UINT64_LE( rb, r, 8 );
1128}
1129
1130/*
1131 * AES-XTS buffer encryption/decryption
1132 */
1133int mbedtls_aes_crypt_xts( mbedtls_aes_xts_context *ctx,
1134 int mode,
1135 size_t length,
1136 const unsigned char data_unit[16],
1137 const unsigned char *input,
1138 unsigned char *output )
1139{
1140 int ret;
1141 size_t blocks = length / 16;
1142 size_t leftover = length % 16;
1143 unsigned char tweak[16];
1144 unsigned char prev_tweak[16];
1145 unsigned char tmp[16];
1146
1147 /* Sectors must be at least 16 bytes. */
1148 if( length < 16 )
1149 return MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH;
1150
1151 /* NIST SP 80-38E disallows data units larger than 2**20 blocks. */
1152 if( length > ( 1 << 20 ) * 16 )
1153 return MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH;
1154
1155 /* Compute the tweak. */
1156 ret = mbedtls_aes_crypt_ecb( &ctx->tweak, MBEDTLS_AES_ENCRYPT,
1157 data_unit, tweak );
1158 if( ret != 0 )
1159 return( ret );
1160
1161 while( blocks-- )
1162 {
1163 size_t i;
1164
1165 if( leftover && ( mode == MBEDTLS_AES_DECRYPT ) && blocks == 0 )
1166 {
1167 /* We are on the last block in a decrypt operation that has
1168 * leftover bytes, so we need to use the next tweak for this block,
1169 * and this tweak for the lefover bytes. Save the current tweak for
1170 * the leftovers and then update the current tweak for use on this,
1171 * the last full block. */
1172 memcpy( prev_tweak, tweak, sizeof( tweak ) );
1173 mbedtls_gf128mul_x_ble( tweak, tweak );
1174 }
1175
1176 for( i = 0; i < 16; i++ )
1177 tmp[i] = input[i] ^ tweak[i];
1178
1179 ret = mbedtls_aes_crypt_ecb( &ctx->crypt, mode, tmp, tmp );
1180 if( ret != 0 )
1181 return( ret );
1182
1183 for( i = 0; i < 16; i++ )
1184 output[i] = tmp[i] ^ tweak[i];
1185
1186 /* Update the tweak for the next block. */
1187 mbedtls_gf128mul_x_ble( tweak, tweak );
1188
1189 output += 16;
1190 input += 16;
1191 }
1192
1193 if( leftover )
1194 {
1195 /* If we are on the leftover bytes in a decrypt operation, we need to
1196 * use the previous tweak for these bytes (as saved in prev_tweak). */
1197 unsigned char *t = mode == MBEDTLS_AES_DECRYPT ? prev_tweak : tweak;
1198
1199 /* We are now on the final part of the data unit, which doesn't divide
1200 * evenly by 16. It's time for ciphertext stealing. */
1201 size_t i;
1202 unsigned char *prev_output = output - 16;
1203
1204 /* Copy ciphertext bytes from the previous block to our output for each
1205 * byte of cyphertext we won't steal. At the same time, copy the
1206 * remainder of the input for this final round (since the loop bounds
1207 * are the same). */
1208 for( i = 0; i < leftover; i++ )
1209 {
1210 output[i] = prev_output[i];
1211 tmp[i] = input[i] ^ t[i];
1212 }
1213
1214 /* Copy ciphertext bytes from the previous block for input in this
1215 * round. */
1216 for( ; i < 16; i++ )
1217 tmp[i] = prev_output[i] ^ t[i];
1218
1219 ret = mbedtls_aes_crypt_ecb( &ctx->crypt, mode, tmp, tmp );
1220 if( ret != 0 )
1221 return ret;
1222
1223 /* Write the result back to the previous block, overriding the previous
1224 * output we copied. */
1225 for( i = 0; i < 16; i++ )
1226 prev_output[i] = tmp[i] ^ t[i];
1227 }
1228
1229 return( 0 );
1230}
1231#endif /* MBEDTLS_CIPHER_MODE_XTS */
1232
1233#if defined(MBEDTLS_CIPHER_MODE_CFB)
1234/*
1235 * AES-CFB128 buffer encryption/decryption
1236 */
1237int mbedtls_aes_crypt_cfb128( mbedtls_aes_context *ctx,
1238 int mode,
1239 size_t length,
1240 size_t *iv_off,
1241 unsigned char iv[16],
1242 const unsigned char *input,
1243 unsigned char *output )
1244{
1245 int c;
1246 size_t n = *iv_off;
1247
1248 if( mode == MBEDTLS_AES_DECRYPT )
1249 {
1250 while( length-- )
1251 {
1252 if( n == 0 )
1253 mbedtls_aes_crypt_ecb( ctx, MBEDTLS_AES_ENCRYPT, iv, iv );
1254
1255 c = *input++;
1256 *output++ = (unsigned char)( c ^ iv[n] );
1257 iv[n] = (unsigned char) c;
1258
1259 n = ( n + 1 ) & 0x0F;
1260 }
1261 }
1262 else
1263 {
1264 while( length-- )
1265 {
1266 if( n == 0 )
1267 mbedtls_aes_crypt_ecb( ctx, MBEDTLS_AES_ENCRYPT, iv, iv );
1268
1269 iv[n] = *output++ = (unsigned char)( iv[n] ^ *input++ );
1270
1271 n = ( n + 1 ) & 0x0F;
1272 }
1273 }
1274
1275 *iv_off = n;
1276
1277 return( 0 );
1278}
1279
1280/*
1281 * AES-CFB8 buffer encryption/decryption
1282 */
1283int mbedtls_aes_crypt_cfb8( mbedtls_aes_context *ctx,
1284 int mode,
1285 size_t length,
1286 unsigned char iv[16],
1287 const unsigned char *input,
1288 unsigned char *output )
1289{
1290 unsigned char c;
1291 unsigned char ov[17];
1292
1293 while( length-- )
1294 {
1295 memcpy( ov, iv, 16 );
1296 mbedtls_aes_crypt_ecb( ctx, MBEDTLS_AES_ENCRYPT, iv, iv );
1297
1298 if( mode == MBEDTLS_AES_DECRYPT )
1299 ov[16] = *input;
1300
1301 c = *output++ = (unsigned char)( iv[0] ^ *input++ );
1302
1303 if( mode == MBEDTLS_AES_ENCRYPT )
1304 ov[16] = c;
1305
1306 memcpy( iv, ov + 1, 16 );
1307 }
1308
1309 return( 0 );
1310}
1311#endif /* MBEDTLS_CIPHER_MODE_CFB */
1312
1313#if defined(MBEDTLS_CIPHER_MODE_OFB)
1314/*
1315 * AES-OFB (Output Feedback Mode) buffer encryption/decryption
1316 */
1317int mbedtls_aes_crypt_ofb( mbedtls_aes_context *ctx,
1318 size_t length,
1319 size_t *iv_off,
1320 unsigned char iv[16],
1321 const unsigned char *input,
1322 unsigned char *output )
1323{
1324 int ret = 0;
1325 size_t n = *iv_off;
1326
1327 while( length-- )
1328 {
1329 if( n == 0 )
1330 {
1331 ret = mbedtls_aes_crypt_ecb( ctx, MBEDTLS_AES_ENCRYPT, iv, iv );
1332 if( ret != 0 )
1333 goto exit;
1334 }
1335 *output++ = *input++ ^ iv[n];
1336
1337 n = ( n + 1 ) & 0x0F;
1338 }
1339
1340 *iv_off = n;
1341
1342exit:
1343 return( ret );
1344}
1345#endif /* MBEDTLS_CIPHER_MODE_OFB */
1346
1347#if defined(MBEDTLS_CIPHER_MODE_CTR)
1348/*
1349 * AES-CTR buffer encryption/decryption
1350 */
1351int mbedtls_aes_crypt_ctr( mbedtls_aes_context *ctx,
1352 size_t length,
1353 size_t *nc_off,
1354 unsigned char nonce_counter[16],
1355 unsigned char stream_block[16],
1356 const unsigned char *input,
1357 unsigned char *output )
1358{
1359 int c, i;
1360 size_t n = *nc_off;
1361
1362 if ( n > 0x0F )
1363 return( MBEDTLS_ERR_AES_BAD_INPUT_DATA );
1364
1365 while( length-- )
1366 {
1367 if( n == 0 ) {
1368 mbedtls_aes_crypt_ecb( ctx, MBEDTLS_AES_ENCRYPT, nonce_counter, stream_block );
1369
1370 for( i = 16; i > 0; i-- )
1371 if( ++nonce_counter[i - 1] != 0 )
1372 break;
1373 }
1374 c = *input++;
1375 *output++ = (unsigned char)( c ^ stream_block[n] );
1376
1377 n = ( n + 1 ) & 0x0F;
1378 }
1379
1380 *nc_off = n;
1381
1382 return( 0 );
1383}
1384#endif /* MBEDTLS_CIPHER_MODE_CTR */
1385
1386#endif /* !MBEDTLS_AES_ALT */
1387
1388#if defined(MBEDTLS_SELF_TEST)
1389/*
1390 * AES test vectors from:
1391 *
1392 * http://csrc.nist.gov/archive/aes/rijndael/rijndael-vals.zip
1393 */
1394static const unsigned char aes_test_ecb_dec[3][16] =
1395{
1396 { 0x44, 0x41, 0x6A, 0xC2, 0xD1, 0xF5, 0x3C, 0x58,
1397 0x33, 0x03, 0x91, 0x7E, 0x6B, 0xE9, 0xEB, 0xE0 },
1398 { 0x48, 0xE3, 0x1E, 0x9E, 0x25, 0x67, 0x18, 0xF2,
1399 0x92, 0x29, 0x31, 0x9C, 0x19, 0xF1, 0x5B, 0xA4 },
1400 { 0x05, 0x8C, 0xCF, 0xFD, 0xBB, 0xCB, 0x38, 0x2D,
1401 0x1F, 0x6F, 0x56, 0x58, 0x5D, 0x8A, 0x4A, 0xDE }
1402};
1403
1404static const unsigned char aes_test_ecb_enc[3][16] =
1405{
1406 { 0xC3, 0x4C, 0x05, 0x2C, 0xC0, 0xDA, 0x8D, 0x73,
1407 0x45, 0x1A, 0xFE, 0x5F, 0x03, 0xBE, 0x29, 0x7F },
1408 { 0xF3, 0xF6, 0x75, 0x2A, 0xE8, 0xD7, 0x83, 0x11,
1409 0x38, 0xF0, 0x41, 0x56, 0x06, 0x31, 0xB1, 0x14 },
1410 { 0x8B, 0x79, 0xEE, 0xCC, 0x93, 0xA0, 0xEE, 0x5D,
1411 0xFF, 0x30, 0xB4, 0xEA, 0x21, 0x63, 0x6D, 0xA4 }
1412};
1413
1414#if defined(MBEDTLS_CIPHER_MODE_CBC)
1415static const unsigned char aes_test_cbc_dec[3][16] =
1416{
1417 { 0xFA, 0xCA, 0x37, 0xE0, 0xB0, 0xC8, 0x53, 0x73,
1418 0xDF, 0x70, 0x6E, 0x73, 0xF7, 0xC9, 0xAF, 0x86 },
1419 { 0x5D, 0xF6, 0x78, 0xDD, 0x17, 0xBA, 0x4E, 0x75,
1420 0xB6, 0x17, 0x68, 0xC6, 0xAD, 0xEF, 0x7C, 0x7B },
1421 { 0x48, 0x04, 0xE1, 0x81, 0x8F, 0xE6, 0x29, 0x75,
1422 0x19, 0xA3, 0xE8, 0x8C, 0x57, 0x31, 0x04, 0x13 }
1423};
1424
1425static const unsigned char aes_test_cbc_enc[3][16] =
1426{
1427 { 0x8A, 0x05, 0xFC, 0x5E, 0x09, 0x5A, 0xF4, 0x84,
1428 0x8A, 0x08, 0xD3, 0x28, 0xD3, 0x68, 0x8E, 0x3D },
1429 { 0x7B, 0xD9, 0x66, 0xD5, 0x3A, 0xD8, 0xC1, 0xBB,
1430 0x85, 0xD2, 0xAD, 0xFA, 0xE8, 0x7B, 0xB1, 0x04 },
1431 { 0xFE, 0x3C, 0x53, 0x65, 0x3E, 0x2F, 0x45, 0xB5,
1432 0x6F, 0xCD, 0x88, 0xB2, 0xCC, 0x89, 0x8F, 0xF0 }
1433};
1434#endif /* MBEDTLS_CIPHER_MODE_CBC */
1435
1436#if defined(MBEDTLS_CIPHER_MODE_CFB)
1437/*
1438 * AES-CFB128 test vectors from:
1439 *
1440 * http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
1441 */
1442static const unsigned char aes_test_cfb128_key[3][32] =
1443{
1444 { 0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6,
1445 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C },
1446 { 0x8E, 0x73, 0xB0, 0xF7, 0xDA, 0x0E, 0x64, 0x52,
1447 0xC8, 0x10, 0xF3, 0x2B, 0x80, 0x90, 0x79, 0xE5,
1448 0x62, 0xF8, 0xEA, 0xD2, 0x52, 0x2C, 0x6B, 0x7B },
1449 { 0x60, 0x3D, 0xEB, 0x10, 0x15, 0xCA, 0x71, 0xBE,
1450 0x2B, 0x73, 0xAE, 0xF0, 0x85, 0x7D, 0x77, 0x81,
1451 0x1F, 0x35, 0x2C, 0x07, 0x3B, 0x61, 0x08, 0xD7,
1452 0x2D, 0x98, 0x10, 0xA3, 0x09, 0x14, 0xDF, 0xF4 }
1453};
1454
1455static const unsigned char aes_test_cfb128_iv[16] =
1456{
1457 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1458 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
1459};
1460
1461static const unsigned char aes_test_cfb128_pt[64] =
1462{
1463 0x6B, 0xC1, 0xBE, 0xE2, 0x2E, 0x40, 0x9F, 0x96,
1464 0xE9, 0x3D, 0x7E, 0x11, 0x73, 0x93, 0x17, 0x2A,
1465 0xAE, 0x2D, 0x8A, 0x57, 0x1E, 0x03, 0xAC, 0x9C,
1466 0x9E, 0xB7, 0x6F, 0xAC, 0x45, 0xAF, 0x8E, 0x51,
1467 0x30, 0xC8, 0x1C, 0x46, 0xA3, 0x5C, 0xE4, 0x11,
1468 0xE5, 0xFB, 0xC1, 0x19, 0x1A, 0x0A, 0x52, 0xEF,
1469 0xF6, 0x9F, 0x24, 0x45, 0xDF, 0x4F, 0x9B, 0x17,
1470 0xAD, 0x2B, 0x41, 0x7B, 0xE6, 0x6C, 0x37, 0x10
1471};
1472
1473static const unsigned char aes_test_cfb128_ct[3][64] =
1474{
1475 { 0x3B, 0x3F, 0xD9, 0x2E, 0xB7, 0x2D, 0xAD, 0x20,
1476 0x33, 0x34, 0x49, 0xF8, 0xE8, 0x3C, 0xFB, 0x4A,
1477 0xC8, 0xA6, 0x45, 0x37, 0xA0, 0xB3, 0xA9, 0x3F,
1478 0xCD, 0xE3, 0xCD, 0xAD, 0x9F, 0x1C, 0xE5, 0x8B,
1479 0x26, 0x75, 0x1F, 0x67, 0xA3, 0xCB, 0xB1, 0x40,
1480 0xB1, 0x80, 0x8C, 0xF1, 0x87, 0xA4, 0xF4, 0xDF,
1481 0xC0, 0x4B, 0x05, 0x35, 0x7C, 0x5D, 0x1C, 0x0E,
1482 0xEA, 0xC4, 0xC6, 0x6F, 0x9F, 0xF7, 0xF2, 0xE6 },
1483 { 0xCD, 0xC8, 0x0D, 0x6F, 0xDD, 0xF1, 0x8C, 0xAB,
1484 0x34, 0xC2, 0x59, 0x09, 0xC9, 0x9A, 0x41, 0x74,
1485 0x67, 0xCE, 0x7F, 0x7F, 0x81, 0x17, 0x36, 0x21,
1486 0x96, 0x1A, 0x2B, 0x70, 0x17, 0x1D, 0x3D, 0x7A,
1487 0x2E, 0x1E, 0x8A, 0x1D, 0xD5, 0x9B, 0x88, 0xB1,
1488 0xC8, 0xE6, 0x0F, 0xED, 0x1E, 0xFA, 0xC4, 0xC9,
1489 0xC0, 0x5F, 0x9F, 0x9C, 0xA9, 0x83, 0x4F, 0xA0,
1490 0x42, 0xAE, 0x8F, 0xBA, 0x58, 0x4B, 0x09, 0xFF },
1491 { 0xDC, 0x7E, 0x84, 0xBF, 0xDA, 0x79, 0x16, 0x4B,
1492 0x7E, 0xCD, 0x84, 0x86, 0x98, 0x5D, 0x38, 0x60,
1493 0x39, 0xFF, 0xED, 0x14, 0x3B, 0x28, 0xB1, 0xC8,
1494 0x32, 0x11, 0x3C, 0x63, 0x31, 0xE5, 0x40, 0x7B,
1495 0xDF, 0x10, 0x13, 0x24, 0x15, 0xE5, 0x4B, 0x92,
1496 0xA1, 0x3E, 0xD0, 0xA8, 0x26, 0x7A, 0xE2, 0xF9,
1497 0x75, 0xA3, 0x85, 0x74, 0x1A, 0xB9, 0xCE, 0xF8,
1498 0x20, 0x31, 0x62, 0x3D, 0x55, 0xB1, 0xE4, 0x71 }
1499};
1500#endif /* MBEDTLS_CIPHER_MODE_CFB */
1501
1502#if defined(MBEDTLS_CIPHER_MODE_OFB)
1503/*
1504 * AES-OFB test vectors from:
1505 *
1506 * https://csrc.nist.gov/publications/detail/sp/800-38a/final
1507 */
1508static const unsigned char aes_test_ofb_key[3][32] =
1509{
1510 { 0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6,
1511 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C },
1512 { 0x8E, 0x73, 0xB0, 0xF7, 0xDA, 0x0E, 0x64, 0x52,
1513 0xC8, 0x10, 0xF3, 0x2B, 0x80, 0x90, 0x79, 0xE5,
1514 0x62, 0xF8, 0xEA, 0xD2, 0x52, 0x2C, 0x6B, 0x7B },
1515 { 0x60, 0x3D, 0xEB, 0x10, 0x15, 0xCA, 0x71, 0xBE,
1516 0x2B, 0x73, 0xAE, 0xF0, 0x85, 0x7D, 0x77, 0x81,
1517 0x1F, 0x35, 0x2C, 0x07, 0x3B, 0x61, 0x08, 0xD7,
1518 0x2D, 0x98, 0x10, 0xA3, 0x09, 0x14, 0xDF, 0xF4 }
1519};
1520
1521static const unsigned char aes_test_ofb_iv[16] =
1522{
1523 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1524 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
1525};
1526
1527static const unsigned char aes_test_ofb_pt[64] =
1528{
1529 0x6B, 0xC1, 0xBE, 0xE2, 0x2E, 0x40, 0x9F, 0x96,
1530 0xE9, 0x3D, 0x7E, 0x11, 0x73, 0x93, 0x17, 0x2A,
1531 0xAE, 0x2D, 0x8A, 0x57, 0x1E, 0x03, 0xAC, 0x9C,
1532 0x9E, 0xB7, 0x6F, 0xAC, 0x45, 0xAF, 0x8E, 0x51,
1533 0x30, 0xC8, 0x1C, 0x46, 0xA3, 0x5C, 0xE4, 0x11,
1534 0xE5, 0xFB, 0xC1, 0x19, 0x1A, 0x0A, 0x52, 0xEF,
1535 0xF6, 0x9F, 0x24, 0x45, 0xDF, 0x4F, 0x9B, 0x17,
1536 0xAD, 0x2B, 0x41, 0x7B, 0xE6, 0x6C, 0x37, 0x10
1537};
1538
1539static const unsigned char aes_test_ofb_ct[3][64] =
1540{
1541 { 0x3B, 0x3F, 0xD9, 0x2E, 0xB7, 0x2D, 0xAD, 0x20,
1542 0x33, 0x34, 0x49, 0xF8, 0xE8, 0x3C, 0xFB, 0x4A,
1543 0x77, 0x89, 0x50, 0x8d, 0x16, 0x91, 0x8f, 0x03,
1544 0xf5, 0x3c, 0x52, 0xda, 0xc5, 0x4e, 0xd8, 0x25,
1545 0x97, 0x40, 0x05, 0x1e, 0x9c, 0x5f, 0xec, 0xf6,
1546 0x43, 0x44, 0xf7, 0xa8, 0x22, 0x60, 0xed, 0xcc,
1547 0x30, 0x4c, 0x65, 0x28, 0xf6, 0x59, 0xc7, 0x78,
1548 0x66, 0xa5, 0x10, 0xd9, 0xc1, 0xd6, 0xae, 0x5e },
1549 { 0xCD, 0xC8, 0x0D, 0x6F, 0xDD, 0xF1, 0x8C, 0xAB,
1550 0x34, 0xC2, 0x59, 0x09, 0xC9, 0x9A, 0x41, 0x74,
1551 0xfc, 0xc2, 0x8b, 0x8d, 0x4c, 0x63, 0x83, 0x7c,
1552 0x09, 0xe8, 0x17, 0x00, 0xc1, 0x10, 0x04, 0x01,
1553 0x8d, 0x9a, 0x9a, 0xea, 0xc0, 0xf6, 0x59, 0x6f,
1554 0x55, 0x9c, 0x6d, 0x4d, 0xaf, 0x59, 0xa5, 0xf2,
1555 0x6d, 0x9f, 0x20, 0x08, 0x57, 0xca, 0x6c, 0x3e,
1556 0x9c, 0xac, 0x52, 0x4b, 0xd9, 0xac, 0xc9, 0x2a },
1557 { 0xDC, 0x7E, 0x84, 0xBF, 0xDA, 0x79, 0x16, 0x4B,
1558 0x7E, 0xCD, 0x84, 0x86, 0x98, 0x5D, 0x38, 0x60,
1559 0x4f, 0xeb, 0xdc, 0x67, 0x40, 0xd2, 0x0b, 0x3a,
1560 0xc8, 0x8f, 0x6a, 0xd8, 0x2a, 0x4f, 0xb0, 0x8d,
1561 0x71, 0xab, 0x47, 0xa0, 0x86, 0xe8, 0x6e, 0xed,
1562 0xf3, 0x9d, 0x1c, 0x5b, 0xba, 0x97, 0xc4, 0x08,
1563 0x01, 0x26, 0x14, 0x1d, 0x67, 0xf3, 0x7b, 0xe8,
1564 0x53, 0x8f, 0x5a, 0x8b, 0xe7, 0x40, 0xe4, 0x84 }
1565};
1566#endif /* MBEDTLS_CIPHER_MODE_OFB */
1567
1568#if defined(MBEDTLS_CIPHER_MODE_CTR)
1569/*
1570 * AES-CTR test vectors from:
1571 *
1572 * http://www.faqs.org/rfcs/rfc3686.html
1573 */
1574
1575static const unsigned char aes_test_ctr_key[3][16] =
1576{
1577 { 0xAE, 0x68, 0x52, 0xF8, 0x12, 0x10, 0x67, 0xCC,
1578 0x4B, 0xF7, 0xA5, 0x76, 0x55, 0x77, 0xF3, 0x9E },
1579 { 0x7E, 0x24, 0x06, 0x78, 0x17, 0xFA, 0xE0, 0xD7,
1580 0x43, 0xD6, 0xCE, 0x1F, 0x32, 0x53, 0x91, 0x63 },
1581 { 0x76, 0x91, 0xBE, 0x03, 0x5E, 0x50, 0x20, 0xA8,
1582 0xAC, 0x6E, 0x61, 0x85, 0x29, 0xF9, 0xA0, 0xDC }
1583};
1584
1585static const unsigned char aes_test_ctr_nonce_counter[3][16] =
1586{
1587 { 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00,
1588 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 },
1589 { 0x00, 0x6C, 0xB6, 0xDB, 0xC0, 0x54, 0x3B, 0x59,
1590 0xDA, 0x48, 0xD9, 0x0B, 0x00, 0x00, 0x00, 0x01 },
1591 { 0x00, 0xE0, 0x01, 0x7B, 0x27, 0x77, 0x7F, 0x3F,
1592 0x4A, 0x17, 0x86, 0xF0, 0x00, 0x00, 0x00, 0x01 }
1593};
1594
1595static const unsigned char aes_test_ctr_pt[3][48] =
1596{
1597 { 0x53, 0x69, 0x6E, 0x67, 0x6C, 0x65, 0x20, 0x62,
1598 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x6D, 0x73, 0x67 },
1599
1600 { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1601 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
1602 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
1603 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F },
1604
1605 { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1606 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
1607 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
1608 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
1609 0x20, 0x21, 0x22, 0x23 }
1610};
1611
1612static const unsigned char aes_test_ctr_ct[3][48] =
1613{
1614 { 0xE4, 0x09, 0x5D, 0x4F, 0xB7, 0xA7, 0xB3, 0x79,
1615 0x2D, 0x61, 0x75, 0xA3, 0x26, 0x13, 0x11, 0xB8 },
1616 { 0x51, 0x04, 0xA1, 0x06, 0x16, 0x8A, 0x72, 0xD9,
1617 0x79, 0x0D, 0x41, 0xEE, 0x8E, 0xDA, 0xD3, 0x88,
1618 0xEB, 0x2E, 0x1E, 0xFC, 0x46, 0xDA, 0x57, 0xC8,
1619 0xFC, 0xE6, 0x30, 0xDF, 0x91, 0x41, 0xBE, 0x28 },
1620 { 0xC1, 0xCF, 0x48, 0xA8, 0x9F, 0x2F, 0xFD, 0xD9,
1621 0xCF, 0x46, 0x52, 0xE9, 0xEF, 0xDB, 0x72, 0xD7,
1622 0x45, 0x40, 0xA4, 0x2B, 0xDE, 0x6D, 0x78, 0x36,
1623 0xD5, 0x9A, 0x5C, 0xEA, 0xAE, 0xF3, 0x10, 0x53,
1624 0x25, 0xB2, 0x07, 0x2F }
1625};
1626
1627static const int aes_test_ctr_len[3] =
1628 { 16, 32, 36 };
1629#endif /* MBEDTLS_CIPHER_MODE_CTR */
1630
1631#if defined(MBEDTLS_CIPHER_MODE_XTS)
1632/*
1633 * AES-XTS test vectors from:
1634 *
1635 * IEEE P1619/D16 Annex B
1636 * https://web.archive.org/web/20150629024421/http://grouper.ieee.org/groups/1619/email/pdf00086.pdf
1637 * (Archived from original at http://grouper.ieee.org/groups/1619/email/pdf00086.pdf)
1638 */
1639static const unsigned char aes_test_xts_key[][32] =
1640{
1641 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1642 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1643 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1644 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1645 { 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
1646 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
1647 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
1648 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22 },
1649 { 0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8,
1650 0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1, 0xf0,
1651 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
1652 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22 },
1653};
1654
1655static const unsigned char aes_test_xts_pt32[][32] =
1656{
1657 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1658 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1659 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1660 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1661 { 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
1662 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
1663 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
1664 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44 },
1665 { 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
1666 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
1667 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
1668 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44 },
1669};
1670
1671static const unsigned char aes_test_xts_ct32[][32] =
1672{
1673 { 0x91, 0x7c, 0xf6, 0x9e, 0xbd, 0x68, 0xb2, 0xec,
1674 0x9b, 0x9f, 0xe9, 0xa3, 0xea, 0xdd, 0xa6, 0x92,
1675 0xcd, 0x43, 0xd2, 0xf5, 0x95, 0x98, 0xed, 0x85,
1676 0x8c, 0x02, 0xc2, 0x65, 0x2f, 0xbf, 0x92, 0x2e },
1677 { 0xc4, 0x54, 0x18, 0x5e, 0x6a, 0x16, 0x93, 0x6e,
1678 0x39, 0x33, 0x40, 0x38, 0xac, 0xef, 0x83, 0x8b,
1679 0xfb, 0x18, 0x6f, 0xff, 0x74, 0x80, 0xad, 0xc4,
1680 0x28, 0x93, 0x82, 0xec, 0xd6, 0xd3, 0x94, 0xf0 },
1681 { 0xaf, 0x85, 0x33, 0x6b, 0x59, 0x7a, 0xfc, 0x1a,
1682 0x90, 0x0b, 0x2e, 0xb2, 0x1e, 0xc9, 0x49, 0xd2,
1683 0x92, 0xdf, 0x4c, 0x04, 0x7e, 0x0b, 0x21, 0x53,
1684 0x21, 0x86, 0xa5, 0x97, 0x1a, 0x22, 0x7a, 0x89 },
1685};
1686
1687static const unsigned char aes_test_xts_data_unit[][16] =
1688{
1689 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1690 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1691 { 0x33, 0x33, 0x33, 0x33, 0x33, 0x00, 0x00, 0x00,
1692 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1693 { 0x33, 0x33, 0x33, 0x33, 0x33, 0x00, 0x00, 0x00,
1694 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
1695};
1696
1697#endif /* MBEDTLS_CIPHER_MODE_XTS */
1698
1699/*
1700 * Checkup routine
1701 */
1702int mbedtls_aes_self_test( int verbose )
1703{
1704 int ret = 0, i, j, u, mode;
1705 unsigned int keybits;
1706 unsigned char key[32];
1707 unsigned char buf[64];
1708 const unsigned char *aes_tests;
1709#if defined(MBEDTLS_CIPHER_MODE_CBC) || defined(MBEDTLS_CIPHER_MODE_CFB)
1710 unsigned char iv[16];
1711#endif
1712#if defined(MBEDTLS_CIPHER_MODE_CBC)
1713 unsigned char prv[16];
1714#endif
1715#if defined(MBEDTLS_CIPHER_MODE_CTR) || defined(MBEDTLS_CIPHER_MODE_CFB) || \
1716 defined(MBEDTLS_CIPHER_MODE_OFB)
1717 size_t offset;
1718#endif
1719#if defined(MBEDTLS_CIPHER_MODE_CTR) || defined(MBEDTLS_CIPHER_MODE_XTS)
1720 int len;
1721#endif
1722#if defined(MBEDTLS_CIPHER_MODE_CTR)
1723 unsigned char nonce_counter[16];
1724 unsigned char stream_block[16];
1725#endif
1726 mbedtls_aes_context ctx;
1727
1728 memset( key, 0, 32 );
1729 mbedtls_aes_init( &ctx );
1730
1731 /*
1732 * ECB mode
1733 */
1734 for( i = 0; i < 6; i++ )
1735 {
1736 u = i >> 1;
1737 keybits = 128 + u * 64;
1738 mode = i & 1;
1739
1740 if( verbose != 0 )
1741 mbedtls_printf( " AES-ECB-%3d (%s): ", keybits,
1742 ( mode == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );
1743
1744 memset( buf, 0, 16 );
1745
1746 if( mode == MBEDTLS_AES_DECRYPT )
1747 {
1748 ret = mbedtls_aes_setkey_dec( &ctx, key, keybits );
1749 aes_tests = aes_test_ecb_dec[u];
1750 }
1751 else
1752 {
1753 ret = mbedtls_aes_setkey_enc( &ctx, key, keybits );
1754 aes_tests = aes_test_ecb_enc[u];
1755 }
1756
1757 /*
1758 * AES-192 is an optional feature that may be unavailable when
1759 * there is an alternative underlying implementation i.e. when
1760 * MBEDTLS_AES_ALT is defined.
1761 */
1762 if( ret == MBEDTLS_ERR_AES_FEATURE_UNAVAILABLE && keybits == 192 )
1763 {
1764 mbedtls_printf( "skipped\n" );
1765 continue;
1766 }
1767 else if( ret != 0 )
1768 {
1769 goto exit;
1770 }
1771
1772 for( j = 0; j < 10000; j++ )
1773 {
1774 ret = mbedtls_aes_crypt_ecb( &ctx, mode, buf, buf );
1775 if( ret != 0 )
1776 goto exit;
1777 }
1778
1779 if( memcmp( buf, aes_tests, 16 ) != 0 )
1780 {
1781 ret = 1;
1782 goto exit;
1783 }
1784
1785 if( verbose != 0 )
1786 mbedtls_printf( "passed\n" );
1787 }
1788
1789 if( verbose != 0 )
1790 mbedtls_printf( "\n" );
1791
1792#if defined(MBEDTLS_CIPHER_MODE_CBC)
1793 /*
1794 * CBC mode
1795 */
1796 for( i = 0; i < 6; i++ )
1797 {
1798 u = i >> 1;
1799 keybits = 128 + u * 64;
1800 mode = i & 1;
1801
1802 if( verbose != 0 )
1803 mbedtls_printf( " AES-CBC-%3d (%s): ", keybits,
1804 ( mode == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );
1805
1806 memset( iv , 0, 16 );
1807 memset( prv, 0, 16 );
1808 memset( buf, 0, 16 );
1809
1810 if( mode == MBEDTLS_AES_DECRYPT )
1811 {
1812 ret = mbedtls_aes_setkey_dec( &ctx, key, keybits );
1813 aes_tests = aes_test_cbc_dec[u];
1814 }
1815 else
1816 {
1817 ret = mbedtls_aes_setkey_enc( &ctx, key, keybits );
1818 aes_tests = aes_test_cbc_enc[u];
1819 }
1820
1821 /*
1822 * AES-192 is an optional feature that may be unavailable when
1823 * there is an alternative underlying implementation i.e. when
1824 * MBEDTLS_AES_ALT is defined.
1825 */
1826 if( ret == MBEDTLS_ERR_AES_FEATURE_UNAVAILABLE && keybits == 192 )
1827 {
1828 mbedtls_printf( "skipped\n" );
1829 continue;
1830 }
1831 else if( ret != 0 )
1832 {
1833 goto exit;
1834 }
1835
1836 for( j = 0; j < 10000; j++ )
1837 {
1838 if( mode == MBEDTLS_AES_ENCRYPT )
1839 {
1840 unsigned char tmp[16];
1841
1842 memcpy( tmp, prv, 16 );
1843 memcpy( prv, buf, 16 );
1844 memcpy( buf, tmp, 16 );
1845 }
1846
1847 ret = mbedtls_aes_crypt_cbc( &ctx, mode, 16, iv, buf, buf );
1848 if( ret != 0 )
1849 goto exit;
1850
1851 }
1852
1853 if( memcmp( buf, aes_tests, 16 ) != 0 )
1854 {
1855 ret = 1;
1856 goto exit;
1857 }
1858
1859 if( verbose != 0 )
1860 mbedtls_printf( "passed\n" );
1861 }
1862
1863 if( verbose != 0 )
1864 mbedtls_printf( "\n" );
1865#endif /* MBEDTLS_CIPHER_MODE_CBC */
1866
1867#if defined(MBEDTLS_CIPHER_MODE_CFB)
1868 /*
1869 * CFB128 mode
1870 */
1871 for( i = 0; i < 6; i++ )
1872 {
1873 u = i >> 1;
1874 keybits = 128 + u * 64;
1875 mode = i & 1;
1876
1877 if( verbose != 0 )
1878 mbedtls_printf( " AES-CFB128-%3d (%s): ", keybits,
1879 ( mode == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );
1880
1881 memcpy( iv, aes_test_cfb128_iv, 16 );
1882 memcpy( key, aes_test_cfb128_key[u], keybits / 8 );
1883
1884 offset = 0;
1885 ret = mbedtls_aes_setkey_enc( &ctx, key, keybits );
1886 /*
1887 * AES-192 is an optional feature that may be unavailable when
1888 * there is an alternative underlying implementation i.e. when
1889 * MBEDTLS_AES_ALT is defined.
1890 */
1891 if( ret == MBEDTLS_ERR_AES_FEATURE_UNAVAILABLE && keybits == 192 )
1892 {
1893 mbedtls_printf( "skipped\n" );
1894 continue;
1895 }
1896 else if( ret != 0 )
1897 {
1898 goto exit;
1899 }
1900
1901 if( mode == MBEDTLS_AES_DECRYPT )
1902 {
1903 memcpy( buf, aes_test_cfb128_ct[u], 64 );
1904 aes_tests = aes_test_cfb128_pt;
1905 }
1906 else
1907 {
1908 memcpy( buf, aes_test_cfb128_pt, 64 );
1909 aes_tests = aes_test_cfb128_ct[u];
1910 }
1911
1912 ret = mbedtls_aes_crypt_cfb128( &ctx, mode, 64, &offset, iv, buf, buf );
1913 if( ret != 0 )
1914 goto exit;
1915
1916 if( memcmp( buf, aes_tests, 64 ) != 0 )
1917 {
1918 ret = 1;
1919 goto exit;
1920 }
1921
1922 if( verbose != 0 )
1923 mbedtls_printf( "passed\n" );
1924 }
1925
1926 if( verbose != 0 )
1927 mbedtls_printf( "\n" );
1928#endif /* MBEDTLS_CIPHER_MODE_CFB */
1929
1930#if defined(MBEDTLS_CIPHER_MODE_OFB)
1931 /*
1932 * OFB mode
1933 */
1934 for( i = 0; i < 6; i++ )
1935 {
1936 u = i >> 1;
1937 keybits = 128 + u * 64;
1938 mode = i & 1;
1939
1940 if( verbose != 0 )
1941 mbedtls_printf( " AES-OFB-%3d (%s): ", keybits,
1942 ( mode == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );
1943
1944 memcpy( iv, aes_test_ofb_iv, 16 );
1945 memcpy( key, aes_test_ofb_key[u], keybits / 8 );
1946
1947 offset = 0;
1948 ret = mbedtls_aes_setkey_enc( &ctx, key, keybits );
1949 /*
1950 * AES-192 is an optional feature that may be unavailable when
1951 * there is an alternative underlying implementation i.e. when
1952 * MBEDTLS_AES_ALT is defined.
1953 */
1954 if( ret == MBEDTLS_ERR_AES_FEATURE_UNAVAILABLE && keybits == 192 )
1955 {
1956 mbedtls_printf( "skipped\n" );
1957 continue;
1958 }
1959 else if( ret != 0 )
1960 {
1961 goto exit;
1962 }
1963
1964 if( mode == MBEDTLS_AES_DECRYPT )
1965 {
1966 memcpy( buf, aes_test_ofb_ct[u], 64 );
1967 aes_tests = aes_test_ofb_pt;
1968 }
1969 else
1970 {
1971 memcpy( buf, aes_test_ofb_pt, 64 );
1972 aes_tests = aes_test_ofb_ct[u];
1973 }
1974
1975 ret = mbedtls_aes_crypt_ofb( &ctx, 64, &offset, iv, buf, buf );
1976 if( ret != 0 )
1977 goto exit;
1978
1979 if( memcmp( buf, aes_tests, 64 ) != 0 )
1980 {
1981 ret = 1;
1982 goto exit;
1983 }
1984
1985 if( verbose != 0 )
1986 mbedtls_printf( "passed\n" );
1987 }
1988
1989 if( verbose != 0 )
1990 mbedtls_printf( "\n" );
1991#endif /* MBEDTLS_CIPHER_MODE_OFB */
1992
1993#if defined(MBEDTLS_CIPHER_MODE_CTR)
1994 /*
1995 * CTR mode
1996 */
1997 for( i = 0; i < 6; i++ )
1998 {
1999 u = i >> 1;
2000 mode = i & 1;
2001
2002 if( verbose != 0 )
2003 mbedtls_printf( " AES-CTR-128 (%s): ",
2004 ( mode == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );
2005
2006 memcpy( nonce_counter, aes_test_ctr_nonce_counter[u], 16 );
2007 memcpy( key, aes_test_ctr_key[u], 16 );
2008
2009 offset = 0;
2010 if( ( ret = mbedtls_aes_setkey_enc( &ctx, key, 128 ) ) != 0 )
2011 goto exit;
2012
2013 len = aes_test_ctr_len[u];
2014
2015 if( mode == MBEDTLS_AES_DECRYPT )
2016 {
2017 memcpy( buf, aes_test_ctr_ct[u], len );
2018 aes_tests = aes_test_ctr_pt[u];
2019 }
2020 else
2021 {
2022 memcpy( buf, aes_test_ctr_pt[u], len );
2023 aes_tests = aes_test_ctr_ct[u];
2024 }
2025
2026 ret = mbedtls_aes_crypt_ctr( &ctx, len, &offset, nonce_counter,
2027 stream_block, buf, buf );
2028 if( ret != 0 )
2029 goto exit;
2030
2031 if( memcmp( buf, aes_tests, len ) != 0 )
2032 {
2033 ret = 1;
2034 goto exit;
2035 }
2036
2037 if( verbose != 0 )
2038 mbedtls_printf( "passed\n" );
2039 }
2040
2041 if( verbose != 0 )
2042 mbedtls_printf( "\n" );
2043#endif /* MBEDTLS_CIPHER_MODE_CTR */
2044
2045#if defined(MBEDTLS_CIPHER_MODE_XTS)
2046 {
2047 static const int num_tests =
2048 sizeof(aes_test_xts_key) / sizeof(*aes_test_xts_key);
2049 mbedtls_aes_xts_context ctx_xts;
2050
2051 /*
2052 * XTS mode
2053 */
2054 mbedtls_aes_xts_init( &ctx_xts );
2055
2056 for( i = 0; i < num_tests << 1; i++ )
2057 {
2058 const unsigned char *data_unit;
2059 u = i >> 1;
2060 mode = i & 1;
2061
2062 if( verbose != 0 )
2063 mbedtls_printf( " AES-XTS-128 (%s): ",
2064 ( mode == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );
2065
2066 memset( key, 0, sizeof( key ) );
2067 memcpy( key, aes_test_xts_key[u], 32 );
2068 data_unit = aes_test_xts_data_unit[u];
2069
2070 len = sizeof( *aes_test_xts_ct32 );
2071
2072 if( mode == MBEDTLS_AES_DECRYPT )
2073 {
2074 ret = mbedtls_aes_xts_setkey_dec( &ctx_xts, key, 256 );
2075 if( ret != 0)
2076 goto exit;
2077 memcpy( buf, aes_test_xts_ct32[u], len );
2078 aes_tests = aes_test_xts_pt32[u];
2079 }
2080 else
2081 {
2082 ret = mbedtls_aes_xts_setkey_enc( &ctx_xts, key, 256 );
2083 if( ret != 0)
2084 goto exit;
2085 memcpy( buf, aes_test_xts_pt32[u], len );
2086 aes_tests = aes_test_xts_ct32[u];
2087 }
2088
2089
2090 ret = mbedtls_aes_crypt_xts( &ctx_xts, mode, len, data_unit,
2091 buf, buf );
2092 if( ret != 0 )
2093 goto exit;
2094
2095 if( memcmp( buf, aes_tests, len ) != 0 )
2096 {
2097 ret = 1;
2098 goto exit;
2099 }
2100
2101 if( verbose != 0 )
2102 mbedtls_printf( "passed\n" );
2103 }
2104
2105 if( verbose != 0 )
2106 mbedtls_printf( "\n" );
2107
2108 mbedtls_aes_xts_free( &ctx_xts );
2109 }
2110#endif /* MBEDTLS_CIPHER_MODE_XTS */
2111
2112 ret = 0;
2113
2114exit:
2115 if( ret != 0 && verbose != 0 )
2116 mbedtls_printf( "failed\n" );
2117
2118 mbedtls_aes_free( &ctx );
2119
2120 return( ret );
2121}
2122
2123#endif /* MBEDTLS_SELF_TEST */
2124
2125#endif /* MBEDTLS_AES_C */
diff --git a/source/mbedtls/lib/cipher.c b/source/mbedtls/lib/cipher.c
deleted file mode 100644
index de9402a..0000000
--- a/source/mbedtls/lib/cipher.c
+++ /dev/null
@@ -1,1108 +0,0 @@
1/**
2 * \file cipher.c
3 *
4 * \brief Generic cipher wrapper for mbed TLS
5 *
6 * \author Adriaan de Jong <dejong@fox-it.com>
7 *
8 * Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
9 * SPDX-License-Identifier: GPL-2.0
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License along
22 * with this program; if not, write to the Free Software Foundation, Inc.,
23 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
24 *
25 * This file is part of mbed TLS (https://tls.mbed.org)
26 */
27
28#if !defined(MBEDTLS_CONFIG_FILE)
29#include "mbedtls/config.h"
30#else
31#include MBEDTLS_CONFIG_FILE
32#endif
33
34#if defined(MBEDTLS_CIPHER_C)
35
36#include "mbedtls/cipher.h"
37#include "mbedtls/cipher_internal.h"
38#include "mbedtls/platform_util.h"
39
40#include <stdlib.h>
41#include <string.h>
42
43#if defined(MBEDTLS_CHACHAPOLY_C)
44#include "mbedtls/chachapoly.h"
45#endif
46
47#if defined(MBEDTLS_GCM_C)
48#include "mbedtls/gcm.h"
49#endif
50
51#if defined(MBEDTLS_CCM_C)
52#include "mbedtls/ccm.h"
53#endif
54
55#if defined(MBEDTLS_CHACHA20_C)
56#include "mbedtls/chacha20.h"
57#endif
58
59#if defined(MBEDTLS_CMAC_C)
60#include "mbedtls/cmac.h"
61#endif
62
63#if defined(MBEDTLS_PLATFORM_C)
64#include "mbedtls/platform.h"
65#else
66#define mbedtls_calloc calloc
67#define mbedtls_free free
68#endif
69
70#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
71/* Compare the contents of two buffers in constant time.
72 * Returns 0 if the contents are bitwise identical, otherwise returns
73 * a non-zero value.
74 * This is currently only used by GCM and ChaCha20+Poly1305.
75 */
76static int mbedtls_constant_time_memcmp( const void *v1, const void *v2, size_t len )
77{
78 const unsigned char *p1 = (const unsigned char*) v1;
79 const unsigned char *p2 = (const unsigned char*) v2;
80 size_t i;
81 unsigned char diff;
82
83 for( diff = 0, i = 0; i < len; i++ )
84 diff |= p1[i] ^ p2[i];
85
86 return (int)diff;
87}
88#endif /* MBEDTLS_GCM_C || MBEDTLS_CHACHAPOLY_C */
89
90static int supported_init = 0;
91
92const int *mbedtls_cipher_list( void )
93{
94 const mbedtls_cipher_definition_t *def;
95 int *type;
96
97 if( ! supported_init )
98 {
99 def = mbedtls_cipher_definitions;
100 type = mbedtls_cipher_supported;
101
102 while( def->type != 0 )
103 *type++ = (*def++).type;
104
105 *type = 0;
106
107 supported_init = 1;
108 }
109
110 return( mbedtls_cipher_supported );
111}
112
113const mbedtls_cipher_info_t *mbedtls_cipher_info_from_type( const mbedtls_cipher_type_t cipher_type )
114{
115 const mbedtls_cipher_definition_t *def;
116
117 for( def = mbedtls_cipher_definitions; def->info != NULL; def++ )
118 if( def->type == cipher_type )
119 return( def->info );
120
121 return( NULL );
122}
123
124const mbedtls_cipher_info_t *mbedtls_cipher_info_from_string( const char *cipher_name )
125{
126 const mbedtls_cipher_definition_t *def;
127
128 if( NULL == cipher_name )
129 return( NULL );
130
131 for( def = mbedtls_cipher_definitions; def->info != NULL; def++ )
132 if( ! strcmp( def->info->name, cipher_name ) )
133 return( def->info );
134
135 return( NULL );
136}
137
138const mbedtls_cipher_info_t *mbedtls_cipher_info_from_values( const mbedtls_cipher_id_t cipher_id,
139 int key_bitlen,
140 const mbedtls_cipher_mode_t mode )
141{
142 const mbedtls_cipher_definition_t *def;
143
144 for( def = mbedtls_cipher_definitions; def->info != NULL; def++ )
145 if( def->info->base->cipher == cipher_id &&
146 def->info->key_bitlen == (unsigned) key_bitlen &&
147 def->info->mode == mode )
148 return( def->info );
149
150 return( NULL );
151}
152
153void mbedtls_cipher_init( mbedtls_cipher_context_t *ctx )
154{
155 memset( ctx, 0, sizeof( mbedtls_cipher_context_t ) );
156}
157
158void mbedtls_cipher_free( mbedtls_cipher_context_t *ctx )
159{
160 if( ctx == NULL )
161 return;
162
163#if defined(MBEDTLS_CMAC_C)
164 if( ctx->cmac_ctx )
165 {
166 mbedtls_platform_zeroize( ctx->cmac_ctx,
167 sizeof( mbedtls_cmac_context_t ) );
168 mbedtls_free( ctx->cmac_ctx );
169 }
170#endif
171
172 if( ctx->cipher_ctx )
173 ctx->cipher_info->base->ctx_free_func( ctx->cipher_ctx );
174
175 mbedtls_platform_zeroize( ctx, sizeof(mbedtls_cipher_context_t) );
176}
177
178int mbedtls_cipher_setup( mbedtls_cipher_context_t *ctx, const mbedtls_cipher_info_t *cipher_info )
179{
180 if( NULL == cipher_info || NULL == ctx )
181 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
182
183 memset( ctx, 0, sizeof( mbedtls_cipher_context_t ) );
184
185 if( NULL == ( ctx->cipher_ctx = cipher_info->base->ctx_alloc_func() ) )
186 return( MBEDTLS_ERR_CIPHER_ALLOC_FAILED );
187
188 ctx->cipher_info = cipher_info;
189
190#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
191 /*
192 * Ignore possible errors caused by a cipher mode that doesn't use padding
193 */
194#if defined(MBEDTLS_CIPHER_PADDING_PKCS7)
195 (void) mbedtls_cipher_set_padding_mode( ctx, MBEDTLS_PADDING_PKCS7 );
196#else
197 (void) mbedtls_cipher_set_padding_mode( ctx, MBEDTLS_PADDING_NONE );
198#endif
199#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
200
201 return( 0 );
202}
203
204int mbedtls_cipher_setkey( mbedtls_cipher_context_t *ctx, const unsigned char *key,
205 int key_bitlen, const mbedtls_operation_t operation )
206{
207 if( NULL == ctx || NULL == ctx->cipher_info )
208 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
209
210 if( ( ctx->cipher_info->flags & MBEDTLS_CIPHER_VARIABLE_KEY_LEN ) == 0 &&
211 (int) ctx->cipher_info->key_bitlen != key_bitlen )
212 {
213 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
214 }
215
216 ctx->key_bitlen = key_bitlen;
217 ctx->operation = operation;
218
219 /*
220 * For OFB, CFB and CTR mode always use the encryption key schedule
221 */
222 if( MBEDTLS_ENCRYPT == operation ||
223 MBEDTLS_MODE_CFB == ctx->cipher_info->mode ||
224 MBEDTLS_MODE_OFB == ctx->cipher_info->mode ||
225 MBEDTLS_MODE_CTR == ctx->cipher_info->mode )
226 {
227 return ctx->cipher_info->base->setkey_enc_func( ctx->cipher_ctx, key,
228 ctx->key_bitlen );
229 }
230
231 if( MBEDTLS_DECRYPT == operation )
232 return ctx->cipher_info->base->setkey_dec_func( ctx->cipher_ctx, key,
233 ctx->key_bitlen );
234
235 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
236}
237
238int mbedtls_cipher_set_iv( mbedtls_cipher_context_t *ctx,
239 const unsigned char *iv, size_t iv_len )
240{
241 size_t actual_iv_size;
242
243 if( NULL == ctx || NULL == ctx->cipher_info || NULL == iv )
244 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
245
246 /* avoid buffer overflow in ctx->iv */
247 if( iv_len > MBEDTLS_MAX_IV_LENGTH )
248 return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
249
250 if( ( ctx->cipher_info->flags & MBEDTLS_CIPHER_VARIABLE_IV_LEN ) != 0 )
251 actual_iv_size = iv_len;
252 else
253 {
254 actual_iv_size = ctx->cipher_info->iv_size;
255
256 /* avoid reading past the end of input buffer */
257 if( actual_iv_size > iv_len )
258 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
259 }
260
261#if defined(MBEDTLS_CHACHA20_C)
262 if ( ctx->cipher_info->type == MBEDTLS_CIPHER_CHACHA20 )
263 {
264 if ( 0 != mbedtls_chacha20_starts( (mbedtls_chacha20_context*)ctx->cipher_ctx,
265 iv,
266 0U ) ) /* Initial counter value */
267 {
268 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
269 }
270 }
271#endif
272
273 memcpy( ctx->iv, iv, actual_iv_size );
274 ctx->iv_size = actual_iv_size;
275
276 return( 0 );
277}
278
279int mbedtls_cipher_reset( mbedtls_cipher_context_t *ctx )
280{
281 if( NULL == ctx || NULL == ctx->cipher_info )
282 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
283
284 ctx->unprocessed_len = 0;
285
286 return( 0 );
287}
288
289#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
290int mbedtls_cipher_update_ad( mbedtls_cipher_context_t *ctx,
291 const unsigned char *ad, size_t ad_len )
292{
293 if( NULL == ctx || NULL == ctx->cipher_info )
294 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
295
296#if defined(MBEDTLS_GCM_C)
297 if( MBEDTLS_MODE_GCM == ctx->cipher_info->mode )
298 {
299 return mbedtls_gcm_starts( (mbedtls_gcm_context *) ctx->cipher_ctx, ctx->operation,
300 ctx->iv, ctx->iv_size, ad, ad_len );
301 }
302#endif
303
304#if defined(MBEDTLS_CHACHAPOLY_C)
305 if (MBEDTLS_CIPHER_CHACHA20_POLY1305 == ctx->cipher_info->type )
306 {
307 int result;
308 mbedtls_chachapoly_mode_t mode;
309
310 mode = ( ctx->operation == MBEDTLS_ENCRYPT )
311 ? MBEDTLS_CHACHAPOLY_ENCRYPT
312 : MBEDTLS_CHACHAPOLY_DECRYPT;
313
314 result = mbedtls_chachapoly_starts( (mbedtls_chachapoly_context*) ctx->cipher_ctx,
315 ctx->iv,
316 mode );
317 if ( result != 0 )
318 return( result );
319
320 return mbedtls_chachapoly_update_aad( (mbedtls_chachapoly_context*) ctx->cipher_ctx,
321 ad, ad_len );
322 }
323#endif
324
325 return( 0 );
326}
327#endif /* MBEDTLS_GCM_C || MBEDTLS_CHACHAPOLY_C */
328
329int mbedtls_cipher_update( mbedtls_cipher_context_t *ctx, const unsigned char *input,
330 size_t ilen, unsigned char *output, size_t *olen )
331{
332 int ret;
333 size_t block_size = 0;
334
335 if( NULL == ctx || NULL == ctx->cipher_info || NULL == olen )
336 {
337 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
338 }
339
340 *olen = 0;
341 block_size = mbedtls_cipher_get_block_size( ctx );
342
343 if( ctx->cipher_info->mode == MBEDTLS_MODE_ECB )
344 {
345 if( ilen != block_size )
346 return( MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED );
347
348 *olen = ilen;
349
350 if( 0 != ( ret = ctx->cipher_info->base->ecb_func( ctx->cipher_ctx,
351 ctx->operation, input, output ) ) )
352 {
353 return( ret );
354 }
355
356 return( 0 );
357 }
358
359#if defined(MBEDTLS_GCM_C)
360 if( ctx->cipher_info->mode == MBEDTLS_MODE_GCM )
361 {
362 *olen = ilen;
363 return mbedtls_gcm_update( (mbedtls_gcm_context *) ctx->cipher_ctx, ilen, input,
364 output );
365 }
366#endif
367
368#if defined(MBEDTLS_CHACHAPOLY_C)
369 if ( ctx->cipher_info->type == MBEDTLS_CIPHER_CHACHA20_POLY1305 )
370 {
371 *olen = ilen;
372 return mbedtls_chachapoly_update( (mbedtls_chachapoly_context*) ctx->cipher_ctx,
373 ilen, input, output );
374 }
375#endif
376
377 if ( 0 == block_size )
378 {
379 return MBEDTLS_ERR_CIPHER_INVALID_CONTEXT;
380 }
381
382 if( input == output &&
383 ( ctx->unprocessed_len != 0 || ilen % block_size ) )
384 {
385 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
386 }
387
388#if defined(MBEDTLS_CIPHER_MODE_CBC)
389 if( ctx->cipher_info->mode == MBEDTLS_MODE_CBC )
390 {
391 size_t copy_len = 0;
392
393 /*
394 * If there is not enough data for a full block, cache it.
395 */
396 if( ( ctx->operation == MBEDTLS_DECRYPT && NULL != ctx->add_padding &&
397 ilen <= block_size - ctx->unprocessed_len ) ||
398 ( ctx->operation == MBEDTLS_DECRYPT && NULL == ctx->add_padding &&
399 ilen < block_size - ctx->unprocessed_len ) ||
400 ( ctx->operation == MBEDTLS_ENCRYPT &&
401 ilen < block_size - ctx->unprocessed_len ) )
402 {
403 memcpy( &( ctx->unprocessed_data[ctx->unprocessed_len] ), input,
404 ilen );
405
406 ctx->unprocessed_len += ilen;
407 return( 0 );
408 }
409
410 /*
411 * Process cached data first
412 */
413 if( 0 != ctx->unprocessed_len )
414 {
415 copy_len = block_size - ctx->unprocessed_len;
416
417 memcpy( &( ctx->unprocessed_data[ctx->unprocessed_len] ), input,
418 copy_len );
419
420 if( 0 != ( ret = ctx->cipher_info->base->cbc_func( ctx->cipher_ctx,
421 ctx->operation, block_size, ctx->iv,
422 ctx->unprocessed_data, output ) ) )
423 {
424 return( ret );
425 }
426
427 *olen += block_size;
428 output += block_size;
429 ctx->unprocessed_len = 0;
430
431 input += copy_len;
432 ilen -= copy_len;
433 }
434
435 /*
436 * Cache final, incomplete block
437 */
438 if( 0 != ilen )
439 {
440 if( 0 == block_size )
441 {
442 return MBEDTLS_ERR_CIPHER_INVALID_CONTEXT;
443 }
444
445 /* Encryption: only cache partial blocks
446 * Decryption w/ padding: always keep at least one whole block
447 * Decryption w/o padding: only cache partial blocks
448 */
449 copy_len = ilen % block_size;
450 if( copy_len == 0 &&
451 ctx->operation == MBEDTLS_DECRYPT &&
452 NULL != ctx->add_padding)
453 {
454 copy_len = block_size;
455 }
456
457 memcpy( ctx->unprocessed_data, &( input[ilen - copy_len] ),
458 copy_len );
459
460 ctx->unprocessed_len += copy_len;
461 ilen -= copy_len;
462 }
463
464 /*
465 * Process remaining full blocks
466 */
467 if( ilen )
468 {
469 if( 0 != ( ret = ctx->cipher_info->base->cbc_func( ctx->cipher_ctx,
470 ctx->operation, ilen, ctx->iv, input, output ) ) )
471 {
472 return( ret );
473 }
474
475 *olen += ilen;
476 }
477
478 return( 0 );
479 }
480#endif /* MBEDTLS_CIPHER_MODE_CBC */
481
482#if defined(MBEDTLS_CIPHER_MODE_CFB)
483 if( ctx->cipher_info->mode == MBEDTLS_MODE_CFB )
484 {
485 if( 0 != ( ret = ctx->cipher_info->base->cfb_func( ctx->cipher_ctx,
486 ctx->operation, ilen, &ctx->unprocessed_len, ctx->iv,
487 input, output ) ) )
488 {
489 return( ret );
490 }
491
492 *olen = ilen;
493
494 return( 0 );
495 }
496#endif /* MBEDTLS_CIPHER_MODE_CFB */
497
498#if defined(MBEDTLS_CIPHER_MODE_OFB)
499 if( ctx->cipher_info->mode == MBEDTLS_MODE_OFB )
500 {
501 if( 0 != ( ret = ctx->cipher_info->base->ofb_func( ctx->cipher_ctx,
502 ilen, &ctx->unprocessed_len, ctx->iv, input, output ) ) )
503 {
504 return( ret );
505 }
506
507 *olen = ilen;
508
509 return( 0 );
510 }
511#endif /* MBEDTLS_CIPHER_MODE_OFB */
512
513#if defined(MBEDTLS_CIPHER_MODE_CTR)
514 if( ctx->cipher_info->mode == MBEDTLS_MODE_CTR )
515 {
516 if( 0 != ( ret = ctx->cipher_info->base->ctr_func( ctx->cipher_ctx,
517 ilen, &ctx->unprocessed_len, ctx->iv,
518 ctx->unprocessed_data, input, output ) ) )
519 {
520 return( ret );
521 }
522
523 *olen = ilen;
524
525 return( 0 );
526 }
527#endif /* MBEDTLS_CIPHER_MODE_CTR */
528
529#if defined(MBEDTLS_CIPHER_MODE_XTS)
530 if( ctx->cipher_info->mode == MBEDTLS_MODE_XTS )
531 {
532 if( ctx->unprocessed_len > 0 ) {
533 /* We can only process an entire data unit at a time. */
534 return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
535 }
536
537 ret = ctx->cipher_info->base->xts_func( ctx->cipher_ctx,
538 ctx->operation, ilen, ctx->iv, input, output );
539 if( ret != 0 )
540 {
541 return( ret );
542 }
543
544 *olen = ilen;
545
546 return( 0 );
547 }
548#endif /* MBEDTLS_CIPHER_MODE_XTS */
549
550#if defined(MBEDTLS_CIPHER_MODE_STREAM)
551 if( ctx->cipher_info->mode == MBEDTLS_MODE_STREAM )
552 {
553 if( 0 != ( ret = ctx->cipher_info->base->stream_func( ctx->cipher_ctx,
554 ilen, input, output ) ) )
555 {
556 return( ret );
557 }
558
559 *olen = ilen;
560
561 return( 0 );
562 }
563#endif /* MBEDTLS_CIPHER_MODE_STREAM */
564
565 return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
566}
567
568#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
569#if defined(MBEDTLS_CIPHER_PADDING_PKCS7)
570/*
571 * PKCS7 (and PKCS5) padding: fill with ll bytes, with ll = padding_len
572 */
573static void add_pkcs_padding( unsigned char *output, size_t output_len,
574 size_t data_len )
575{
576 size_t padding_len = output_len - data_len;
577 unsigned char i;
578
579 for( i = 0; i < padding_len; i++ )
580 output[data_len + i] = (unsigned char) padding_len;
581}
582
583static int get_pkcs_padding( unsigned char *input, size_t input_len,
584 size_t *data_len )
585{
586 size_t i, pad_idx;
587 unsigned char padding_len, bad = 0;
588
589 if( NULL == input || NULL == data_len )
590 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
591
592 padding_len = input[input_len - 1];
593 *data_len = input_len - padding_len;
594
595 /* Avoid logical || since it results in a branch */
596 bad |= padding_len > input_len;
597 bad |= padding_len == 0;
598
599 /* The number of bytes checked must be independent of padding_len,
600 * so pick input_len, which is usually 8 or 16 (one block) */
601 pad_idx = input_len - padding_len;
602 for( i = 0; i < input_len; i++ )
603 bad |= ( input[i] ^ padding_len ) * ( i >= pad_idx );
604
605 return( MBEDTLS_ERR_CIPHER_INVALID_PADDING * ( bad != 0 ) );
606}
607#endif /* MBEDTLS_CIPHER_PADDING_PKCS7 */
608
609#if defined(MBEDTLS_CIPHER_PADDING_ONE_AND_ZEROS)
610/*
611 * One and zeros padding: fill with 80 00 ... 00
612 */
613static void add_one_and_zeros_padding( unsigned char *output,
614 size_t output_len, size_t data_len )
615{
616 size_t padding_len = output_len - data_len;
617 unsigned char i = 0;
618
619 output[data_len] = 0x80;
620 for( i = 1; i < padding_len; i++ )
621 output[data_len + i] = 0x00;
622}
623
624static int get_one_and_zeros_padding( unsigned char *input, size_t input_len,
625 size_t *data_len )
626{
627 size_t i;
628 unsigned char done = 0, prev_done, bad;
629
630 if( NULL == input || NULL == data_len )
631 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
632
633 bad = 0x80;
634 *data_len = 0;
635 for( i = input_len; i > 0; i-- )
636 {
637 prev_done = done;
638 done |= ( input[i - 1] != 0 );
639 *data_len |= ( i - 1 ) * ( done != prev_done );
640 bad ^= input[i - 1] * ( done != prev_done );
641 }
642
643 return( MBEDTLS_ERR_CIPHER_INVALID_PADDING * ( bad != 0 ) );
644
645}
646#endif /* MBEDTLS_CIPHER_PADDING_ONE_AND_ZEROS */
647
648#if defined(MBEDTLS_CIPHER_PADDING_ZEROS_AND_LEN)
649/*
650 * Zeros and len padding: fill with 00 ... 00 ll, where ll is padding length
651 */
652static void add_zeros_and_len_padding( unsigned char *output,
653 size_t output_len, size_t data_len )
654{
655 size_t padding_len = output_len - data_len;
656 unsigned char i = 0;
657
658 for( i = 1; i < padding_len; i++ )
659 output[data_len + i - 1] = 0x00;
660 output[output_len - 1] = (unsigned char) padding_len;
661}
662
663static int get_zeros_and_len_padding( unsigned char *input, size_t input_len,
664 size_t *data_len )
665{
666 size_t i, pad_idx;
667 unsigned char padding_len, bad = 0;
668
669 if( NULL == input || NULL == data_len )
670 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
671
672 padding_len = input[input_len - 1];
673 *data_len = input_len - padding_len;
674
675 /* Avoid logical || since it results in a branch */
676 bad |= padding_len > input_len;
677 bad |= padding_len == 0;
678
679 /* The number of bytes checked must be independent of padding_len */
680 pad_idx = input_len - padding_len;
681 for( i = 0; i < input_len - 1; i++ )
682 bad |= input[i] * ( i >= pad_idx );
683
684 return( MBEDTLS_ERR_CIPHER_INVALID_PADDING * ( bad != 0 ) );
685}
686#endif /* MBEDTLS_CIPHER_PADDING_ZEROS_AND_LEN */
687
688#if defined(MBEDTLS_CIPHER_PADDING_ZEROS)
689/*
690 * Zero padding: fill with 00 ... 00
691 */
692static void add_zeros_padding( unsigned char *output,
693 size_t output_len, size_t data_len )
694{
695 size_t i;
696
697 for( i = data_len; i < output_len; i++ )
698 output[i] = 0x00;
699}
700
701static int get_zeros_padding( unsigned char *input, size_t input_len,
702 size_t *data_len )
703{
704 size_t i;
705 unsigned char done = 0, prev_done;
706
707 if( NULL == input || NULL == data_len )
708 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
709
710 *data_len = 0;
711 for( i = input_len; i > 0; i-- )
712 {
713 prev_done = done;
714 done |= ( input[i-1] != 0 );
715 *data_len |= i * ( done != prev_done );
716 }
717
718 return( 0 );
719}
720#endif /* MBEDTLS_CIPHER_PADDING_ZEROS */
721
722/*
723 * No padding: don't pad :)
724 *
725 * There is no add_padding function (check for NULL in mbedtls_cipher_finish)
726 * but a trivial get_padding function
727 */
728static int get_no_padding( unsigned char *input, size_t input_len,
729 size_t *data_len )
730{
731 if( NULL == input || NULL == data_len )
732 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
733
734 *data_len = input_len;
735
736 return( 0 );
737}
738#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
739
740int mbedtls_cipher_finish( mbedtls_cipher_context_t *ctx,
741 unsigned char *output, size_t *olen )
742{
743 if( NULL == ctx || NULL == ctx->cipher_info || NULL == olen )
744 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
745
746 *olen = 0;
747
748 if( MBEDTLS_MODE_CFB == ctx->cipher_info->mode ||
749 MBEDTLS_MODE_OFB == ctx->cipher_info->mode ||
750 MBEDTLS_MODE_CTR == ctx->cipher_info->mode ||
751 MBEDTLS_MODE_GCM == ctx->cipher_info->mode ||
752 MBEDTLS_MODE_XTS == ctx->cipher_info->mode ||
753 MBEDTLS_MODE_STREAM == ctx->cipher_info->mode )
754 {
755 return( 0 );
756 }
757
758 if ( ( MBEDTLS_CIPHER_CHACHA20 == ctx->cipher_info->type ) ||
759 ( MBEDTLS_CIPHER_CHACHA20_POLY1305 == ctx->cipher_info->type ) )
760 {
761 return( 0 );
762 }
763
764 if( MBEDTLS_MODE_ECB == ctx->cipher_info->mode )
765 {
766 if( ctx->unprocessed_len != 0 )
767 return( MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED );
768
769 return( 0 );
770 }
771
772#if defined(MBEDTLS_CIPHER_MODE_CBC)
773 if( MBEDTLS_MODE_CBC == ctx->cipher_info->mode )
774 {
775 int ret = 0;
776
777 if( MBEDTLS_ENCRYPT == ctx->operation )
778 {
779 /* check for 'no padding' mode */
780 if( NULL == ctx->add_padding )
781 {
782 if( 0 != ctx->unprocessed_len )
783 return( MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED );
784
785 return( 0 );
786 }
787
788 ctx->add_padding( ctx->unprocessed_data, mbedtls_cipher_get_iv_size( ctx ),
789 ctx->unprocessed_len );
790 }
791 else if( mbedtls_cipher_get_block_size( ctx ) != ctx->unprocessed_len )
792 {
793 /*
794 * For decrypt operations, expect a full block,
795 * or an empty block if no padding
796 */
797 if( NULL == ctx->add_padding && 0 == ctx->unprocessed_len )
798 return( 0 );
799
800 return( MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED );
801 }
802
803 /* cipher block */
804 if( 0 != ( ret = ctx->cipher_info->base->cbc_func( ctx->cipher_ctx,
805 ctx->operation, mbedtls_cipher_get_block_size( ctx ), ctx->iv,
806 ctx->unprocessed_data, output ) ) )
807 {
808 return( ret );
809 }
810
811 /* Set output size for decryption */
812 if( MBEDTLS_DECRYPT == ctx->operation )
813 return ctx->get_padding( output, mbedtls_cipher_get_block_size( ctx ),
814 olen );
815
816 /* Set output size for encryption */
817 *olen = mbedtls_cipher_get_block_size( ctx );
818 return( 0 );
819 }
820#else
821 ((void) output);
822#endif /* MBEDTLS_CIPHER_MODE_CBC */
823
824 return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
825}
826
827#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
828int mbedtls_cipher_set_padding_mode( mbedtls_cipher_context_t *ctx, mbedtls_cipher_padding_t mode )
829{
830 if( NULL == ctx ||
831 MBEDTLS_MODE_CBC != ctx->cipher_info->mode )
832 {
833 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
834 }
835
836 switch( mode )
837 {
838#if defined(MBEDTLS_CIPHER_PADDING_PKCS7)
839 case MBEDTLS_PADDING_PKCS7:
840 ctx->add_padding = add_pkcs_padding;
841 ctx->get_padding = get_pkcs_padding;
842 break;
843#endif
844#if defined(MBEDTLS_CIPHER_PADDING_ONE_AND_ZEROS)
845 case MBEDTLS_PADDING_ONE_AND_ZEROS:
846 ctx->add_padding = add_one_and_zeros_padding;
847 ctx->get_padding = get_one_and_zeros_padding;
848 break;
849#endif
850#if defined(MBEDTLS_CIPHER_PADDING_ZEROS_AND_LEN)
851 case MBEDTLS_PADDING_ZEROS_AND_LEN:
852 ctx->add_padding = add_zeros_and_len_padding;
853 ctx->get_padding = get_zeros_and_len_padding;
854 break;
855#endif
856#if defined(MBEDTLS_CIPHER_PADDING_ZEROS)
857 case MBEDTLS_PADDING_ZEROS:
858 ctx->add_padding = add_zeros_padding;
859 ctx->get_padding = get_zeros_padding;
860 break;
861#endif
862 case MBEDTLS_PADDING_NONE:
863 ctx->add_padding = NULL;
864 ctx->get_padding = get_no_padding;
865 break;
866
867 default:
868 return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
869 }
870
871 return( 0 );
872}
873#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
874
875#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
876int mbedtls_cipher_write_tag( mbedtls_cipher_context_t *ctx,
877 unsigned char *tag, size_t tag_len )
878{
879 if( NULL == ctx || NULL == ctx->cipher_info || NULL == tag )
880 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
881
882 if( MBEDTLS_ENCRYPT != ctx->operation )
883 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
884
885#if defined(MBEDTLS_GCM_C)
886 if( MBEDTLS_MODE_GCM == ctx->cipher_info->mode )
887 return mbedtls_gcm_finish( (mbedtls_gcm_context *) ctx->cipher_ctx, tag, tag_len );
888#endif
889
890#if defined(MBEDTLS_CHACHAPOLY_C)
891 if ( MBEDTLS_CIPHER_CHACHA20_POLY1305 == ctx->cipher_info->type )
892 {
893 /* Don't allow truncated MAC for Poly1305 */
894 if ( tag_len != 16U )
895 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
896
897 return mbedtls_chachapoly_finish( (mbedtls_chachapoly_context*) ctx->cipher_ctx,
898 tag );
899 }
900#endif
901
902 return( 0 );
903}
904
905int mbedtls_cipher_check_tag( mbedtls_cipher_context_t *ctx,
906 const unsigned char *tag, size_t tag_len )
907{
908 unsigned char check_tag[16];
909 int ret;
910
911 if( NULL == ctx || NULL == ctx->cipher_info ||
912 MBEDTLS_DECRYPT != ctx->operation )
913 {
914 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
915 }
916
917#if defined(MBEDTLS_GCM_C)
918 if( MBEDTLS_MODE_GCM == ctx->cipher_info->mode )
919 {
920 if( tag_len > sizeof( check_tag ) )
921 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
922
923 if( 0 != ( ret = mbedtls_gcm_finish( (mbedtls_gcm_context *) ctx->cipher_ctx,
924 check_tag, tag_len ) ) )
925 {
926 return( ret );
927 }
928
929 /* Check the tag in "constant-time" */
930 if( mbedtls_constant_time_memcmp( tag, check_tag, tag_len ) != 0 )
931 return( MBEDTLS_ERR_CIPHER_AUTH_FAILED );
932
933 return( 0 );
934 }
935#endif /* MBEDTLS_GCM_C */
936
937#if defined(MBEDTLS_CHACHAPOLY_C)
938 if ( MBEDTLS_CIPHER_CHACHA20_POLY1305 == ctx->cipher_info->type )
939 {
940 /* Don't allow truncated MAC for Poly1305 */
941 if ( tag_len != sizeof( check_tag ) )
942 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
943
944 ret = mbedtls_chachapoly_finish( (mbedtls_chachapoly_context*) ctx->cipher_ctx,
945 check_tag );
946 if ( ret != 0 )
947 {
948 return( ret );
949 }
950
951 /* Check the tag in "constant-time" */
952 if( mbedtls_constant_time_memcmp( tag, check_tag, tag_len ) != 0 )
953 return( MBEDTLS_ERR_CIPHER_AUTH_FAILED );
954
955 return( 0 );
956 }
957#endif /* MBEDTLS_CHACHAPOLY_C */
958
959 return( 0 );
960}
961#endif /* MBEDTLS_GCM_C || MBEDTLS_CHACHAPOLY_C */
962
963/*
964 * Packet-oriented wrapper for non-AEAD modes
965 */
966int mbedtls_cipher_crypt( mbedtls_cipher_context_t *ctx,
967 const unsigned char *iv, size_t iv_len,
968 const unsigned char *input, size_t ilen,
969 unsigned char *output, size_t *olen )
970{
971 int ret;
972 size_t finish_olen;
973
974 if( ( ret = mbedtls_cipher_set_iv( ctx, iv, iv_len ) ) != 0 )
975 return( ret );
976
977 if( ( ret = mbedtls_cipher_reset( ctx ) ) != 0 )
978 return( ret );
979
980 if( ( ret = mbedtls_cipher_update( ctx, input, ilen, output, olen ) ) != 0 )
981 return( ret );
982
983 if( ( ret = mbedtls_cipher_finish( ctx, output + *olen, &finish_olen ) ) != 0 )
984 return( ret );
985
986 *olen += finish_olen;
987
988 return( 0 );
989}
990
991#if defined(MBEDTLS_CIPHER_MODE_AEAD)
992/*
993 * Packet-oriented encryption for AEAD modes
994 */
995int mbedtls_cipher_auth_encrypt( mbedtls_cipher_context_t *ctx,
996 const unsigned char *iv, size_t iv_len,
997 const unsigned char *ad, size_t ad_len,
998 const unsigned char *input, size_t ilen,
999 unsigned char *output, size_t *olen,
1000 unsigned char *tag, size_t tag_len )
1001{
1002#if defined(MBEDTLS_GCM_C)
1003 if( MBEDTLS_MODE_GCM == ctx->cipher_info->mode )
1004 {
1005 *olen = ilen;
1006 return( mbedtls_gcm_crypt_and_tag( ctx->cipher_ctx, MBEDTLS_GCM_ENCRYPT, ilen,
1007 iv, iv_len, ad, ad_len, input, output,
1008 tag_len, tag ) );
1009 }
1010#endif /* MBEDTLS_GCM_C */
1011#if defined(MBEDTLS_CCM_C)
1012 if( MBEDTLS_MODE_CCM == ctx->cipher_info->mode )
1013 {
1014 *olen = ilen;
1015 return( mbedtls_ccm_encrypt_and_tag( ctx->cipher_ctx, ilen,
1016 iv, iv_len, ad, ad_len, input, output,
1017 tag, tag_len ) );
1018 }
1019#endif /* MBEDTLS_CCM_C */
1020#if defined(MBEDTLS_CHACHAPOLY_C)
1021 if ( MBEDTLS_CIPHER_CHACHA20_POLY1305 == ctx->cipher_info->type )
1022 {
1023 /* ChachaPoly has fixed length nonce and MAC (tag) */
1024 if ( ( iv_len != ctx->cipher_info->iv_size ) ||
1025 ( tag_len != 16U ) )
1026 {
1027 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
1028 }
1029
1030 *olen = ilen;
1031 return( mbedtls_chachapoly_encrypt_and_tag( ctx->cipher_ctx,
1032 ilen, iv, ad, ad_len, input, output, tag ) );
1033 }
1034#endif /* MBEDTLS_CHACHAPOLY_C */
1035
1036 return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
1037}
1038
1039/*
1040 * Packet-oriented decryption for AEAD modes
1041 */
1042int mbedtls_cipher_auth_decrypt( mbedtls_cipher_context_t *ctx,
1043 const unsigned char *iv, size_t iv_len,
1044 const unsigned char *ad, size_t ad_len,
1045 const unsigned char *input, size_t ilen,
1046 unsigned char *output, size_t *olen,
1047 const unsigned char *tag, size_t tag_len )
1048{
1049#if defined(MBEDTLS_GCM_C)
1050 if( MBEDTLS_MODE_GCM == ctx->cipher_info->mode )
1051 {
1052 int ret;
1053
1054 *olen = ilen;
1055 ret = mbedtls_gcm_auth_decrypt( ctx->cipher_ctx, ilen,
1056 iv, iv_len, ad, ad_len,
1057 tag, tag_len, input, output );
1058
1059 if( ret == MBEDTLS_ERR_GCM_AUTH_FAILED )
1060 ret = MBEDTLS_ERR_CIPHER_AUTH_FAILED;
1061
1062 return( ret );
1063 }
1064#endif /* MBEDTLS_GCM_C */
1065#if defined(MBEDTLS_CCM_C)
1066 if( MBEDTLS_MODE_CCM == ctx->cipher_info->mode )
1067 {
1068 int ret;
1069
1070 *olen = ilen;
1071 ret = mbedtls_ccm_auth_decrypt( ctx->cipher_ctx, ilen,
1072 iv, iv_len, ad, ad_len,
1073 input, output, tag, tag_len );
1074
1075 if( ret == MBEDTLS_ERR_CCM_AUTH_FAILED )
1076 ret = MBEDTLS_ERR_CIPHER_AUTH_FAILED;
1077
1078 return( ret );
1079 }
1080#endif /* MBEDTLS_CCM_C */
1081#if defined(MBEDTLS_CHACHAPOLY_C)
1082 if ( MBEDTLS_CIPHER_CHACHA20_POLY1305 == ctx->cipher_info->type )
1083 {
1084 int ret;
1085
1086 /* ChachaPoly has fixed length nonce and MAC (tag) */
1087 if ( ( iv_len != ctx->cipher_info->iv_size ) ||
1088 ( tag_len != 16U ) )
1089 {
1090 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
1091 }
1092
1093 *olen = ilen;
1094 ret = mbedtls_chachapoly_auth_decrypt( ctx->cipher_ctx, ilen,
1095 iv, ad, ad_len, tag, input, output );
1096
1097 if( ret == MBEDTLS_ERR_CHACHAPOLY_AUTH_FAILED )
1098 ret = MBEDTLS_ERR_CIPHER_AUTH_FAILED;
1099
1100 return( ret );
1101 }
1102#endif /* MBEDTLS_CHACHAPOLY_C */
1103
1104 return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
1105}
1106#endif /* MBEDTLS_CIPHER_MODE_AEAD */
1107
1108#endif /* MBEDTLS_CIPHER_C */
diff --git a/source/mbedtls/lib/cipher_wrap.c b/source/mbedtls/lib/cipher_wrap.c
deleted file mode 100644
index 3f81729..0000000
--- a/source/mbedtls/lib/cipher_wrap.c
+++ /dev/null
@@ -1,2274 +0,0 @@
1/**
2 * \file cipher_wrap.c
3 *
4 * \brief Generic cipher wrapper for mbed TLS
5 *
6 * \author Adriaan de Jong <dejong@fox-it.com>
7 *
8 * Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
9 * SPDX-License-Identifier: GPL-2.0
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License along
22 * with this program; if not, write to the Free Software Foundation, Inc.,
23 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
24 *
25 * This file is part of mbed TLS (https://tls.mbed.org)
26 */
27
28#if !defined(MBEDTLS_CONFIG_FILE)
29#include "mbedtls/config.h"
30#else
31#include MBEDTLS_CONFIG_FILE
32#endif
33
34#if defined(MBEDTLS_CIPHER_C)
35
36#include "mbedtls/cipher_internal.h"
37
38#if defined(MBEDTLS_CHACHAPOLY_C)
39#include "mbedtls/chachapoly.h"
40#endif
41
42#if defined(MBEDTLS_AES_C)
43#include "mbedtls/aes.h"
44#endif
45
46#if defined(MBEDTLS_ARC4_C)
47#include "mbedtls/arc4.h"
48#endif
49
50#if defined(MBEDTLS_CAMELLIA_C)
51#include "mbedtls/camellia.h"
52#endif
53
54#if defined(MBEDTLS_ARIA_C)
55#include "mbedtls/aria.h"
56#endif
57
58#if defined(MBEDTLS_DES_C)
59#include "mbedtls/des.h"
60#endif
61
62#if defined(MBEDTLS_BLOWFISH_C)
63#include "mbedtls/blowfish.h"
64#endif
65
66#if defined(MBEDTLS_CHACHA20_C)
67#include "mbedtls/chacha20.h"
68#endif
69
70#if defined(MBEDTLS_GCM_C)
71#include "mbedtls/gcm.h"
72#endif
73
74#if defined(MBEDTLS_CCM_C)
75#include "mbedtls/ccm.h"
76#endif
77
78#if defined(MBEDTLS_CIPHER_NULL_CIPHER)
79#include <string.h>
80#endif
81
82#if defined(MBEDTLS_PLATFORM_C)
83#include "mbedtls/platform.h"
84#else
85#include <stdlib.h>
86#define mbedtls_calloc calloc
87#define mbedtls_free free
88#endif
89
90#if defined(MBEDTLS_GCM_C)
91/* shared by all GCM ciphers */
92static void *gcm_ctx_alloc( void )
93{
94 void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_gcm_context ) );
95
96 if( ctx != NULL )
97 mbedtls_gcm_init( (mbedtls_gcm_context *) ctx );
98
99 return( ctx );
100}
101
102static void gcm_ctx_free( void *ctx )
103{
104 mbedtls_gcm_free( ctx );
105 mbedtls_free( ctx );
106}
107#endif /* MBEDTLS_GCM_C */
108
109#if defined(MBEDTLS_CCM_C)
110/* shared by all CCM ciphers */
111static void *ccm_ctx_alloc( void )
112{
113 void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_ccm_context ) );
114
115 if( ctx != NULL )
116 mbedtls_ccm_init( (mbedtls_ccm_context *) ctx );
117
118 return( ctx );
119}
120
121static void ccm_ctx_free( void *ctx )
122{
123 mbedtls_ccm_free( ctx );
124 mbedtls_free( ctx );
125}
126#endif /* MBEDTLS_CCM_C */
127
128#if defined(MBEDTLS_AES_C)
129
130static int aes_crypt_ecb_wrap( void *ctx, mbedtls_operation_t operation,
131 const unsigned char *input, unsigned char *output )
132{
133 return mbedtls_aes_crypt_ecb( (mbedtls_aes_context *) ctx, operation, input, output );
134}
135
136#if defined(MBEDTLS_CIPHER_MODE_CBC)
137static int aes_crypt_cbc_wrap( void *ctx, mbedtls_operation_t operation, size_t length,
138 unsigned char *iv, const unsigned char *input, unsigned char *output )
139{
140 return mbedtls_aes_crypt_cbc( (mbedtls_aes_context *) ctx, operation, length, iv, input,
141 output );
142}
143#endif /* MBEDTLS_CIPHER_MODE_CBC */
144
145#if defined(MBEDTLS_CIPHER_MODE_CFB)
146static int aes_crypt_cfb128_wrap( void *ctx, mbedtls_operation_t operation,
147 size_t length, size_t *iv_off, unsigned char *iv,
148 const unsigned char *input, unsigned char *output )
149{
150 return mbedtls_aes_crypt_cfb128( (mbedtls_aes_context *) ctx, operation, length, iv_off, iv,
151 input, output );
152}
153#endif /* MBEDTLS_CIPHER_MODE_CFB */
154
155#if defined(MBEDTLS_CIPHER_MODE_OFB)
156static int aes_crypt_ofb_wrap( void *ctx, size_t length, size_t *iv_off,
157 unsigned char *iv, const unsigned char *input, unsigned char *output )
158{
159 return mbedtls_aes_crypt_ofb( (mbedtls_aes_context *) ctx, length, iv_off,
160 iv, input, output );
161}
162#endif /* MBEDTLS_CIPHER_MODE_OFB */
163
164#if defined(MBEDTLS_CIPHER_MODE_CTR)
165static int aes_crypt_ctr_wrap( void *ctx, size_t length, size_t *nc_off,
166 unsigned char *nonce_counter, unsigned char *stream_block,
167 const unsigned char *input, unsigned char *output )
168{
169 return mbedtls_aes_crypt_ctr( (mbedtls_aes_context *) ctx, length, nc_off, nonce_counter,
170 stream_block, input, output );
171}
172#endif /* MBEDTLS_CIPHER_MODE_CTR */
173
174#if defined(MBEDTLS_CIPHER_MODE_XTS)
175static int aes_crypt_xts_wrap( void *ctx, mbedtls_operation_t operation,
176 size_t length,
177 const unsigned char data_unit[16],
178 const unsigned char *input,
179 unsigned char *output )
180{
181 mbedtls_aes_xts_context *xts_ctx = ctx;
182 int mode;
183
184 switch( operation )
185 {
186 case MBEDTLS_ENCRYPT:
187 mode = MBEDTLS_AES_ENCRYPT;
188 break;
189 case MBEDTLS_DECRYPT:
190 mode = MBEDTLS_AES_DECRYPT;
191 break;
192 default:
193 return MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA;
194 }
195
196 return mbedtls_aes_crypt_xts( xts_ctx, mode, length,
197 data_unit, input, output );
198}
199#endif /* MBEDTLS_CIPHER_MODE_XTS */
200
201static int aes_setkey_dec_wrap( void *ctx, const unsigned char *key,
202 unsigned int key_bitlen )
203{
204 return mbedtls_aes_setkey_dec( (mbedtls_aes_context *) ctx, key, key_bitlen );
205}
206
207static int aes_setkey_enc_wrap( void *ctx, const unsigned char *key,
208 unsigned int key_bitlen )
209{
210 return mbedtls_aes_setkey_enc( (mbedtls_aes_context *) ctx, key, key_bitlen );
211}
212
213static void * aes_ctx_alloc( void )
214{
215 mbedtls_aes_context *aes = mbedtls_calloc( 1, sizeof( mbedtls_aes_context ) );
216
217 if( aes == NULL )
218 return( NULL );
219
220 mbedtls_aes_init( aes );
221
222 return( aes );
223}
224
225static void aes_ctx_free( void *ctx )
226{
227 mbedtls_aes_free( (mbedtls_aes_context *) ctx );
228 mbedtls_free( ctx );
229}
230
231static const mbedtls_cipher_base_t aes_info = {
232 MBEDTLS_CIPHER_ID_AES,
233 aes_crypt_ecb_wrap,
234#if defined(MBEDTLS_CIPHER_MODE_CBC)
235 aes_crypt_cbc_wrap,
236#endif
237#if defined(MBEDTLS_CIPHER_MODE_CFB)
238 aes_crypt_cfb128_wrap,
239#endif
240#if defined(MBEDTLS_CIPHER_MODE_OFB)
241 aes_crypt_ofb_wrap,
242#endif
243#if defined(MBEDTLS_CIPHER_MODE_CTR)
244 aes_crypt_ctr_wrap,
245#endif
246#if defined(MBEDTLS_CIPHER_MODE_XTS)
247 NULL,
248#endif
249#if defined(MBEDTLS_CIPHER_MODE_STREAM)
250 NULL,
251#endif
252 aes_setkey_enc_wrap,
253 aes_setkey_dec_wrap,
254 aes_ctx_alloc,
255 aes_ctx_free
256};
257
258static const mbedtls_cipher_info_t aes_128_ecb_info = {
259 MBEDTLS_CIPHER_AES_128_ECB,
260 MBEDTLS_MODE_ECB,
261 128,
262 "AES-128-ECB",
263 16,
264 0,
265 16,
266 &aes_info
267};
268
269static const mbedtls_cipher_info_t aes_192_ecb_info = {
270 MBEDTLS_CIPHER_AES_192_ECB,
271 MBEDTLS_MODE_ECB,
272 192,
273 "AES-192-ECB",
274 16,
275 0,
276 16,
277 &aes_info
278};
279
280static const mbedtls_cipher_info_t aes_256_ecb_info = {
281 MBEDTLS_CIPHER_AES_256_ECB,
282 MBEDTLS_MODE_ECB,
283 256,
284 "AES-256-ECB",
285 16,
286 0,
287 16,
288 &aes_info
289};
290
291#if defined(MBEDTLS_CIPHER_MODE_CBC)
292static const mbedtls_cipher_info_t aes_128_cbc_info = {
293 MBEDTLS_CIPHER_AES_128_CBC,
294 MBEDTLS_MODE_CBC,
295 128,
296 "AES-128-CBC",
297 16,
298 0,
299 16,
300 &aes_info
301};
302
303static const mbedtls_cipher_info_t aes_192_cbc_info = {
304 MBEDTLS_CIPHER_AES_192_CBC,
305 MBEDTLS_MODE_CBC,
306 192,
307 "AES-192-CBC",
308 16,
309 0,
310 16,
311 &aes_info
312};
313
314static const mbedtls_cipher_info_t aes_256_cbc_info = {
315 MBEDTLS_CIPHER_AES_256_CBC,
316 MBEDTLS_MODE_CBC,
317 256,
318 "AES-256-CBC",
319 16,
320 0,
321 16,
322 &aes_info
323};
324#endif /* MBEDTLS_CIPHER_MODE_CBC */
325
326#if defined(MBEDTLS_CIPHER_MODE_CFB)
327static const mbedtls_cipher_info_t aes_128_cfb128_info = {
328 MBEDTLS_CIPHER_AES_128_CFB128,
329 MBEDTLS_MODE_CFB,
330 128,
331 "AES-128-CFB128",
332 16,
333 0,
334 16,
335 &aes_info
336};
337
338static const mbedtls_cipher_info_t aes_192_cfb128_info = {
339 MBEDTLS_CIPHER_AES_192_CFB128,
340 MBEDTLS_MODE_CFB,
341 192,
342 "AES-192-CFB128",
343 16,
344 0,
345 16,
346 &aes_info
347};
348
349static const mbedtls_cipher_info_t aes_256_cfb128_info = {
350 MBEDTLS_CIPHER_AES_256_CFB128,
351 MBEDTLS_MODE_CFB,
352 256,
353 "AES-256-CFB128",
354 16,
355 0,
356 16,
357 &aes_info
358};
359#endif /* MBEDTLS_CIPHER_MODE_CFB */
360
361#if defined(MBEDTLS_CIPHER_MODE_OFB)
362static const mbedtls_cipher_info_t aes_128_ofb_info = {
363 MBEDTLS_CIPHER_AES_128_OFB,
364 MBEDTLS_MODE_OFB,
365 128,
366 "AES-128-OFB",
367 16,
368 0,
369 16,
370 &aes_info
371};
372
373static const mbedtls_cipher_info_t aes_192_ofb_info = {
374 MBEDTLS_CIPHER_AES_192_OFB,
375 MBEDTLS_MODE_OFB,
376 192,
377 "AES-192-OFB",
378 16,
379 0,
380 16,
381 &aes_info
382};
383
384static const mbedtls_cipher_info_t aes_256_ofb_info = {
385 MBEDTLS_CIPHER_AES_256_OFB,
386 MBEDTLS_MODE_OFB,
387 256,
388 "AES-256-OFB",
389 16,
390 0,
391 16,
392 &aes_info
393};
394#endif /* MBEDTLS_CIPHER_MODE_OFB */
395
396#if defined(MBEDTLS_CIPHER_MODE_CTR)
397static const mbedtls_cipher_info_t aes_128_ctr_info = {
398 MBEDTLS_CIPHER_AES_128_CTR,
399 MBEDTLS_MODE_CTR,
400 128,
401 "AES-128-CTR",
402 16,
403 0,
404 16,
405 &aes_info
406};
407
408static const mbedtls_cipher_info_t aes_192_ctr_info = {
409 MBEDTLS_CIPHER_AES_192_CTR,
410 MBEDTLS_MODE_CTR,
411 192,
412 "AES-192-CTR",
413 16,
414 0,
415 16,
416 &aes_info
417};
418
419static const mbedtls_cipher_info_t aes_256_ctr_info = {
420 MBEDTLS_CIPHER_AES_256_CTR,
421 MBEDTLS_MODE_CTR,
422 256,
423 "AES-256-CTR",
424 16,
425 0,
426 16,
427 &aes_info
428};
429#endif /* MBEDTLS_CIPHER_MODE_CTR */
430
431#if defined(MBEDTLS_CIPHER_MODE_XTS)
432static int xts_aes_setkey_enc_wrap( void *ctx, const unsigned char *key,
433 unsigned int key_bitlen )
434{
435 mbedtls_aes_xts_context *xts_ctx = ctx;
436 return( mbedtls_aes_xts_setkey_enc( xts_ctx, key, key_bitlen ) );
437}
438
439static int xts_aes_setkey_dec_wrap( void *ctx, const unsigned char *key,
440 unsigned int key_bitlen )
441{
442 mbedtls_aes_xts_context *xts_ctx = ctx;
443 return( mbedtls_aes_xts_setkey_dec( xts_ctx, key, key_bitlen ) );
444}
445
446static void *xts_aes_ctx_alloc( void )
447{
448 mbedtls_aes_xts_context *xts_ctx = mbedtls_calloc( 1, sizeof( *xts_ctx ) );
449
450 if( xts_ctx != NULL )
451 mbedtls_aes_xts_init( xts_ctx );
452
453 return( xts_ctx );
454}
455
456static void xts_aes_ctx_free( void *ctx )
457{
458 mbedtls_aes_xts_context *xts_ctx = ctx;
459
460 if( xts_ctx == NULL )
461 return;
462
463 mbedtls_aes_xts_free( xts_ctx );
464 mbedtls_free( xts_ctx );
465}
466
467static const mbedtls_cipher_base_t xts_aes_info = {
468 MBEDTLS_CIPHER_ID_AES,
469 NULL,
470#if defined(MBEDTLS_CIPHER_MODE_CBC)
471 NULL,
472#endif
473#if defined(MBEDTLS_CIPHER_MODE_CFB)
474 NULL,
475#endif
476#if defined(MBEDTLS_CIPHER_MODE_OFB)
477 NULL,
478#endif
479#if defined(MBEDTLS_CIPHER_MODE_CTR)
480 NULL,
481#endif
482#if defined(MBEDTLS_CIPHER_MODE_XTS)
483 aes_crypt_xts_wrap,
484#endif
485#if defined(MBEDTLS_CIPHER_MODE_STREAM)
486 NULL,
487#endif
488 xts_aes_setkey_enc_wrap,
489 xts_aes_setkey_dec_wrap,
490 xts_aes_ctx_alloc,
491 xts_aes_ctx_free
492};
493
494static const mbedtls_cipher_info_t aes_128_xts_info = {
495 MBEDTLS_CIPHER_AES_128_XTS,
496 MBEDTLS_MODE_XTS,
497 256,
498 "AES-128-XTS",
499 16,
500 0,
501 16,
502 &xts_aes_info
503};
504
505static const mbedtls_cipher_info_t aes_256_xts_info = {
506 MBEDTLS_CIPHER_AES_256_XTS,
507 MBEDTLS_MODE_XTS,
508 512,
509 "AES-256-XTS",
510 16,
511 0,
512 16,
513 &xts_aes_info
514};
515#endif /* MBEDTLS_CIPHER_MODE_XTS */
516
517#if defined(MBEDTLS_GCM_C)
518static int gcm_aes_setkey_wrap( void *ctx, const unsigned char *key,
519 unsigned int key_bitlen )
520{
521 return mbedtls_gcm_setkey( (mbedtls_gcm_context *) ctx, MBEDTLS_CIPHER_ID_AES,
522 key, key_bitlen );
523}
524
525static const mbedtls_cipher_base_t gcm_aes_info = {
526 MBEDTLS_CIPHER_ID_AES,
527 NULL,
528#if defined(MBEDTLS_CIPHER_MODE_CBC)
529 NULL,
530#endif
531#if defined(MBEDTLS_CIPHER_MODE_CFB)
532 NULL,
533#endif
534#if defined(MBEDTLS_CIPHER_MODE_OFB)
535 NULL,
536#endif
537#if defined(MBEDTLS_CIPHER_MODE_CTR)
538 NULL,
539#endif
540#if defined(MBEDTLS_CIPHER_MODE_XTS)
541 NULL,
542#endif
543#if defined(MBEDTLS_CIPHER_MODE_STREAM)
544 NULL,
545#endif
546 gcm_aes_setkey_wrap,
547 gcm_aes_setkey_wrap,
548 gcm_ctx_alloc,
549 gcm_ctx_free,
550};
551
552static const mbedtls_cipher_info_t aes_128_gcm_info = {
553 MBEDTLS_CIPHER_AES_128_GCM,
554 MBEDTLS_MODE_GCM,
555 128,
556 "AES-128-GCM",
557 12,
558 MBEDTLS_CIPHER_VARIABLE_IV_LEN,
559 16,
560 &gcm_aes_info
561};
562
563static const mbedtls_cipher_info_t aes_192_gcm_info = {
564 MBEDTLS_CIPHER_AES_192_GCM,
565 MBEDTLS_MODE_GCM,
566 192,
567 "AES-192-GCM",
568 12,
569 MBEDTLS_CIPHER_VARIABLE_IV_LEN,
570 16,
571 &gcm_aes_info
572};
573
574static const mbedtls_cipher_info_t aes_256_gcm_info = {
575 MBEDTLS_CIPHER_AES_256_GCM,
576 MBEDTLS_MODE_GCM,
577 256,
578 "AES-256-GCM",
579 12,
580 MBEDTLS_CIPHER_VARIABLE_IV_LEN,
581 16,
582 &gcm_aes_info
583};
584#endif /* MBEDTLS_GCM_C */
585
586#if defined(MBEDTLS_CCM_C)
587static int ccm_aes_setkey_wrap( void *ctx, const unsigned char *key,
588 unsigned int key_bitlen )
589{
590 return mbedtls_ccm_setkey( (mbedtls_ccm_context *) ctx, MBEDTLS_CIPHER_ID_AES,
591 key, key_bitlen );
592}
593
594static const mbedtls_cipher_base_t ccm_aes_info = {
595 MBEDTLS_CIPHER_ID_AES,
596 NULL,
597#if defined(MBEDTLS_CIPHER_MODE_CBC)
598 NULL,
599#endif
600#if defined(MBEDTLS_CIPHER_MODE_CFB)
601 NULL,
602#endif
603#if defined(MBEDTLS_CIPHER_MODE_OFB)
604 NULL,
605#endif
606#if defined(MBEDTLS_CIPHER_MODE_CTR)
607 NULL,
608#endif
609#if defined(MBEDTLS_CIPHER_MODE_XTS)
610 NULL,
611#endif
612#if defined(MBEDTLS_CIPHER_MODE_STREAM)
613 NULL,
614#endif
615 ccm_aes_setkey_wrap,
616 ccm_aes_setkey_wrap,
617 ccm_ctx_alloc,
618 ccm_ctx_free,
619};
620
621static const mbedtls_cipher_info_t aes_128_ccm_info = {
622 MBEDTLS_CIPHER_AES_128_CCM,
623 MBEDTLS_MODE_CCM,
624 128,
625 "AES-128-CCM",
626 12,
627 MBEDTLS_CIPHER_VARIABLE_IV_LEN,
628 16,
629 &ccm_aes_info
630};
631
632static const mbedtls_cipher_info_t aes_192_ccm_info = {
633 MBEDTLS_CIPHER_AES_192_CCM,
634 MBEDTLS_MODE_CCM,
635 192,
636 "AES-192-CCM",
637 12,
638 MBEDTLS_CIPHER_VARIABLE_IV_LEN,
639 16,
640 &ccm_aes_info
641};
642
643static const mbedtls_cipher_info_t aes_256_ccm_info = {
644 MBEDTLS_CIPHER_AES_256_CCM,
645 MBEDTLS_MODE_CCM,
646 256,
647 "AES-256-CCM",
648 12,
649 MBEDTLS_CIPHER_VARIABLE_IV_LEN,
650 16,
651 &ccm_aes_info
652};
653#endif /* MBEDTLS_CCM_C */
654
655#endif /* MBEDTLS_AES_C */
656
657#if defined(MBEDTLS_CAMELLIA_C)
658
659static int camellia_crypt_ecb_wrap( void *ctx, mbedtls_operation_t operation,
660 const unsigned char *input, unsigned char *output )
661{
662 return mbedtls_camellia_crypt_ecb( (mbedtls_camellia_context *) ctx, operation, input,
663 output );
664}
665
666#if defined(MBEDTLS_CIPHER_MODE_CBC)
667static int camellia_crypt_cbc_wrap( void *ctx, mbedtls_operation_t operation,
668 size_t length, unsigned char *iv,
669 const unsigned char *input, unsigned char *output )
670{
671 return mbedtls_camellia_crypt_cbc( (mbedtls_camellia_context *) ctx, operation, length, iv,
672 input, output );
673}
674#endif /* MBEDTLS_CIPHER_MODE_CBC */
675
676#if defined(MBEDTLS_CIPHER_MODE_CFB)
677static int camellia_crypt_cfb128_wrap( void *ctx, mbedtls_operation_t operation,
678 size_t length, size_t *iv_off, unsigned char *iv,
679 const unsigned char *input, unsigned char *output )
680{
681 return mbedtls_camellia_crypt_cfb128( (mbedtls_camellia_context *) ctx, operation, length,
682 iv_off, iv, input, output );
683}
684#endif /* MBEDTLS_CIPHER_MODE_CFB */
685
686#if defined(MBEDTLS_CIPHER_MODE_CTR)
687static int camellia_crypt_ctr_wrap( void *ctx, size_t length, size_t *nc_off,
688 unsigned char *nonce_counter, unsigned char *stream_block,
689 const unsigned char *input, unsigned char *output )
690{
691 return mbedtls_camellia_crypt_ctr( (mbedtls_camellia_context *) ctx, length, nc_off,
692 nonce_counter, stream_block, input, output );
693}
694#endif /* MBEDTLS_CIPHER_MODE_CTR */
695
696static int camellia_setkey_dec_wrap( void *ctx, const unsigned char *key,
697 unsigned int key_bitlen )
698{
699 return mbedtls_camellia_setkey_dec( (mbedtls_camellia_context *) ctx, key, key_bitlen );
700}
701
702static int camellia_setkey_enc_wrap( void *ctx, const unsigned char *key,
703 unsigned int key_bitlen )
704{
705 return mbedtls_camellia_setkey_enc( (mbedtls_camellia_context *) ctx, key, key_bitlen );
706}
707
708static void * camellia_ctx_alloc( void )
709{
710 mbedtls_camellia_context *ctx;
711 ctx = mbedtls_calloc( 1, sizeof( mbedtls_camellia_context ) );
712
713 if( ctx == NULL )
714 return( NULL );
715
716 mbedtls_camellia_init( ctx );
717
718 return( ctx );
719}
720
721static void camellia_ctx_free( void *ctx )
722{
723 mbedtls_camellia_free( (mbedtls_camellia_context *) ctx );
724 mbedtls_free( ctx );
725}
726
727static const mbedtls_cipher_base_t camellia_info = {
728 MBEDTLS_CIPHER_ID_CAMELLIA,
729 camellia_crypt_ecb_wrap,
730#if defined(MBEDTLS_CIPHER_MODE_CBC)
731 camellia_crypt_cbc_wrap,
732#endif
733#if defined(MBEDTLS_CIPHER_MODE_CFB)
734 camellia_crypt_cfb128_wrap,
735#endif
736#if defined(MBEDTLS_CIPHER_MODE_OFB)
737 NULL,
738#endif
739#if defined(MBEDTLS_CIPHER_MODE_CTR)
740 camellia_crypt_ctr_wrap,
741#endif
742#if defined(MBEDTLS_CIPHER_MODE_XTS)
743 NULL,
744#endif
745#if defined(MBEDTLS_CIPHER_MODE_STREAM)
746 NULL,
747#endif
748 camellia_setkey_enc_wrap,
749 camellia_setkey_dec_wrap,
750 camellia_ctx_alloc,
751 camellia_ctx_free
752};
753
754static const mbedtls_cipher_info_t camellia_128_ecb_info = {
755 MBEDTLS_CIPHER_CAMELLIA_128_ECB,
756 MBEDTLS_MODE_ECB,
757 128,
758 "CAMELLIA-128-ECB",
759 16,
760 0,
761 16,
762 &camellia_info
763};
764
765static const mbedtls_cipher_info_t camellia_192_ecb_info = {
766 MBEDTLS_CIPHER_CAMELLIA_192_ECB,
767 MBEDTLS_MODE_ECB,
768 192,
769 "CAMELLIA-192-ECB",
770 16,
771 0,
772 16,
773 &camellia_info
774};
775
776static const mbedtls_cipher_info_t camellia_256_ecb_info = {
777 MBEDTLS_CIPHER_CAMELLIA_256_ECB,
778 MBEDTLS_MODE_ECB,
779 256,
780 "CAMELLIA-256-ECB",
781 16,
782 0,
783 16,
784 &camellia_info
785};
786
787#if defined(MBEDTLS_CIPHER_MODE_CBC)
788static const mbedtls_cipher_info_t camellia_128_cbc_info = {
789 MBEDTLS_CIPHER_CAMELLIA_128_CBC,
790 MBEDTLS_MODE_CBC,
791 128,
792 "CAMELLIA-128-CBC",
793 16,
794 0,
795 16,
796 &camellia_info
797};
798
799static const mbedtls_cipher_info_t camellia_192_cbc_info = {
800 MBEDTLS_CIPHER_CAMELLIA_192_CBC,
801 MBEDTLS_MODE_CBC,
802 192,
803 "CAMELLIA-192-CBC",
804 16,
805 0,
806 16,
807 &camellia_info
808};
809
810static const mbedtls_cipher_info_t camellia_256_cbc_info = {
811 MBEDTLS_CIPHER_CAMELLIA_256_CBC,
812 MBEDTLS_MODE_CBC,
813 256,
814 "CAMELLIA-256-CBC",
815 16,
816 0,
817 16,
818 &camellia_info
819};
820#endif /* MBEDTLS_CIPHER_MODE_CBC */
821
822#if defined(MBEDTLS_CIPHER_MODE_CFB)
823static const mbedtls_cipher_info_t camellia_128_cfb128_info = {
824 MBEDTLS_CIPHER_CAMELLIA_128_CFB128,
825 MBEDTLS_MODE_CFB,
826 128,
827 "CAMELLIA-128-CFB128",
828 16,
829 0,
830 16,
831 &camellia_info
832};
833
834static const mbedtls_cipher_info_t camellia_192_cfb128_info = {
835 MBEDTLS_CIPHER_CAMELLIA_192_CFB128,
836 MBEDTLS_MODE_CFB,
837 192,
838 "CAMELLIA-192-CFB128",
839 16,
840 0,
841 16,
842 &camellia_info
843};
844
845static const mbedtls_cipher_info_t camellia_256_cfb128_info = {
846 MBEDTLS_CIPHER_CAMELLIA_256_CFB128,
847 MBEDTLS_MODE_CFB,
848 256,
849 "CAMELLIA-256-CFB128",
850 16,
851 0,
852 16,
853 &camellia_info
854};
855#endif /* MBEDTLS_CIPHER_MODE_CFB */
856
857#if defined(MBEDTLS_CIPHER_MODE_CTR)
858static const mbedtls_cipher_info_t camellia_128_ctr_info = {
859 MBEDTLS_CIPHER_CAMELLIA_128_CTR,
860 MBEDTLS_MODE_CTR,
861 128,
862 "CAMELLIA-128-CTR",
863 16,
864 0,
865 16,
866 &camellia_info
867};
868
869static const mbedtls_cipher_info_t camellia_192_ctr_info = {
870 MBEDTLS_CIPHER_CAMELLIA_192_CTR,
871 MBEDTLS_MODE_CTR,
872 192,
873 "CAMELLIA-192-CTR",
874 16,
875 0,
876 16,
877 &camellia_info
878};
879
880static const mbedtls_cipher_info_t camellia_256_ctr_info = {
881 MBEDTLS_CIPHER_CAMELLIA_256_CTR,
882 MBEDTLS_MODE_CTR,
883 256,
884 "CAMELLIA-256-CTR",
885 16,
886 0,
887 16,
888 &camellia_info
889};
890#endif /* MBEDTLS_CIPHER_MODE_CTR */
891
892#if defined(MBEDTLS_GCM_C)
893static int gcm_camellia_setkey_wrap( void *ctx, const unsigned char *key,
894 unsigned int key_bitlen )
895{
896 return mbedtls_gcm_setkey( (mbedtls_gcm_context *) ctx, MBEDTLS_CIPHER_ID_CAMELLIA,
897 key, key_bitlen );
898}
899
900static const mbedtls_cipher_base_t gcm_camellia_info = {
901 MBEDTLS_CIPHER_ID_CAMELLIA,
902 NULL,
903#if defined(MBEDTLS_CIPHER_MODE_CBC)
904 NULL,
905#endif
906#if defined(MBEDTLS_CIPHER_MODE_CFB)
907 NULL,
908#endif
909#if defined(MBEDTLS_CIPHER_MODE_OFB)
910 NULL,
911#endif
912#if defined(MBEDTLS_CIPHER_MODE_CTR)
913 NULL,
914#endif
915#if defined(MBEDTLS_CIPHER_MODE_XTS)
916 NULL,
917#endif
918#if defined(MBEDTLS_CIPHER_MODE_STREAM)
919 NULL,
920#endif
921 gcm_camellia_setkey_wrap,
922 gcm_camellia_setkey_wrap,
923 gcm_ctx_alloc,
924 gcm_ctx_free,
925};
926
927static const mbedtls_cipher_info_t camellia_128_gcm_info = {
928 MBEDTLS_CIPHER_CAMELLIA_128_GCM,
929 MBEDTLS_MODE_GCM,
930 128,
931 "CAMELLIA-128-GCM",
932 12,
933 MBEDTLS_CIPHER_VARIABLE_IV_LEN,
934 16,
935 &gcm_camellia_info
936};
937
938static const mbedtls_cipher_info_t camellia_192_gcm_info = {
939 MBEDTLS_CIPHER_CAMELLIA_192_GCM,
940 MBEDTLS_MODE_GCM,
941 192,
942 "CAMELLIA-192-GCM",
943 12,
944 MBEDTLS_CIPHER_VARIABLE_IV_LEN,
945 16,
946 &gcm_camellia_info
947};
948
949static const mbedtls_cipher_info_t camellia_256_gcm_info = {
950 MBEDTLS_CIPHER_CAMELLIA_256_GCM,
951 MBEDTLS_MODE_GCM,
952 256,
953 "CAMELLIA-256-GCM",
954 12,
955 MBEDTLS_CIPHER_VARIABLE_IV_LEN,
956 16,
957 &gcm_camellia_info
958};
959#endif /* MBEDTLS_GCM_C */
960
961#if defined(MBEDTLS_CCM_C)
962static int ccm_camellia_setkey_wrap( void *ctx, const unsigned char *key,
963 unsigned int key_bitlen )
964{
965 return mbedtls_ccm_setkey( (mbedtls_ccm_context *) ctx, MBEDTLS_CIPHER_ID_CAMELLIA,
966 key, key_bitlen );
967}
968
969static const mbedtls_cipher_base_t ccm_camellia_info = {
970 MBEDTLS_CIPHER_ID_CAMELLIA,
971 NULL,
972#if defined(MBEDTLS_CIPHER_MODE_CBC)
973 NULL,
974#endif
975#if defined(MBEDTLS_CIPHER_MODE_CFB)
976 NULL,
977#endif
978#if defined(MBEDTLS_CIPHER_MODE_OFB)
979 NULL,
980#endif
981#if defined(MBEDTLS_CIPHER_MODE_CTR)
982 NULL,
983#endif
984#if defined(MBEDTLS_CIPHER_MODE_XTS)
985 NULL,
986#endif
987#if defined(MBEDTLS_CIPHER_MODE_STREAM)
988 NULL,
989#endif
990 ccm_camellia_setkey_wrap,
991 ccm_camellia_setkey_wrap,
992 ccm_ctx_alloc,
993 ccm_ctx_free,
994};
995
996static const mbedtls_cipher_info_t camellia_128_ccm_info = {
997 MBEDTLS_CIPHER_CAMELLIA_128_CCM,
998 MBEDTLS_MODE_CCM,
999 128,
1000 "CAMELLIA-128-CCM",
1001 12,
1002 MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1003 16,
1004 &ccm_camellia_info
1005};
1006
1007static const mbedtls_cipher_info_t camellia_192_ccm_info = {
1008 MBEDTLS_CIPHER_CAMELLIA_192_CCM,
1009 MBEDTLS_MODE_CCM,
1010 192,
1011 "CAMELLIA-192-CCM",
1012 12,
1013 MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1014 16,
1015 &ccm_camellia_info
1016};
1017
1018static const mbedtls_cipher_info_t camellia_256_ccm_info = {
1019 MBEDTLS_CIPHER_CAMELLIA_256_CCM,
1020 MBEDTLS_MODE_CCM,
1021 256,
1022 "CAMELLIA-256-CCM",
1023 12,
1024 MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1025 16,
1026 &ccm_camellia_info
1027};
1028#endif /* MBEDTLS_CCM_C */
1029
1030#endif /* MBEDTLS_CAMELLIA_C */
1031
1032#if defined(MBEDTLS_ARIA_C)
1033
1034static int aria_crypt_ecb_wrap( void *ctx, mbedtls_operation_t operation,
1035 const unsigned char *input, unsigned char *output )
1036{
1037 (void) operation;
1038 return mbedtls_aria_crypt_ecb( (mbedtls_aria_context *) ctx, input,
1039 output );
1040}
1041
1042#if defined(MBEDTLS_CIPHER_MODE_CBC)
1043static int aria_crypt_cbc_wrap( void *ctx, mbedtls_operation_t operation,
1044 size_t length, unsigned char *iv,
1045 const unsigned char *input, unsigned char *output )
1046{
1047 return mbedtls_aria_crypt_cbc( (mbedtls_aria_context *) ctx, operation, length, iv,
1048 input, output );
1049}
1050#endif /* MBEDTLS_CIPHER_MODE_CBC */
1051
1052#if defined(MBEDTLS_CIPHER_MODE_CFB)
1053static int aria_crypt_cfb128_wrap( void *ctx, mbedtls_operation_t operation,
1054 size_t length, size_t *iv_off, unsigned char *iv,
1055 const unsigned char *input, unsigned char *output )
1056{
1057 return mbedtls_aria_crypt_cfb128( (mbedtls_aria_context *) ctx, operation, length,
1058 iv_off, iv, input, output );
1059}
1060#endif /* MBEDTLS_CIPHER_MODE_CFB */
1061
1062#if defined(MBEDTLS_CIPHER_MODE_CTR)
1063static int aria_crypt_ctr_wrap( void *ctx, size_t length, size_t *nc_off,
1064 unsigned char *nonce_counter, unsigned char *stream_block,
1065 const unsigned char *input, unsigned char *output )
1066{
1067 return mbedtls_aria_crypt_ctr( (mbedtls_aria_context *) ctx, length, nc_off,
1068 nonce_counter, stream_block, input, output );
1069}
1070#endif /* MBEDTLS_CIPHER_MODE_CTR */
1071
1072static int aria_setkey_dec_wrap( void *ctx, const unsigned char *key,
1073 unsigned int key_bitlen )
1074{
1075 return mbedtls_aria_setkey_dec( (mbedtls_aria_context *) ctx, key, key_bitlen );
1076}
1077
1078static int aria_setkey_enc_wrap( void *ctx, const unsigned char *key,
1079 unsigned int key_bitlen )
1080{
1081 return mbedtls_aria_setkey_enc( (mbedtls_aria_context *) ctx, key, key_bitlen );
1082}
1083
1084static void * aria_ctx_alloc( void )
1085{
1086 mbedtls_aria_context *ctx;
1087 ctx = mbedtls_calloc( 1, sizeof( mbedtls_aria_context ) );
1088
1089 if( ctx == NULL )
1090 return( NULL );
1091
1092 mbedtls_aria_init( ctx );
1093
1094 return( ctx );
1095}
1096
1097static void aria_ctx_free( void *ctx )
1098{
1099 mbedtls_aria_free( (mbedtls_aria_context *) ctx );
1100 mbedtls_free( ctx );
1101}
1102
1103static const mbedtls_cipher_base_t aria_info = {
1104 MBEDTLS_CIPHER_ID_ARIA,
1105 aria_crypt_ecb_wrap,
1106#if defined(MBEDTLS_CIPHER_MODE_CBC)
1107 aria_crypt_cbc_wrap,
1108#endif
1109#if defined(MBEDTLS_CIPHER_MODE_CFB)
1110 aria_crypt_cfb128_wrap,
1111#endif
1112#if defined(MBEDTLS_CIPHER_MODE_OFB)
1113 NULL,
1114#endif
1115#if defined(MBEDTLS_CIPHER_MODE_CTR)
1116 aria_crypt_ctr_wrap,
1117#endif
1118#if defined(MBEDTLS_CIPHER_MODE_XTS)
1119 NULL,
1120#endif
1121#if defined(MBEDTLS_CIPHER_MODE_STREAM)
1122 NULL,
1123#endif
1124 aria_setkey_enc_wrap,
1125 aria_setkey_dec_wrap,
1126 aria_ctx_alloc,
1127 aria_ctx_free
1128};
1129
1130static const mbedtls_cipher_info_t aria_128_ecb_info = {
1131 MBEDTLS_CIPHER_ARIA_128_ECB,
1132 MBEDTLS_MODE_ECB,
1133 128,
1134 "ARIA-128-ECB",
1135 16,
1136 0,
1137 16,
1138 &aria_info
1139};
1140
1141static const mbedtls_cipher_info_t aria_192_ecb_info = {
1142 MBEDTLS_CIPHER_ARIA_192_ECB,
1143 MBEDTLS_MODE_ECB,
1144 192,
1145 "ARIA-192-ECB",
1146 16,
1147 0,
1148 16,
1149 &aria_info
1150};
1151
1152static const mbedtls_cipher_info_t aria_256_ecb_info = {
1153 MBEDTLS_CIPHER_ARIA_256_ECB,
1154 MBEDTLS_MODE_ECB,
1155 256,
1156 "ARIA-256-ECB",
1157 16,
1158 0,
1159 16,
1160 &aria_info
1161};
1162
1163#if defined(MBEDTLS_CIPHER_MODE_CBC)
1164static const mbedtls_cipher_info_t aria_128_cbc_info = {
1165 MBEDTLS_CIPHER_ARIA_128_CBC,
1166 MBEDTLS_MODE_CBC,
1167 128,
1168 "ARIA-128-CBC",
1169 16,
1170 0,
1171 16,
1172 &aria_info
1173};
1174
1175static const mbedtls_cipher_info_t aria_192_cbc_info = {
1176 MBEDTLS_CIPHER_ARIA_192_CBC,
1177 MBEDTLS_MODE_CBC,
1178 192,
1179 "ARIA-192-CBC",
1180 16,
1181 0,
1182 16,
1183 &aria_info
1184};
1185
1186static const mbedtls_cipher_info_t aria_256_cbc_info = {
1187 MBEDTLS_CIPHER_ARIA_256_CBC,
1188 MBEDTLS_MODE_CBC,
1189 256,
1190 "ARIA-256-CBC",
1191 16,
1192 0,
1193 16,
1194 &aria_info
1195};
1196#endif /* MBEDTLS_CIPHER_MODE_CBC */
1197
1198#if defined(MBEDTLS_CIPHER_MODE_CFB)
1199static const mbedtls_cipher_info_t aria_128_cfb128_info = {
1200 MBEDTLS_CIPHER_ARIA_128_CFB128,
1201 MBEDTLS_MODE_CFB,
1202 128,
1203 "ARIA-128-CFB128",
1204 16,
1205 0,
1206 16,
1207 &aria_info
1208};
1209
1210static const mbedtls_cipher_info_t aria_192_cfb128_info = {
1211 MBEDTLS_CIPHER_ARIA_192_CFB128,
1212 MBEDTLS_MODE_CFB,
1213 192,
1214 "ARIA-192-CFB128",
1215 16,
1216 0,
1217 16,
1218 &aria_info
1219};
1220
1221static const mbedtls_cipher_info_t aria_256_cfb128_info = {
1222 MBEDTLS_CIPHER_ARIA_256_CFB128,
1223 MBEDTLS_MODE_CFB,
1224 256,
1225 "ARIA-256-CFB128",
1226 16,
1227 0,
1228 16,
1229 &aria_info
1230};
1231#endif /* MBEDTLS_CIPHER_MODE_CFB */
1232
1233#if defined(MBEDTLS_CIPHER_MODE_CTR)
1234static const mbedtls_cipher_info_t aria_128_ctr_info = {
1235 MBEDTLS_CIPHER_ARIA_128_CTR,
1236 MBEDTLS_MODE_CTR,
1237 128,
1238 "ARIA-128-CTR",
1239 16,
1240 0,
1241 16,
1242 &aria_info
1243};
1244
1245static const mbedtls_cipher_info_t aria_192_ctr_info = {
1246 MBEDTLS_CIPHER_ARIA_192_CTR,
1247 MBEDTLS_MODE_CTR,
1248 192,
1249 "ARIA-192-CTR",
1250 16,
1251 0,
1252 16,
1253 &aria_info
1254};
1255
1256static const mbedtls_cipher_info_t aria_256_ctr_info = {
1257 MBEDTLS_CIPHER_ARIA_256_CTR,
1258 MBEDTLS_MODE_CTR,
1259 256,
1260 "ARIA-256-CTR",
1261 16,
1262 0,
1263 16,
1264 &aria_info
1265};
1266#endif /* MBEDTLS_CIPHER_MODE_CTR */
1267
1268#if defined(MBEDTLS_GCM_C)
1269static int gcm_aria_setkey_wrap( void *ctx, const unsigned char *key,
1270 unsigned int key_bitlen )
1271{
1272 return mbedtls_gcm_setkey( (mbedtls_gcm_context *) ctx, MBEDTLS_CIPHER_ID_ARIA,
1273 key, key_bitlen );
1274}
1275
1276static const mbedtls_cipher_base_t gcm_aria_info = {
1277 MBEDTLS_CIPHER_ID_ARIA,
1278 NULL,
1279#if defined(MBEDTLS_CIPHER_MODE_CBC)
1280 NULL,
1281#endif
1282#if defined(MBEDTLS_CIPHER_MODE_CFB)
1283 NULL,
1284#endif
1285#if defined(MBEDTLS_CIPHER_MODE_OFB)
1286 NULL,
1287#endif
1288#if defined(MBEDTLS_CIPHER_MODE_CTR)
1289 NULL,
1290#endif
1291#if defined(MBEDTLS_CIPHER_MODE_XTS)
1292 NULL,
1293#endif
1294#if defined(MBEDTLS_CIPHER_MODE_STREAM)
1295 NULL,
1296#endif
1297 gcm_aria_setkey_wrap,
1298 gcm_aria_setkey_wrap,
1299 gcm_ctx_alloc,
1300 gcm_ctx_free,
1301};
1302
1303static const mbedtls_cipher_info_t aria_128_gcm_info = {
1304 MBEDTLS_CIPHER_ARIA_128_GCM,
1305 MBEDTLS_MODE_GCM,
1306 128,
1307 "ARIA-128-GCM",
1308 12,
1309 MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1310 16,
1311 &gcm_aria_info
1312};
1313
1314static const mbedtls_cipher_info_t aria_192_gcm_info = {
1315 MBEDTLS_CIPHER_ARIA_192_GCM,
1316 MBEDTLS_MODE_GCM,
1317 192,
1318 "ARIA-192-GCM",
1319 12,
1320 MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1321 16,
1322 &gcm_aria_info
1323};
1324
1325static const mbedtls_cipher_info_t aria_256_gcm_info = {
1326 MBEDTLS_CIPHER_ARIA_256_GCM,
1327 MBEDTLS_MODE_GCM,
1328 256,
1329 "ARIA-256-GCM",
1330 12,
1331 MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1332 16,
1333 &gcm_aria_info
1334};
1335#endif /* MBEDTLS_GCM_C */
1336
1337#if defined(MBEDTLS_CCM_C)
1338static int ccm_aria_setkey_wrap( void *ctx, const unsigned char *key,
1339 unsigned int key_bitlen )
1340{
1341 return mbedtls_ccm_setkey( (mbedtls_ccm_context *) ctx, MBEDTLS_CIPHER_ID_ARIA,
1342 key, key_bitlen );
1343}
1344
1345static const mbedtls_cipher_base_t ccm_aria_info = {
1346 MBEDTLS_CIPHER_ID_ARIA,
1347 NULL,
1348#if defined(MBEDTLS_CIPHER_MODE_CBC)
1349 NULL,
1350#endif
1351#if defined(MBEDTLS_CIPHER_MODE_CFB)
1352 NULL,
1353#endif
1354#if defined(MBEDTLS_CIPHER_MODE_OFB)
1355 NULL,
1356#endif
1357#if defined(MBEDTLS_CIPHER_MODE_CTR)
1358 NULL,
1359#endif
1360#if defined(MBEDTLS_CIPHER_MODE_XTS)
1361 NULL,
1362#endif
1363#if defined(MBEDTLS_CIPHER_MODE_STREAM)
1364 NULL,
1365#endif
1366 ccm_aria_setkey_wrap,
1367 ccm_aria_setkey_wrap,
1368 ccm_ctx_alloc,
1369 ccm_ctx_free,
1370};
1371
1372static const mbedtls_cipher_info_t aria_128_ccm_info = {
1373 MBEDTLS_CIPHER_ARIA_128_CCM,
1374 MBEDTLS_MODE_CCM,
1375 128,
1376 "ARIA-128-CCM",
1377 12,
1378 MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1379 16,
1380 &ccm_aria_info
1381};
1382
1383static const mbedtls_cipher_info_t aria_192_ccm_info = {
1384 MBEDTLS_CIPHER_ARIA_192_CCM,
1385 MBEDTLS_MODE_CCM,
1386 192,
1387 "ARIA-192-CCM",
1388 12,
1389 MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1390 16,
1391 &ccm_aria_info
1392};
1393
1394static const mbedtls_cipher_info_t aria_256_ccm_info = {
1395 MBEDTLS_CIPHER_ARIA_256_CCM,
1396 MBEDTLS_MODE_CCM,
1397 256,
1398 "ARIA-256-CCM",
1399 12,
1400 MBEDTLS_CIPHER_VARIABLE_IV_LEN,
1401 16,
1402 &ccm_aria_info
1403};
1404#endif /* MBEDTLS_CCM_C */
1405
1406#endif /* MBEDTLS_ARIA_C */
1407
1408#if defined(MBEDTLS_DES_C)
1409
1410static int des_crypt_ecb_wrap( void *ctx, mbedtls_operation_t operation,
1411 const unsigned char *input, unsigned char *output )
1412{
1413 ((void) operation);
1414 return mbedtls_des_crypt_ecb( (mbedtls_des_context *) ctx, input, output );
1415}
1416
1417static int des3_crypt_ecb_wrap( void *ctx, mbedtls_operation_t operation,
1418 const unsigned char *input, unsigned char *output )
1419{
1420 ((void) operation);
1421 return mbedtls_des3_crypt_ecb( (mbedtls_des3_context *) ctx, input, output );
1422}
1423
1424#if defined(MBEDTLS_CIPHER_MODE_CBC)
1425static int des_crypt_cbc_wrap( void *ctx, mbedtls_operation_t operation, size_t length,
1426 unsigned char *iv, const unsigned char *input, unsigned char *output )
1427{
1428 return mbedtls_des_crypt_cbc( (mbedtls_des_context *) ctx, operation, length, iv, input,
1429 output );
1430}
1431#endif /* MBEDTLS_CIPHER_MODE_CBC */
1432
1433#if defined(MBEDTLS_CIPHER_MODE_CBC)
1434static int des3_crypt_cbc_wrap( void *ctx, mbedtls_operation_t operation, size_t length,
1435 unsigned char *iv, const unsigned char *input, unsigned char *output )
1436{
1437 return mbedtls_des3_crypt_cbc( (mbedtls_des3_context *) ctx, operation, length, iv, input,
1438 output );
1439}
1440#endif /* MBEDTLS_CIPHER_MODE_CBC */
1441
1442static int des_setkey_dec_wrap( void *ctx, const unsigned char *key,
1443 unsigned int key_bitlen )
1444{
1445 ((void) key_bitlen);
1446
1447 return mbedtls_des_setkey_dec( (mbedtls_des_context *) ctx, key );
1448}
1449
1450static int des_setkey_enc_wrap( void *ctx, const unsigned char *key,
1451 unsigned int key_bitlen )
1452{
1453 ((void) key_bitlen);
1454
1455 return mbedtls_des_setkey_enc( (mbedtls_des_context *) ctx, key );
1456}
1457
1458static int des3_set2key_dec_wrap( void *ctx, const unsigned char *key,
1459 unsigned int key_bitlen )
1460{
1461 ((void) key_bitlen);
1462
1463 return mbedtls_des3_set2key_dec( (mbedtls_des3_context *) ctx, key );
1464}
1465
1466static int des3_set2key_enc_wrap( void *ctx, const unsigned char *key,
1467 unsigned int key_bitlen )
1468{
1469 ((void) key_bitlen);
1470
1471 return mbedtls_des3_set2key_enc( (mbedtls_des3_context *) ctx, key );
1472}
1473
1474static int des3_set3key_dec_wrap( void *ctx, const unsigned char *key,
1475 unsigned int key_bitlen )
1476{
1477 ((void) key_bitlen);
1478
1479 return mbedtls_des3_set3key_dec( (mbedtls_des3_context *) ctx, key );
1480}
1481
1482static int des3_set3key_enc_wrap( void *ctx, const unsigned char *key,
1483 unsigned int key_bitlen )
1484{
1485 ((void) key_bitlen);
1486
1487 return mbedtls_des3_set3key_enc( (mbedtls_des3_context *) ctx, key );
1488}
1489
1490static void * des_ctx_alloc( void )
1491{
1492 mbedtls_des_context *des = mbedtls_calloc( 1, sizeof( mbedtls_des_context ) );
1493
1494 if( des == NULL )
1495 return( NULL );
1496
1497 mbedtls_des_init( des );
1498
1499 return( des );
1500}
1501
1502static void des_ctx_free( void *ctx )
1503{
1504 mbedtls_des_free( (mbedtls_des_context *) ctx );
1505 mbedtls_free( ctx );
1506}
1507
1508static void * des3_ctx_alloc( void )
1509{
1510 mbedtls_des3_context *des3;
1511 des3 = mbedtls_calloc( 1, sizeof( mbedtls_des3_context ) );
1512
1513 if( des3 == NULL )
1514 return( NULL );
1515
1516 mbedtls_des3_init( des3 );
1517
1518 return( des3 );
1519}
1520
1521static void des3_ctx_free( void *ctx )
1522{
1523 mbedtls_des3_free( (mbedtls_des3_context *) ctx );
1524 mbedtls_free( ctx );
1525}
1526
1527static const mbedtls_cipher_base_t des_info = {
1528 MBEDTLS_CIPHER_ID_DES,
1529 des_crypt_ecb_wrap,
1530#if defined(MBEDTLS_CIPHER_MODE_CBC)
1531 des_crypt_cbc_wrap,
1532#endif
1533#if defined(MBEDTLS_CIPHER_MODE_CFB)
1534 NULL,
1535#endif
1536#if defined(MBEDTLS_CIPHER_MODE_OFB)
1537 NULL,
1538#endif
1539#if defined(MBEDTLS_CIPHER_MODE_CTR)
1540 NULL,
1541#endif
1542#if defined(MBEDTLS_CIPHER_MODE_XTS)
1543 NULL,
1544#endif
1545#if defined(MBEDTLS_CIPHER_MODE_STREAM)
1546 NULL,
1547#endif
1548 des_setkey_enc_wrap,
1549 des_setkey_dec_wrap,
1550 des_ctx_alloc,
1551 des_ctx_free
1552};
1553
1554static const mbedtls_cipher_info_t des_ecb_info = {
1555 MBEDTLS_CIPHER_DES_ECB,
1556 MBEDTLS_MODE_ECB,
1557 MBEDTLS_KEY_LENGTH_DES,
1558 "DES-ECB",
1559 8,
1560 0,
1561 8,
1562 &des_info
1563};
1564
1565#if defined(MBEDTLS_CIPHER_MODE_CBC)
1566static const mbedtls_cipher_info_t des_cbc_info = {
1567 MBEDTLS_CIPHER_DES_CBC,
1568 MBEDTLS_MODE_CBC,
1569 MBEDTLS_KEY_LENGTH_DES,
1570 "DES-CBC",
1571 8,
1572 0,
1573 8,
1574 &des_info
1575};
1576#endif /* MBEDTLS_CIPHER_MODE_CBC */
1577
1578static const mbedtls_cipher_base_t des_ede_info = {
1579 MBEDTLS_CIPHER_ID_DES,
1580 des3_crypt_ecb_wrap,
1581#if defined(MBEDTLS_CIPHER_MODE_CBC)
1582 des3_crypt_cbc_wrap,
1583#endif
1584#if defined(MBEDTLS_CIPHER_MODE_CFB)
1585 NULL,
1586#endif
1587#if defined(MBEDTLS_CIPHER_MODE_OFB)
1588 NULL,
1589#endif
1590#if defined(MBEDTLS_CIPHER_MODE_CTR)
1591 NULL,
1592#endif
1593#if defined(MBEDTLS_CIPHER_MODE_XTS)
1594 NULL,
1595#endif
1596#if defined(MBEDTLS_CIPHER_MODE_STREAM)
1597 NULL,
1598#endif
1599 des3_set2key_enc_wrap,
1600 des3_set2key_dec_wrap,
1601 des3_ctx_alloc,
1602 des3_ctx_free
1603};
1604
1605static const mbedtls_cipher_info_t des_ede_ecb_info = {
1606 MBEDTLS_CIPHER_DES_EDE_ECB,
1607 MBEDTLS_MODE_ECB,
1608 MBEDTLS_KEY_LENGTH_DES_EDE,
1609 "DES-EDE-ECB",
1610 8,
1611 0,
1612 8,
1613 &des_ede_info
1614};
1615
1616#if defined(MBEDTLS_CIPHER_MODE_CBC)
1617static const mbedtls_cipher_info_t des_ede_cbc_info = {
1618 MBEDTLS_CIPHER_DES_EDE_CBC,
1619 MBEDTLS_MODE_CBC,
1620 MBEDTLS_KEY_LENGTH_DES_EDE,
1621 "DES-EDE-CBC",
1622 8,
1623 0,
1624 8,
1625 &des_ede_info
1626};
1627#endif /* MBEDTLS_CIPHER_MODE_CBC */
1628
1629static const mbedtls_cipher_base_t des_ede3_info = {
1630 MBEDTLS_CIPHER_ID_3DES,
1631 des3_crypt_ecb_wrap,
1632#if defined(MBEDTLS_CIPHER_MODE_CBC)
1633 des3_crypt_cbc_wrap,
1634#endif
1635#if defined(MBEDTLS_CIPHER_MODE_CFB)
1636 NULL,
1637#endif
1638#if defined(MBEDTLS_CIPHER_MODE_OFB)
1639 NULL,
1640#endif
1641#if defined(MBEDTLS_CIPHER_MODE_CTR)
1642 NULL,
1643#endif
1644#if defined(MBEDTLS_CIPHER_MODE_XTS)
1645 NULL,
1646#endif
1647#if defined(MBEDTLS_CIPHER_MODE_STREAM)
1648 NULL,
1649#endif
1650 des3_set3key_enc_wrap,
1651 des3_set3key_dec_wrap,
1652 des3_ctx_alloc,
1653 des3_ctx_free
1654};
1655
1656static const mbedtls_cipher_info_t des_ede3_ecb_info = {
1657 MBEDTLS_CIPHER_DES_EDE3_ECB,
1658 MBEDTLS_MODE_ECB,
1659 MBEDTLS_KEY_LENGTH_DES_EDE3,
1660 "DES-EDE3-ECB",
1661 8,
1662 0,
1663 8,
1664 &des_ede3_info
1665};
1666#if defined(MBEDTLS_CIPHER_MODE_CBC)
1667static const mbedtls_cipher_info_t des_ede3_cbc_info = {
1668 MBEDTLS_CIPHER_DES_EDE3_CBC,
1669 MBEDTLS_MODE_CBC,
1670 MBEDTLS_KEY_LENGTH_DES_EDE3,
1671 "DES-EDE3-CBC",
1672 8,
1673 0,
1674 8,
1675 &des_ede3_info
1676};
1677#endif /* MBEDTLS_CIPHER_MODE_CBC */
1678#endif /* MBEDTLS_DES_C */
1679
1680#if defined(MBEDTLS_BLOWFISH_C)
1681
1682static int blowfish_crypt_ecb_wrap( void *ctx, mbedtls_operation_t operation,
1683 const unsigned char *input, unsigned char *output )
1684{
1685 return mbedtls_blowfish_crypt_ecb( (mbedtls_blowfish_context *) ctx, operation, input,
1686 output );
1687}
1688
1689#if defined(MBEDTLS_CIPHER_MODE_CBC)
1690static int blowfish_crypt_cbc_wrap( void *ctx, mbedtls_operation_t operation,
1691 size_t length, unsigned char *iv, const unsigned char *input,
1692 unsigned char *output )
1693{
1694 return mbedtls_blowfish_crypt_cbc( (mbedtls_blowfish_context *) ctx, operation, length, iv,
1695 input, output );
1696}
1697#endif /* MBEDTLS_CIPHER_MODE_CBC */
1698
1699#if defined(MBEDTLS_CIPHER_MODE_CFB)
1700static int blowfish_crypt_cfb64_wrap( void *ctx, mbedtls_operation_t operation,
1701 size_t length, size_t *iv_off, unsigned char *iv,
1702 const unsigned char *input, unsigned char *output )
1703{
1704 return mbedtls_blowfish_crypt_cfb64( (mbedtls_blowfish_context *) ctx, operation, length,
1705 iv_off, iv, input, output );
1706}
1707#endif /* MBEDTLS_CIPHER_MODE_CFB */
1708
1709#if defined(MBEDTLS_CIPHER_MODE_CTR)
1710static int blowfish_crypt_ctr_wrap( void *ctx, size_t length, size_t *nc_off,
1711 unsigned char *nonce_counter, unsigned char *stream_block,
1712 const unsigned char *input, unsigned char *output )
1713{
1714 return mbedtls_blowfish_crypt_ctr( (mbedtls_blowfish_context *) ctx, length, nc_off,
1715 nonce_counter, stream_block, input, output );
1716}
1717#endif /* MBEDTLS_CIPHER_MODE_CTR */
1718
1719static int blowfish_setkey_wrap( void *ctx, const unsigned char *key,
1720 unsigned int key_bitlen )
1721{
1722 return mbedtls_blowfish_setkey( (mbedtls_blowfish_context *) ctx, key, key_bitlen );
1723}
1724
1725static void * blowfish_ctx_alloc( void )
1726{
1727 mbedtls_blowfish_context *ctx;
1728 ctx = mbedtls_calloc( 1, sizeof( mbedtls_blowfish_context ) );
1729
1730 if( ctx == NULL )
1731 return( NULL );
1732
1733 mbedtls_blowfish_init( ctx );
1734
1735 return( ctx );
1736}
1737
1738static void blowfish_ctx_free( void *ctx )
1739{
1740 mbedtls_blowfish_free( (mbedtls_blowfish_context *) ctx );
1741 mbedtls_free( ctx );
1742}
1743
1744static const mbedtls_cipher_base_t blowfish_info = {
1745 MBEDTLS_CIPHER_ID_BLOWFISH,
1746 blowfish_crypt_ecb_wrap,
1747#if defined(MBEDTLS_CIPHER_MODE_CBC)
1748 blowfish_crypt_cbc_wrap,
1749#endif
1750#if defined(MBEDTLS_CIPHER_MODE_CFB)
1751 blowfish_crypt_cfb64_wrap,
1752#endif
1753#if defined(MBEDTLS_CIPHER_MODE_OFB)
1754 NULL,
1755#endif
1756#if defined(MBEDTLS_CIPHER_MODE_CTR)
1757 blowfish_crypt_ctr_wrap,
1758#endif
1759#if defined(MBEDTLS_CIPHER_MODE_XTS)
1760 NULL,
1761#endif
1762#if defined(MBEDTLS_CIPHER_MODE_STREAM)
1763 NULL,
1764#endif
1765 blowfish_setkey_wrap,
1766 blowfish_setkey_wrap,
1767 blowfish_ctx_alloc,
1768 blowfish_ctx_free
1769};
1770
1771static const mbedtls_cipher_info_t blowfish_ecb_info = {
1772 MBEDTLS_CIPHER_BLOWFISH_ECB,
1773 MBEDTLS_MODE_ECB,
1774 128,
1775 "BLOWFISH-ECB",
1776 8,
1777 MBEDTLS_CIPHER_VARIABLE_KEY_LEN,
1778 8,
1779 &blowfish_info
1780};
1781
1782#if defined(MBEDTLS_CIPHER_MODE_CBC)
1783static const mbedtls_cipher_info_t blowfish_cbc_info = {
1784 MBEDTLS_CIPHER_BLOWFISH_CBC,
1785 MBEDTLS_MODE_CBC,
1786 128,
1787 "BLOWFISH-CBC",
1788 8,
1789 MBEDTLS_CIPHER_VARIABLE_KEY_LEN,
1790 8,
1791 &blowfish_info
1792};
1793#endif /* MBEDTLS_CIPHER_MODE_CBC */
1794
1795#if defined(MBEDTLS_CIPHER_MODE_CFB)
1796static const mbedtls_cipher_info_t blowfish_cfb64_info = {
1797 MBEDTLS_CIPHER_BLOWFISH_CFB64,
1798 MBEDTLS_MODE_CFB,
1799 128,
1800 "BLOWFISH-CFB64",
1801 8,
1802 MBEDTLS_CIPHER_VARIABLE_KEY_LEN,
1803 8,
1804 &blowfish_info
1805};
1806#endif /* MBEDTLS_CIPHER_MODE_CFB */
1807
1808#if defined(MBEDTLS_CIPHER_MODE_CTR)
1809static const mbedtls_cipher_info_t blowfish_ctr_info = {
1810 MBEDTLS_CIPHER_BLOWFISH_CTR,
1811 MBEDTLS_MODE_CTR,
1812 128,
1813 "BLOWFISH-CTR",
1814 8,
1815 MBEDTLS_CIPHER_VARIABLE_KEY_LEN,
1816 8,
1817 &blowfish_info
1818};
1819#endif /* MBEDTLS_CIPHER_MODE_CTR */
1820#endif /* MBEDTLS_BLOWFISH_C */
1821
1822#if defined(MBEDTLS_ARC4_C)
1823static int arc4_crypt_stream_wrap( void *ctx, size_t length,
1824 const unsigned char *input,
1825 unsigned char *output )
1826{
1827 return( mbedtls_arc4_crypt( (mbedtls_arc4_context *) ctx, length, input, output ) );
1828}
1829
1830static int arc4_setkey_wrap( void *ctx, const unsigned char *key,
1831 unsigned int key_bitlen )
1832{
1833 /* we get key_bitlen in bits, arc4 expects it in bytes */
1834 if( key_bitlen % 8 != 0 )
1835 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
1836
1837 mbedtls_arc4_setup( (mbedtls_arc4_context *) ctx, key, key_bitlen / 8 );
1838 return( 0 );
1839}
1840
1841static void * arc4_ctx_alloc( void )
1842{
1843 mbedtls_arc4_context *ctx;
1844 ctx = mbedtls_calloc( 1, sizeof( mbedtls_arc4_context ) );
1845
1846 if( ctx == NULL )
1847 return( NULL );
1848
1849 mbedtls_arc4_init( ctx );
1850
1851 return( ctx );
1852}
1853
1854static void arc4_ctx_free( void *ctx )
1855{
1856 mbedtls_arc4_free( (mbedtls_arc4_context *) ctx );
1857 mbedtls_free( ctx );
1858}
1859
1860static const mbedtls_cipher_base_t arc4_base_info = {
1861 MBEDTLS_CIPHER_ID_ARC4,
1862 NULL,
1863#if defined(MBEDTLS_CIPHER_MODE_CBC)
1864 NULL,
1865#endif
1866#if defined(MBEDTLS_CIPHER_MODE_CFB)
1867 NULL,
1868#endif
1869#if defined(MBEDTLS_CIPHER_MODE_OFB)
1870 NULL,
1871#endif
1872#if defined(MBEDTLS_CIPHER_MODE_CTR)
1873 NULL,
1874#endif
1875#if defined(MBEDTLS_CIPHER_MODE_XTS)
1876 NULL,
1877#endif
1878#if defined(MBEDTLS_CIPHER_MODE_STREAM)
1879 arc4_crypt_stream_wrap,
1880#endif
1881 arc4_setkey_wrap,
1882 arc4_setkey_wrap,
1883 arc4_ctx_alloc,
1884 arc4_ctx_free
1885};
1886
1887static const mbedtls_cipher_info_t arc4_128_info = {
1888 MBEDTLS_CIPHER_ARC4_128,
1889 MBEDTLS_MODE_STREAM,
1890 128,
1891 "ARC4-128",
1892 0,
1893 0,
1894 1,
1895 &arc4_base_info
1896};
1897#endif /* MBEDTLS_ARC4_C */
1898
1899#if defined(MBEDTLS_CHACHA20_C)
1900
1901static int chacha20_setkey_wrap( void *ctx, const unsigned char *key,
1902 unsigned int key_bitlen )
1903{
1904 if( key_bitlen != 256U )
1905 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
1906
1907 if ( 0 != mbedtls_chacha20_setkey( (mbedtls_chacha20_context*)ctx, key ) )
1908 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
1909
1910 return( 0 );
1911}
1912
1913static int chacha20_stream_wrap( void *ctx, size_t length,
1914 const unsigned char *input,
1915 unsigned char *output )
1916{
1917 int ret;
1918
1919 ret = mbedtls_chacha20_update( ctx, length, input, output );
1920 if( ret == MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA )
1921 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
1922
1923 return( ret );
1924}
1925
1926static void * chacha20_ctx_alloc( void )
1927{
1928 mbedtls_chacha20_context *ctx;
1929 ctx = mbedtls_calloc( 1, sizeof( mbedtls_chacha20_context ) );
1930
1931 if( ctx == NULL )
1932 return( NULL );
1933
1934 mbedtls_chacha20_init( ctx );
1935
1936 return( ctx );
1937}
1938
1939static void chacha20_ctx_free( void *ctx )
1940{
1941 mbedtls_chacha20_free( (mbedtls_chacha20_context *) ctx );
1942 mbedtls_free( ctx );
1943}
1944
1945static const mbedtls_cipher_base_t chacha20_base_info = {
1946 MBEDTLS_CIPHER_ID_CHACHA20,
1947 NULL,
1948#if defined(MBEDTLS_CIPHER_MODE_CBC)
1949 NULL,
1950#endif
1951#if defined(MBEDTLS_CIPHER_MODE_CFB)
1952 NULL,
1953#endif
1954#if defined(MBEDTLS_CIPHER_MODE_OFB)
1955 NULL,
1956#endif
1957#if defined(MBEDTLS_CIPHER_MODE_CTR)
1958 NULL,
1959#endif
1960#if defined(MBEDTLS_CIPHER_MODE_XTS)
1961 NULL,
1962#endif
1963#if defined(MBEDTLS_CIPHER_MODE_STREAM)
1964 chacha20_stream_wrap,
1965#endif
1966 chacha20_setkey_wrap,
1967 chacha20_setkey_wrap,
1968 chacha20_ctx_alloc,
1969 chacha20_ctx_free
1970};
1971static const mbedtls_cipher_info_t chacha20_info = {
1972 MBEDTLS_CIPHER_CHACHA20,
1973 MBEDTLS_MODE_STREAM,
1974 256,
1975 "CHACHA20",
1976 12,
1977 0,
1978 1,
1979 &chacha20_base_info
1980};
1981#endif /* MBEDTLS_CHACHA20_C */
1982
1983#if defined(MBEDTLS_CHACHAPOLY_C)
1984
1985static int chachapoly_setkey_wrap( void *ctx,
1986 const unsigned char *key,
1987 unsigned int key_bitlen )
1988{
1989 if( key_bitlen != 256U )
1990 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
1991
1992 if ( 0 != mbedtls_chachapoly_setkey( (mbedtls_chachapoly_context*)ctx, key ) )
1993 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
1994
1995 return( 0 );
1996}
1997
1998static void * chachapoly_ctx_alloc( void )
1999{
2000 mbedtls_chachapoly_context *ctx;
2001 ctx = mbedtls_calloc( 1, sizeof( mbedtls_chachapoly_context ) );
2002
2003 if( ctx == NULL )
2004 return( NULL );
2005
2006 mbedtls_chachapoly_init( ctx );
2007
2008 return( ctx );
2009}
2010
2011static void chachapoly_ctx_free( void *ctx )
2012{
2013 mbedtls_chachapoly_free( (mbedtls_chachapoly_context *) ctx );
2014 mbedtls_free( ctx );
2015}
2016
2017static const mbedtls_cipher_base_t chachapoly_base_info = {
2018 MBEDTLS_CIPHER_ID_CHACHA20,
2019 NULL,
2020#if defined(MBEDTLS_CIPHER_MODE_CBC)
2021 NULL,
2022#endif
2023#if defined(MBEDTLS_CIPHER_MODE_CFB)
2024 NULL,
2025#endif
2026#if defined(MBEDTLS_CIPHER_MODE_OFB)
2027 NULL,
2028#endif
2029#if defined(MBEDTLS_CIPHER_MODE_CTR)
2030 NULL,
2031#endif
2032#if defined(MBEDTLS_CIPHER_MODE_XTS)
2033 NULL,
2034#endif
2035#if defined(MBEDTLS_CIPHER_MODE_STREAM)
2036 NULL,
2037#endif
2038 chachapoly_setkey_wrap,
2039 chachapoly_setkey_wrap,
2040 chachapoly_ctx_alloc,
2041 chachapoly_ctx_free
2042};
2043static const mbedtls_cipher_info_t chachapoly_info = {
2044 MBEDTLS_CIPHER_CHACHA20_POLY1305,
2045 MBEDTLS_MODE_CHACHAPOLY,
2046 256,
2047 "CHACHA20-POLY1305",
2048 12,
2049 0,
2050 1,
2051 &chachapoly_base_info
2052};
2053#endif /* MBEDTLS_CHACHAPOLY_C */
2054
2055#if defined(MBEDTLS_CIPHER_NULL_CIPHER)
2056static int null_crypt_stream( void *ctx, size_t length,
2057 const unsigned char *input,
2058 unsigned char *output )
2059{
2060 ((void) ctx);
2061 memmove( output, input, length );
2062 return( 0 );
2063}
2064
2065static int null_setkey( void *ctx, const unsigned char *key,
2066 unsigned int key_bitlen )
2067{
2068 ((void) ctx);
2069 ((void) key);
2070 ((void) key_bitlen);
2071
2072 return( 0 );
2073}
2074
2075static void * null_ctx_alloc( void )
2076{
2077 return( (void *) 1 );
2078}
2079
2080static void null_ctx_free( void *ctx )
2081{
2082 ((void) ctx);
2083}
2084
2085static const mbedtls_cipher_base_t null_base_info = {
2086 MBEDTLS_CIPHER_ID_NULL,
2087 NULL,
2088#if defined(MBEDTLS_CIPHER_MODE_CBC)
2089 NULL,
2090#endif
2091#if defined(MBEDTLS_CIPHER_MODE_CFB)
2092 NULL,
2093#endif
2094#if defined(MBEDTLS_CIPHER_MODE_OFB)
2095 NULL,
2096#endif
2097#if defined(MBEDTLS_CIPHER_MODE_CTR)
2098 NULL,
2099#endif
2100#if defined(MBEDTLS_CIPHER_MODE_XTS)
2101 NULL,
2102#endif
2103#if defined(MBEDTLS_CIPHER_MODE_STREAM)
2104 null_crypt_stream,
2105#endif
2106 null_setkey,
2107 null_setkey,
2108 null_ctx_alloc,
2109 null_ctx_free
2110};
2111
2112static const mbedtls_cipher_info_t null_cipher_info = {
2113 MBEDTLS_CIPHER_NULL,
2114 MBEDTLS_MODE_STREAM,
2115 0,
2116 "NULL",
2117 0,
2118 0,
2119 1,
2120 &null_base_info
2121};
2122#endif /* defined(MBEDTLS_CIPHER_NULL_CIPHER) */
2123
2124const mbedtls_cipher_definition_t mbedtls_cipher_definitions[] =
2125{
2126#if defined(MBEDTLS_AES_C)
2127 { MBEDTLS_CIPHER_AES_128_ECB, &aes_128_ecb_info },
2128 { MBEDTLS_CIPHER_AES_192_ECB, &aes_192_ecb_info },
2129 { MBEDTLS_CIPHER_AES_256_ECB, &aes_256_ecb_info },
2130#if defined(MBEDTLS_CIPHER_MODE_CBC)
2131 { MBEDTLS_CIPHER_AES_128_CBC, &aes_128_cbc_info },
2132 { MBEDTLS_CIPHER_AES_192_CBC, &aes_192_cbc_info },
2133 { MBEDTLS_CIPHER_AES_256_CBC, &aes_256_cbc_info },
2134#endif
2135#if defined(MBEDTLS_CIPHER_MODE_CFB)
2136 { MBEDTLS_CIPHER_AES_128_CFB128, &aes_128_cfb128_info },
2137 { MBEDTLS_CIPHER_AES_192_CFB128, &aes_192_cfb128_info },
2138 { MBEDTLS_CIPHER_AES_256_CFB128, &aes_256_cfb128_info },
2139#endif
2140#if defined(MBEDTLS_CIPHER_MODE_OFB)
2141 { MBEDTLS_CIPHER_AES_128_OFB, &aes_128_ofb_info },
2142 { MBEDTLS_CIPHER_AES_192_OFB, &aes_192_ofb_info },
2143 { MBEDTLS_CIPHER_AES_256_OFB, &aes_256_ofb_info },
2144#endif
2145#if defined(MBEDTLS_CIPHER_MODE_CTR)
2146 { MBEDTLS_CIPHER_AES_128_CTR, &aes_128_ctr_info },
2147 { MBEDTLS_CIPHER_AES_192_CTR, &aes_192_ctr_info },
2148 { MBEDTLS_CIPHER_AES_256_CTR, &aes_256_ctr_info },
2149#endif
2150#if defined(MBEDTLS_CIPHER_MODE_XTS)
2151 { MBEDTLS_CIPHER_AES_128_XTS, &aes_128_xts_info },
2152 { MBEDTLS_CIPHER_AES_256_XTS, &aes_256_xts_info },
2153#endif
2154#if defined(MBEDTLS_GCM_C)
2155 { MBEDTLS_CIPHER_AES_128_GCM, &aes_128_gcm_info },
2156 { MBEDTLS_CIPHER_AES_192_GCM, &aes_192_gcm_info },
2157 { MBEDTLS_CIPHER_AES_256_GCM, &aes_256_gcm_info },
2158#endif
2159#if defined(MBEDTLS_CCM_C)
2160 { MBEDTLS_CIPHER_AES_128_CCM, &aes_128_ccm_info },
2161 { MBEDTLS_CIPHER_AES_192_CCM, &aes_192_ccm_info },
2162 { MBEDTLS_CIPHER_AES_256_CCM, &aes_256_ccm_info },
2163#endif
2164#endif /* MBEDTLS_AES_C */
2165
2166#if defined(MBEDTLS_ARC4_C)
2167 { MBEDTLS_CIPHER_ARC4_128, &arc4_128_info },
2168#endif
2169
2170#if defined(MBEDTLS_BLOWFISH_C)
2171 { MBEDTLS_CIPHER_BLOWFISH_ECB, &blowfish_ecb_info },
2172#if defined(MBEDTLS_CIPHER_MODE_CBC)
2173 { MBEDTLS_CIPHER_BLOWFISH_CBC, &blowfish_cbc_info },
2174#endif
2175#if defined(MBEDTLS_CIPHER_MODE_CFB)
2176 { MBEDTLS_CIPHER_BLOWFISH_CFB64, &blowfish_cfb64_info },
2177#endif
2178#if defined(MBEDTLS_CIPHER_MODE_CTR)
2179 { MBEDTLS_CIPHER_BLOWFISH_CTR, &blowfish_ctr_info },
2180#endif
2181#endif /* MBEDTLS_BLOWFISH_C */
2182
2183#if defined(MBEDTLS_CAMELLIA_C)
2184 { MBEDTLS_CIPHER_CAMELLIA_128_ECB, &camellia_128_ecb_info },
2185 { MBEDTLS_CIPHER_CAMELLIA_192_ECB, &camellia_192_ecb_info },
2186 { MBEDTLS_CIPHER_CAMELLIA_256_ECB, &camellia_256_ecb_info },
2187#if defined(MBEDTLS_CIPHER_MODE_CBC)
2188 { MBEDTLS_CIPHER_CAMELLIA_128_CBC, &camellia_128_cbc_info },
2189 { MBEDTLS_CIPHER_CAMELLIA_192_CBC, &camellia_192_cbc_info },
2190 { MBEDTLS_CIPHER_CAMELLIA_256_CBC, &camellia_256_cbc_info },
2191#endif
2192#if defined(MBEDTLS_CIPHER_MODE_CFB)
2193 { MBEDTLS_CIPHER_CAMELLIA_128_CFB128, &camellia_128_cfb128_info },
2194 { MBEDTLS_CIPHER_CAMELLIA_192_CFB128, &camellia_192_cfb128_info },
2195 { MBEDTLS_CIPHER_CAMELLIA_256_CFB128, &camellia_256_cfb128_info },
2196#endif
2197#if defined(MBEDTLS_CIPHER_MODE_CTR)
2198 { MBEDTLS_CIPHER_CAMELLIA_128_CTR, &camellia_128_ctr_info },
2199 { MBEDTLS_CIPHER_CAMELLIA_192_CTR, &camellia_192_ctr_info },
2200 { MBEDTLS_CIPHER_CAMELLIA_256_CTR, &camellia_256_ctr_info },
2201#endif
2202#if defined(MBEDTLS_GCM_C)
2203 { MBEDTLS_CIPHER_CAMELLIA_128_GCM, &camellia_128_gcm_info },
2204 { MBEDTLS_CIPHER_CAMELLIA_192_GCM, &camellia_192_gcm_info },
2205 { MBEDTLS_CIPHER_CAMELLIA_256_GCM, &camellia_256_gcm_info },
2206#endif
2207#if defined(MBEDTLS_CCM_C)
2208 { MBEDTLS_CIPHER_CAMELLIA_128_CCM, &camellia_128_ccm_info },
2209 { MBEDTLS_CIPHER_CAMELLIA_192_CCM, &camellia_192_ccm_info },
2210 { MBEDTLS_CIPHER_CAMELLIA_256_CCM, &camellia_256_ccm_info },
2211#endif
2212#endif /* MBEDTLS_CAMELLIA_C */
2213
2214#if defined(MBEDTLS_ARIA_C)
2215 { MBEDTLS_CIPHER_ARIA_128_ECB, &aria_128_ecb_info },
2216 { MBEDTLS_CIPHER_ARIA_192_ECB, &aria_192_ecb_info },
2217 { MBEDTLS_CIPHER_ARIA_256_ECB, &aria_256_ecb_info },
2218#if defined(MBEDTLS_CIPHER_MODE_CBC)
2219 { MBEDTLS_CIPHER_ARIA_128_CBC, &aria_128_cbc_info },
2220 { MBEDTLS_CIPHER_ARIA_192_CBC, &aria_192_cbc_info },
2221 { MBEDTLS_CIPHER_ARIA_256_CBC, &aria_256_cbc_info },
2222#endif
2223#if defined(MBEDTLS_CIPHER_MODE_CFB)
2224 { MBEDTLS_CIPHER_ARIA_128_CFB128, &aria_128_cfb128_info },
2225 { MBEDTLS_CIPHER_ARIA_192_CFB128, &aria_192_cfb128_info },
2226 { MBEDTLS_CIPHER_ARIA_256_CFB128, &aria_256_cfb128_info },
2227#endif
2228#if defined(MBEDTLS_CIPHER_MODE_CTR)
2229 { MBEDTLS_CIPHER_ARIA_128_CTR, &aria_128_ctr_info },
2230 { MBEDTLS_CIPHER_ARIA_192_CTR, &aria_192_ctr_info },
2231 { MBEDTLS_CIPHER_ARIA_256_CTR, &aria_256_ctr_info },
2232#endif
2233#if defined(MBEDTLS_GCM_C)
2234 { MBEDTLS_CIPHER_ARIA_128_GCM, &aria_128_gcm_info },
2235 { MBEDTLS_CIPHER_ARIA_192_GCM, &aria_192_gcm_info },
2236 { MBEDTLS_CIPHER_ARIA_256_GCM, &aria_256_gcm_info },
2237#endif
2238#if defined(MBEDTLS_CCM_C)
2239 { MBEDTLS_CIPHER_ARIA_128_CCM, &aria_128_ccm_info },
2240 { MBEDTLS_CIPHER_ARIA_192_CCM, &aria_192_ccm_info },
2241 { MBEDTLS_CIPHER_ARIA_256_CCM, &aria_256_ccm_info },
2242#endif
2243#endif /* MBEDTLS_ARIA_C */
2244
2245#if defined(MBEDTLS_DES_C)
2246 { MBEDTLS_CIPHER_DES_ECB, &des_ecb_info },
2247 { MBEDTLS_CIPHER_DES_EDE_ECB, &des_ede_ecb_info },
2248 { MBEDTLS_CIPHER_DES_EDE3_ECB, &des_ede3_ecb_info },
2249#if defined(MBEDTLS_CIPHER_MODE_CBC)
2250 { MBEDTLS_CIPHER_DES_CBC, &des_cbc_info },
2251 { MBEDTLS_CIPHER_DES_EDE_CBC, &des_ede_cbc_info },
2252 { MBEDTLS_CIPHER_DES_EDE3_CBC, &des_ede3_cbc_info },
2253#endif
2254#endif /* MBEDTLS_DES_C */
2255
2256#if defined(MBEDTLS_CHACHA20_C)
2257 { MBEDTLS_CIPHER_CHACHA20, &chacha20_info },
2258#endif
2259
2260#if defined(MBEDTLS_CHACHAPOLY_C)
2261 { MBEDTLS_CIPHER_CHACHA20_POLY1305, &chachapoly_info },
2262#endif
2263
2264#if defined(MBEDTLS_CIPHER_NULL_CIPHER)
2265 { MBEDTLS_CIPHER_NULL, &null_cipher_info },
2266#endif /* MBEDTLS_CIPHER_NULL_CIPHER */
2267
2268 { MBEDTLS_CIPHER_NONE, NULL }
2269};
2270
2271#define NUM_CIPHERS sizeof mbedtls_cipher_definitions / sizeof mbedtls_cipher_definitions[0]
2272int mbedtls_cipher_supported[NUM_CIPHERS];
2273
2274#endif /* MBEDTLS_CIPHER_C */
diff --git a/source/mbedtls/lib/cmac.c b/source/mbedtls/lib/cmac.c
deleted file mode 100644
index db4a71d..0000000
--- a/source/mbedtls/lib/cmac.c
+++ /dev/null
@@ -1,1080 +0,0 @@
1/**
2 * \file cmac.c
3 *
4 * \brief NIST SP800-38B compliant CMAC implementation for AES and 3DES
5 *
6 * Copyright (C) 2006-2016, ARM Limited, All Rights Reserved
7 * SPDX-License-Identifier: GPL-2.0
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License along
20 * with this program; if not, write to the Free Software Foundation, Inc.,
21 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
22 *
23 * This file is part of mbed TLS (https://tls.mbed.org)
24 */
25
26/*
27 * References:
28 *
29 * - NIST SP 800-38B Recommendation for Block Cipher Modes of Operation: The
30 * CMAC Mode for Authentication
31 * http://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-38b.pdf
32 *
33 * - RFC 4493 - The AES-CMAC Algorithm
34 * https://tools.ietf.org/html/rfc4493
35 *
36 * - RFC 4615 - The Advanced Encryption Standard-Cipher-based Message
37 * Authentication Code-Pseudo-Random Function-128 (AES-CMAC-PRF-128)
38 * Algorithm for the Internet Key Exchange Protocol (IKE)
39 * https://tools.ietf.org/html/rfc4615
40 *
41 * Additional test vectors: ISO/IEC 9797-1
42 *
43 */
44
45#if !defined(MBEDTLS_CONFIG_FILE)
46#include "mbedtls/config.h"
47#else
48#include MBEDTLS_CONFIG_FILE
49#endif
50
51#if defined(MBEDTLS_CMAC_C)
52
53#include "mbedtls/cmac.h"
54#include "mbedtls/platform_util.h"
55
56#include <string.h>
57
58
59#if defined(MBEDTLS_PLATFORM_C)
60#include "mbedtls/platform.h"
61#else
62#include <stdlib.h>
63#define mbedtls_calloc calloc
64#define mbedtls_free free
65#if defined(MBEDTLS_SELF_TEST)
66#include <stdio.h>
67#define mbedtls_printf printf
68#endif /* MBEDTLS_SELF_TEST */
69#endif /* MBEDTLS_PLATFORM_C */
70
71#if !defined(MBEDTLS_CMAC_ALT) || defined(MBEDTLS_SELF_TEST)
72
73/*
74 * Multiplication by u in the Galois field of GF(2^n)
75 *
76 * As explained in NIST SP 800-38B, this can be computed:
77 *
78 * If MSB(p) = 0, then p = (p << 1)
79 * If MSB(p) = 1, then p = (p << 1) ^ R_n
80 * with R_64 = 0x1B and R_128 = 0x87
81 *
82 * Input and output MUST NOT point to the same buffer
83 * Block size must be 8 bytes or 16 bytes - the block sizes for DES and AES.
84 */
85static int cmac_multiply_by_u( unsigned char *output,
86 const unsigned char *input,
87 size_t blocksize )
88{
89 const unsigned char R_128 = 0x87;
90 const unsigned char R_64 = 0x1B;
91 unsigned char R_n, mask;
92 unsigned char overflow = 0x00;
93 int i;
94
95 if( blocksize == MBEDTLS_AES_BLOCK_SIZE )
96 {
97 R_n = R_128;
98 }
99 else if( blocksize == MBEDTLS_DES3_BLOCK_SIZE )
100 {
101 R_n = R_64;
102 }
103 else
104 {
105 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
106 }
107
108 for( i = (int)blocksize - 1; i >= 0; i-- )
109 {
110 output[i] = input[i] << 1 | overflow;
111 overflow = input[i] >> 7;
112 }
113
114 /* mask = ( input[0] >> 7 ) ? 0xff : 0x00
115 * using bit operations to avoid branches */
116
117 /* MSVC has a warning about unary minus on unsigned, but this is
118 * well-defined and precisely what we want to do here */
119#if defined(_MSC_VER)
120#pragma warning( push )
121#pragma warning( disable : 4146 )
122#endif
123 mask = - ( input[0] >> 7 );
124#if defined(_MSC_VER)
125#pragma warning( pop )
126#endif
127
128 output[ blocksize - 1 ] ^= R_n & mask;
129
130 return( 0 );
131}
132
133/*
134 * Generate subkeys
135 *
136 * - as specified by RFC 4493, section 2.3 Subkey Generation Algorithm
137 */
138static int cmac_generate_subkeys( mbedtls_cipher_context_t *ctx,
139 unsigned char* K1, unsigned char* K2 )
140{
141 int ret;
142 unsigned char L[MBEDTLS_CIPHER_BLKSIZE_MAX];
143 size_t olen, block_size;
144
145 mbedtls_platform_zeroize( L, sizeof( L ) );
146
147 block_size = ctx->cipher_info->block_size;
148
149 /* Calculate Ek(0) */
150 if( ( ret = mbedtls_cipher_update( ctx, L, block_size, L, &olen ) ) != 0 )
151 goto exit;
152
153 /*
154 * Generate K1 and K2
155 */
156 if( ( ret = cmac_multiply_by_u( K1, L , block_size ) ) != 0 )
157 goto exit;
158
159 if( ( ret = cmac_multiply_by_u( K2, K1 , block_size ) ) != 0 )
160 goto exit;
161
162exit:
163 mbedtls_platform_zeroize( L, sizeof( L ) );
164
165 return( ret );
166}
167#endif /* !defined(MBEDTLS_CMAC_ALT) || defined(MBEDTLS_SELF_TEST) */
168
169#if !defined(MBEDTLS_CMAC_ALT)
170static void cmac_xor_block( unsigned char *output, const unsigned char *input1,
171 const unsigned char *input2,
172 const size_t block_size )
173{
174 size_t idx;
175
176 for( idx = 0; idx < block_size; idx++ )
177 output[ idx ] = input1[ idx ] ^ input2[ idx ];
178}
179
180/*
181 * Create padded last block from (partial) last block.
182 *
183 * We can't use the padding option from the cipher layer, as it only works for
184 * CBC and we use ECB mode, and anyway we need to XOR K1 or K2 in addition.
185 */
186static void cmac_pad( unsigned char padded_block[MBEDTLS_CIPHER_BLKSIZE_MAX],
187 size_t padded_block_len,
188 const unsigned char *last_block,
189 size_t last_block_len )
190{
191 size_t j;
192
193 for( j = 0; j < padded_block_len; j++ )
194 {
195 if( j < last_block_len )
196 padded_block[j] = last_block[j];
197 else if( j == last_block_len )
198 padded_block[j] = 0x80;
199 else
200 padded_block[j] = 0x00;
201 }
202}
203
204int mbedtls_cipher_cmac_starts( mbedtls_cipher_context_t *ctx,
205 const unsigned char *key, size_t keybits )
206{
207 mbedtls_cipher_type_t type;
208 mbedtls_cmac_context_t *cmac_ctx;
209 int retval;
210
211 if( ctx == NULL || ctx->cipher_info == NULL || key == NULL )
212 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
213
214 if( ( retval = mbedtls_cipher_setkey( ctx, key, (int)keybits,
215 MBEDTLS_ENCRYPT ) ) != 0 )
216 return( retval );
217
218 type = ctx->cipher_info->type;
219
220 switch( type )
221 {
222 case MBEDTLS_CIPHER_AES_128_ECB:
223 case MBEDTLS_CIPHER_AES_192_ECB:
224 case MBEDTLS_CIPHER_AES_256_ECB:
225 case MBEDTLS_CIPHER_DES_EDE3_ECB:
226 break;
227 default:
228 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
229 }
230
231 /* Allocated and initialise in the cipher context memory for the CMAC
232 * context */
233 cmac_ctx = mbedtls_calloc( 1, sizeof( mbedtls_cmac_context_t ) );
234 if( cmac_ctx == NULL )
235 return( MBEDTLS_ERR_CIPHER_ALLOC_FAILED );
236
237 ctx->cmac_ctx = cmac_ctx;
238
239 mbedtls_platform_zeroize( cmac_ctx->state, sizeof( cmac_ctx->state ) );
240
241 return 0;
242}
243
244int mbedtls_cipher_cmac_update( mbedtls_cipher_context_t *ctx,
245 const unsigned char *input, size_t ilen )
246{
247 mbedtls_cmac_context_t* cmac_ctx;
248 unsigned char *state;
249 int ret = 0;
250 size_t n, j, olen, block_size;
251
252 if( ctx == NULL || ctx->cipher_info == NULL || input == NULL ||
253 ctx->cmac_ctx == NULL )
254 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
255
256 cmac_ctx = ctx->cmac_ctx;
257 block_size = ctx->cipher_info->block_size;
258 state = ctx->cmac_ctx->state;
259
260 /* Is there data still to process from the last call, that's greater in
261 * size than a block? */
262 if( cmac_ctx->unprocessed_len > 0 &&
263 ilen > block_size - cmac_ctx->unprocessed_len )
264 {
265 memcpy( &cmac_ctx->unprocessed_block[cmac_ctx->unprocessed_len],
266 input,
267 block_size - cmac_ctx->unprocessed_len );
268
269 cmac_xor_block( state, cmac_ctx->unprocessed_block, state, block_size );
270
271 if( ( ret = mbedtls_cipher_update( ctx, state, block_size, state,
272 &olen ) ) != 0 )
273 {
274 goto exit;
275 }
276
277 input += block_size - cmac_ctx->unprocessed_len;
278 ilen -= block_size - cmac_ctx->unprocessed_len;
279 cmac_ctx->unprocessed_len = 0;
280 }
281
282 /* n is the number of blocks including any final partial block */
283 n = ( ilen + block_size - 1 ) / block_size;
284
285 /* Iterate across the input data in block sized chunks, excluding any
286 * final partial or complete block */
287 for( j = 1; j < n; j++ )
288 {
289 cmac_xor_block( state, input, state, block_size );
290
291 if( ( ret = mbedtls_cipher_update( ctx, state, block_size, state,
292 &olen ) ) != 0 )
293 goto exit;
294
295 ilen -= block_size;
296 input += block_size;
297 }
298
299 /* If there is data left over that wasn't aligned to a block */
300 if( ilen > 0 )
301 {
302 memcpy( &cmac_ctx->unprocessed_block[cmac_ctx->unprocessed_len],
303 input,
304 ilen );
305 cmac_ctx->unprocessed_len += ilen;
306 }
307
308exit:
309 return( ret );
310}
311
312int mbedtls_cipher_cmac_finish( mbedtls_cipher_context_t *ctx,
313 unsigned char *output )
314{
315 mbedtls_cmac_context_t* cmac_ctx;
316 unsigned char *state, *last_block;
317 unsigned char K1[MBEDTLS_CIPHER_BLKSIZE_MAX];
318 unsigned char K2[MBEDTLS_CIPHER_BLKSIZE_MAX];
319 unsigned char M_last[MBEDTLS_CIPHER_BLKSIZE_MAX];
320 int ret;
321 size_t olen, block_size;
322
323 if( ctx == NULL || ctx->cipher_info == NULL || ctx->cmac_ctx == NULL ||
324 output == NULL )
325 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
326
327 cmac_ctx = ctx->cmac_ctx;
328 block_size = ctx->cipher_info->block_size;
329 state = cmac_ctx->state;
330
331 mbedtls_platform_zeroize( K1, sizeof( K1 ) );
332 mbedtls_platform_zeroize( K2, sizeof( K2 ) );
333 cmac_generate_subkeys( ctx, K1, K2 );
334
335 last_block = cmac_ctx->unprocessed_block;
336
337 /* Calculate last block */
338 if( cmac_ctx->unprocessed_len < block_size )
339 {
340 cmac_pad( M_last, block_size, last_block, cmac_ctx->unprocessed_len );
341 cmac_xor_block( M_last, M_last, K2, block_size );
342 }
343 else
344 {
345 /* Last block is complete block */
346 cmac_xor_block( M_last, last_block, K1, block_size );
347 }
348
349
350 cmac_xor_block( state, M_last, state, block_size );
351 if( ( ret = mbedtls_cipher_update( ctx, state, block_size, state,
352 &olen ) ) != 0 )
353 {
354 goto exit;
355 }
356
357 memcpy( output, state, block_size );
358
359exit:
360 /* Wipe the generated keys on the stack, and any other transients to avoid
361 * side channel leakage */
362 mbedtls_platform_zeroize( K1, sizeof( K1 ) );
363 mbedtls_platform_zeroize( K2, sizeof( K2 ) );
364
365 cmac_ctx->unprocessed_len = 0;
366 mbedtls_platform_zeroize( cmac_ctx->unprocessed_block,
367 sizeof( cmac_ctx->unprocessed_block ) );
368
369 mbedtls_platform_zeroize( state, MBEDTLS_CIPHER_BLKSIZE_MAX );
370 return( ret );
371}
372
373int mbedtls_cipher_cmac_reset( mbedtls_cipher_context_t *ctx )
374{
375 mbedtls_cmac_context_t* cmac_ctx;
376
377 if( ctx == NULL || ctx->cipher_info == NULL || ctx->cmac_ctx == NULL )
378 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
379
380 cmac_ctx = ctx->cmac_ctx;
381
382 /* Reset the internal state */
383 cmac_ctx->unprocessed_len = 0;
384 mbedtls_platform_zeroize( cmac_ctx->unprocessed_block,
385 sizeof( cmac_ctx->unprocessed_block ) );
386 mbedtls_platform_zeroize( cmac_ctx->state,
387 sizeof( cmac_ctx->state ) );
388
389 return( 0 );
390}
391
392int mbedtls_cipher_cmac( const mbedtls_cipher_info_t *cipher_info,
393 const unsigned char *key, size_t keylen,
394 const unsigned char *input, size_t ilen,
395 unsigned char *output )
396{
397 mbedtls_cipher_context_t ctx;
398 int ret;
399
400 if( cipher_info == NULL || key == NULL || input == NULL || output == NULL )
401 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
402
403 mbedtls_cipher_init( &ctx );
404
405 if( ( ret = mbedtls_cipher_setup( &ctx, cipher_info ) ) != 0 )
406 goto exit;
407
408 ret = mbedtls_cipher_cmac_starts( &ctx, key, keylen );
409 if( ret != 0 )
410 goto exit;
411
412 ret = mbedtls_cipher_cmac_update( &ctx, input, ilen );
413 if( ret != 0 )
414 goto exit;
415
416 ret = mbedtls_cipher_cmac_finish( &ctx, output );
417
418exit:
419 mbedtls_cipher_free( &ctx );
420
421 return( ret );
422}
423
424#if defined(MBEDTLS_AES_C)
425/*
426 * Implementation of AES-CMAC-PRF-128 defined in RFC 4615
427 */
428int mbedtls_aes_cmac_prf_128( const unsigned char *key, size_t key_length,
429 const unsigned char *input, size_t in_len,
430 unsigned char *output )
431{
432 int ret;
433 const mbedtls_cipher_info_t *cipher_info;
434 unsigned char zero_key[MBEDTLS_AES_BLOCK_SIZE];
435 unsigned char int_key[MBEDTLS_AES_BLOCK_SIZE];
436
437 if( key == NULL || input == NULL || output == NULL )
438 return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
439
440 cipher_info = mbedtls_cipher_info_from_type( MBEDTLS_CIPHER_AES_128_ECB );
441 if( cipher_info == NULL )
442 {
443 /* Failing at this point must be due to a build issue */
444 ret = MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE;
445 goto exit;
446 }
447
448 if( key_length == MBEDTLS_AES_BLOCK_SIZE )
449 {
450 /* Use key as is */
451 memcpy( int_key, key, MBEDTLS_AES_BLOCK_SIZE );
452 }
453 else
454 {
455 memset( zero_key, 0, MBEDTLS_AES_BLOCK_SIZE );
456
457 ret = mbedtls_cipher_cmac( cipher_info, zero_key, 128, key,
458 key_length, int_key );
459 if( ret != 0 )
460 goto exit;
461 }
462
463 ret = mbedtls_cipher_cmac( cipher_info, int_key, 128, input, in_len,
464 output );
465
466exit:
467 mbedtls_platform_zeroize( int_key, sizeof( int_key ) );
468
469 return( ret );
470}
471#endif /* MBEDTLS_AES_C */
472
473#endif /* !MBEDTLS_CMAC_ALT */
474
475#if defined(MBEDTLS_SELF_TEST)
476/*
477 * CMAC test data for SP800-38B
478 * http://csrc.nist.gov/groups/ST/toolkit/documents/Examples/AES_CMAC.pdf
479 * http://csrc.nist.gov/groups/ST/toolkit/documents/Examples/TDES_CMAC.pdf
480 *
481 * AES-CMAC-PRF-128 test data from RFC 4615
482 * https://tools.ietf.org/html/rfc4615#page-4
483 */
484
485#define NB_CMAC_TESTS_PER_KEY 4
486#define NB_PRF_TESTS 3
487
488#if defined(MBEDTLS_AES_C) || defined(MBEDTLS_DES_C)
489/* All CMAC test inputs are truncated from the same 64 byte buffer. */
490static const unsigned char test_message[] = {
491 /* PT */
492 0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
493 0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a,
494 0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
495 0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51,
496 0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
497 0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef,
498 0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
499 0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10
500};
501#endif /* MBEDTLS_AES_C || MBEDTLS_DES_C */
502
503#if defined(MBEDTLS_AES_C)
504/* Truncation point of message for AES CMAC tests */
505static const unsigned int aes_message_lengths[NB_CMAC_TESTS_PER_KEY] = {
506 /* Mlen */
507 0,
508 16,
509 20,
510 64
511};
512
513/* CMAC-AES128 Test Data */
514static const unsigned char aes_128_key[16] = {
515 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
516 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c
517};
518static const unsigned char aes_128_subkeys[2][MBEDTLS_AES_BLOCK_SIZE] = {
519 {
520 /* K1 */
521 0xfb, 0xee, 0xd6, 0x18, 0x35, 0x71, 0x33, 0x66,
522 0x7c, 0x85, 0xe0, 0x8f, 0x72, 0x36, 0xa8, 0xde
523 },
524 {
525 /* K2 */
526 0xf7, 0xdd, 0xac, 0x30, 0x6a, 0xe2, 0x66, 0xcc,
527 0xf9, 0x0b, 0xc1, 0x1e, 0xe4, 0x6d, 0x51, 0x3b
528 }
529};
530static const unsigned char aes_128_expected_result[NB_CMAC_TESTS_PER_KEY][MBEDTLS_AES_BLOCK_SIZE] = {
531 {
532 /* Example #1 */
533 0xbb, 0x1d, 0x69, 0x29, 0xe9, 0x59, 0x37, 0x28,
534 0x7f, 0xa3, 0x7d, 0x12, 0x9b, 0x75, 0x67, 0x46
535 },
536 {
537 /* Example #2 */
538 0x07, 0x0a, 0x16, 0xb4, 0x6b, 0x4d, 0x41, 0x44,
539 0xf7, 0x9b, 0xdd, 0x9d, 0xd0, 0x4a, 0x28, 0x7c
540 },
541 {
542 /* Example #3 */
543 0x7d, 0x85, 0x44, 0x9e, 0xa6, 0xea, 0x19, 0xc8,
544 0x23, 0xa7, 0xbf, 0x78, 0x83, 0x7d, 0xfa, 0xde
545 },
546 {
547 /* Example #4 */
548 0x51, 0xf0, 0xbe, 0xbf, 0x7e, 0x3b, 0x9d, 0x92,
549 0xfc, 0x49, 0x74, 0x17, 0x79, 0x36, 0x3c, 0xfe
550 }
551};
552
553/* CMAC-AES192 Test Data */
554static const unsigned char aes_192_key[24] = {
555 0x8e, 0x73, 0xb0, 0xf7, 0xda, 0x0e, 0x64, 0x52,
556 0xc8, 0x10, 0xf3, 0x2b, 0x80, 0x90, 0x79, 0xe5,
557 0x62, 0xf8, 0xea, 0xd2, 0x52, 0x2c, 0x6b, 0x7b
558};
559static const unsigned char aes_192_subkeys[2][MBEDTLS_AES_BLOCK_SIZE] = {
560 {
561 /* K1 */
562 0x44, 0x8a, 0x5b, 0x1c, 0x93, 0x51, 0x4b, 0x27,
563 0x3e, 0xe6, 0x43, 0x9d, 0xd4, 0xda, 0xa2, 0x96
564 },
565 {
566 /* K2 */
567 0x89, 0x14, 0xb6, 0x39, 0x26, 0xa2, 0x96, 0x4e,
568 0x7d, 0xcc, 0x87, 0x3b, 0xa9, 0xb5, 0x45, 0x2c
569 }
570};
571static const unsigned char aes_192_expected_result[NB_CMAC_TESTS_PER_KEY][MBEDTLS_AES_BLOCK_SIZE] = {
572 {
573 /* Example #1 */
574 0xd1, 0x7d, 0xdf, 0x46, 0xad, 0xaa, 0xcd, 0xe5,
575 0x31, 0xca, 0xc4, 0x83, 0xde, 0x7a, 0x93, 0x67
576 },
577 {
578 /* Example #2 */
579 0x9e, 0x99, 0xa7, 0xbf, 0x31, 0xe7, 0x10, 0x90,
580 0x06, 0x62, 0xf6, 0x5e, 0x61, 0x7c, 0x51, 0x84
581 },
582 {
583 /* Example #3 */
584 0x3d, 0x75, 0xc1, 0x94, 0xed, 0x96, 0x07, 0x04,
585 0x44, 0xa9, 0xfa, 0x7e, 0xc7, 0x40, 0xec, 0xf8
586 },
587 {
588 /* Example #4 */
589 0xa1, 0xd5, 0xdf, 0x0e, 0xed, 0x79, 0x0f, 0x79,
590 0x4d, 0x77, 0x58, 0x96, 0x59, 0xf3, 0x9a, 0x11
591 }
592};
593
594/* CMAC-AES256 Test Data */
595static const unsigned char aes_256_key[32] = {
596 0x60, 0x3d, 0xeb, 0x10, 0x15, 0xca, 0x71, 0xbe,
597 0x2b, 0x73, 0xae, 0xf0, 0x85, 0x7d, 0x77, 0x81,
598 0x1f, 0x35, 0x2c, 0x07, 0x3b, 0x61, 0x08, 0xd7,
599 0x2d, 0x98, 0x10, 0xa3, 0x09, 0x14, 0xdf, 0xf4
600};
601static const unsigned char aes_256_subkeys[2][MBEDTLS_AES_BLOCK_SIZE] = {
602 {
603 /* K1 */
604 0xca, 0xd1, 0xed, 0x03, 0x29, 0x9e, 0xed, 0xac,
605 0x2e, 0x9a, 0x99, 0x80, 0x86, 0x21, 0x50, 0x2f
606 },
607 {
608 /* K2 */
609 0x95, 0xa3, 0xda, 0x06, 0x53, 0x3d, 0xdb, 0x58,
610 0x5d, 0x35, 0x33, 0x01, 0x0c, 0x42, 0xa0, 0xd9
611 }
612};
613static const unsigned char aes_256_expected_result[NB_CMAC_TESTS_PER_KEY][MBEDTLS_AES_BLOCK_SIZE] = {
614 {
615 /* Example #1 */
616 0x02, 0x89, 0x62, 0xf6, 0x1b, 0x7b, 0xf8, 0x9e,
617 0xfc, 0x6b, 0x55, 0x1f, 0x46, 0x67, 0xd9, 0x83
618 },
619 {
620 /* Example #2 */
621 0x28, 0xa7, 0x02, 0x3f, 0x45, 0x2e, 0x8f, 0x82,
622 0xbd, 0x4b, 0xf2, 0x8d, 0x8c, 0x37, 0xc3, 0x5c
623 },
624 {
625 /* Example #3 */
626 0x15, 0x67, 0x27, 0xdc, 0x08, 0x78, 0x94, 0x4a,
627 0x02, 0x3c, 0x1f, 0xe0, 0x3b, 0xad, 0x6d, 0x93
628 },
629 {
630 /* Example #4 */
631 0xe1, 0x99, 0x21, 0x90, 0x54, 0x9f, 0x6e, 0xd5,
632 0x69, 0x6a, 0x2c, 0x05, 0x6c, 0x31, 0x54, 0x10
633 }
634};
635#endif /* MBEDTLS_AES_C */
636
637#if defined(MBEDTLS_DES_C)
638/* Truncation point of message for 3DES CMAC tests */
639static const unsigned int des3_message_lengths[NB_CMAC_TESTS_PER_KEY] = {
640 0,
641 16,
642 20,
643 32
644};
645
646/* CMAC-TDES (Generation) - 2 Key Test Data */
647static const unsigned char des3_2key_key[24] = {
648 /* Key1 */
649 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
650 /* Key2 */
651 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xEF, 0x01,
652 /* Key3 */
653 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef
654};
655static const unsigned char des3_2key_subkeys[2][8] = {
656 {
657 /* K1 */
658 0x0d, 0xd2, 0xcb, 0x7a, 0x3d, 0x88, 0x88, 0xd9
659 },
660 {
661 /* K2 */
662 0x1b, 0xa5, 0x96, 0xf4, 0x7b, 0x11, 0x11, 0xb2
663 }
664};
665static const unsigned char des3_2key_expected_result[NB_CMAC_TESTS_PER_KEY][MBEDTLS_DES3_BLOCK_SIZE] = {
666 {
667 /* Sample #1 */
668 0x79, 0xce, 0x52, 0xa7, 0xf7, 0x86, 0xa9, 0x60
669 },
670 {
671 /* Sample #2 */
672 0xcc, 0x18, 0xa0, 0xb7, 0x9a, 0xf2, 0x41, 0x3b
673 },
674 {
675 /* Sample #3 */
676 0xc0, 0x6d, 0x37, 0x7e, 0xcd, 0x10, 0x19, 0x69
677 },
678 {
679 /* Sample #4 */
680 0x9c, 0xd3, 0x35, 0x80, 0xf9, 0xb6, 0x4d, 0xfb
681 }
682};
683
684/* CMAC-TDES (Generation) - 3 Key Test Data */
685static const unsigned char des3_3key_key[24] = {
686 /* Key1 */
687 0x01, 0x23, 0x45, 0x67, 0x89, 0xaa, 0xcd, 0xef,
688 /* Key2 */
689 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0x01,
690 /* Key3 */
691 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0x01, 0x23
692};
693static const unsigned char des3_3key_subkeys[2][8] = {
694 {
695 /* K1 */
696 0x9d, 0x74, 0xe7, 0x39, 0x33, 0x17, 0x96, 0xc0
697 },
698 {
699 /* K2 */
700 0x3a, 0xe9, 0xce, 0x72, 0x66, 0x2f, 0x2d, 0x9b
701 }
702};
703static const unsigned char des3_3key_expected_result[NB_CMAC_TESTS_PER_KEY][MBEDTLS_DES3_BLOCK_SIZE] = {
704 {
705 /* Sample #1 */
706 0x7d, 0xb0, 0xd3, 0x7d, 0xf9, 0x36, 0xc5, 0x50
707 },
708 {
709 /* Sample #2 */
710 0x30, 0x23, 0x9c, 0xf1, 0xf5, 0x2e, 0x66, 0x09
711 },
712 {
713 /* Sample #3 */
714 0x6c, 0x9f, 0x3e, 0xe4, 0x92, 0x3f, 0x6b, 0xe2
715 },
716 {
717 /* Sample #4 */
718 0x99, 0x42, 0x9b, 0xd0, 0xbF, 0x79, 0x04, 0xe5
719 }
720};
721
722#endif /* MBEDTLS_DES_C */
723
724#if defined(MBEDTLS_AES_C)
725/* AES AES-CMAC-PRF-128 Test Data */
726static const unsigned char PRFK[] = {
727 /* Key */
728 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
729 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
730 0xed, 0xcb
731};
732
733/* Sizes in bytes */
734static const size_t PRFKlen[NB_PRF_TESTS] = {
735 18,
736 16,
737 10
738};
739
740/* Message */
741static const unsigned char PRFM[] = {
742 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
743 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
744 0x10, 0x11, 0x12, 0x13
745};
746
747static const unsigned char PRFT[NB_PRF_TESTS][16] = {
748 {
749 0x84, 0xa3, 0x48, 0xa4, 0xa4, 0x5d, 0x23, 0x5b,
750 0xab, 0xff, 0xfc, 0x0d, 0x2b, 0x4d, 0xa0, 0x9a
751 },
752 {
753 0x98, 0x0a, 0xe8, 0x7b, 0x5f, 0x4c, 0x9c, 0x52,
754 0x14, 0xf5, 0xb6, 0xa8, 0x45, 0x5e, 0x4c, 0x2d
755 },
756 {
757 0x29, 0x0d, 0x9e, 0x11, 0x2e, 0xdb, 0x09, 0xee,
758 0x14, 0x1f, 0xcf, 0x64, 0xc0, 0xb7, 0x2f, 0x3d
759 }
760};
761#endif /* MBEDTLS_AES_C */
762
763static int cmac_test_subkeys( int verbose,
764 const char* testname,
765 const unsigned char* key,
766 int keybits,
767 const unsigned char* subkeys,
768 mbedtls_cipher_type_t cipher_type,
769 int block_size,
770 int num_tests )
771{
772 int i, ret = 0;
773 mbedtls_cipher_context_t ctx;
774 const mbedtls_cipher_info_t *cipher_info;
775 unsigned char K1[MBEDTLS_CIPHER_BLKSIZE_MAX];
776 unsigned char K2[MBEDTLS_CIPHER_BLKSIZE_MAX];
777
778 cipher_info = mbedtls_cipher_info_from_type( cipher_type );
779 if( cipher_info == NULL )
780 {
781 /* Failing at this point must be due to a build issue */
782 return( MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
783 }
784
785 for( i = 0; i < num_tests; i++ )
786 {
787 if( verbose != 0 )
788 mbedtls_printf( " %s CMAC subkey #%u: ", testname, i + 1 );
789
790 mbedtls_cipher_init( &ctx );
791
792 if( ( ret = mbedtls_cipher_setup( &ctx, cipher_info ) ) != 0 )
793 {
794 if( verbose != 0 )
795 mbedtls_printf( "test execution failed\n" );
796
797 goto cleanup;
798 }
799
800 if( ( ret = mbedtls_cipher_setkey( &ctx, key, keybits,
801 MBEDTLS_ENCRYPT ) ) != 0 )
802 {
803 if( verbose != 0 )
804 mbedtls_printf( "test execution failed\n" );
805
806 goto cleanup;
807 }
808
809 ret = cmac_generate_subkeys( &ctx, K1, K2 );
810 if( ret != 0 )
811 {
812 if( verbose != 0 )
813 mbedtls_printf( "failed\n" );
814
815 goto cleanup;
816 }
817
818 if( ( ret = memcmp( K1, subkeys, block_size ) ) != 0 ||
819 ( ret = memcmp( K2, &subkeys[block_size], block_size ) ) != 0 )
820 {
821 if( verbose != 0 )
822 mbedtls_printf( "failed\n" );
823
824 goto cleanup;
825 }
826
827 if( verbose != 0 )
828 mbedtls_printf( "passed\n" );
829
830 mbedtls_cipher_free( &ctx );
831 }
832
833 ret = 0;
834 goto exit;
835
836cleanup:
837 mbedtls_cipher_free( &ctx );
838
839exit:
840 return( ret );
841}
842
843static int cmac_test_wth_cipher( int verbose,
844 const char* testname,
845 const unsigned char* key,
846 int keybits,
847 const unsigned char* messages,
848 const unsigned int message_lengths[4],
849 const unsigned char* expected_result,
850 mbedtls_cipher_type_t cipher_type,
851 int block_size,
852 int num_tests )
853{
854 const mbedtls_cipher_info_t *cipher_info;
855 int i, ret = 0;
856 unsigned char output[MBEDTLS_CIPHER_BLKSIZE_MAX];
857
858 cipher_info = mbedtls_cipher_info_from_type( cipher_type );
859 if( cipher_info == NULL )
860 {
861 /* Failing at this point must be due to a build issue */
862 ret = MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE;
863 goto exit;
864 }
865
866 for( i = 0; i < num_tests; i++ )
867 {
868 if( verbose != 0 )
869 mbedtls_printf( " %s CMAC #%u: ", testname, i + 1 );
870
871 if( ( ret = mbedtls_cipher_cmac( cipher_info, key, keybits, messages,
872 message_lengths[i], output ) ) != 0 )
873 {
874 if( verbose != 0 )
875 mbedtls_printf( "failed\n" );
876 goto exit;
877 }
878
879 if( ( ret = memcmp( output, &expected_result[i * block_size], block_size ) ) != 0 )
880 {
881 if( verbose != 0 )
882 mbedtls_printf( "failed\n" );
883 goto exit;
884 }
885
886 if( verbose != 0 )
887 mbedtls_printf( "passed\n" );
888 }
889 ret = 0;
890
891exit:
892 return( ret );
893}
894
895#if defined(MBEDTLS_AES_C)
896static int test_aes128_cmac_prf( int verbose )
897{
898 int i;
899 int ret;
900 unsigned char output[MBEDTLS_AES_BLOCK_SIZE];
901
902 for( i = 0; i < NB_PRF_TESTS; i++ )
903 {
904 mbedtls_printf( " AES CMAC 128 PRF #%u: ", i );
905 ret = mbedtls_aes_cmac_prf_128( PRFK, PRFKlen[i], PRFM, 20, output );
906 if( ret != 0 ||
907 memcmp( output, PRFT[i], MBEDTLS_AES_BLOCK_SIZE ) != 0 )
908 {
909
910 if( verbose != 0 )
911 mbedtls_printf( "failed\n" );
912
913 return( ret );
914 }
915 else if( verbose != 0 )
916 {
917 mbedtls_printf( "passed\n" );
918 }
919 }
920 return( ret );
921}
922#endif /* MBEDTLS_AES_C */
923
924int mbedtls_cmac_self_test( int verbose )
925{
926 int ret;
927
928#if defined(MBEDTLS_AES_C)
929 /* AES-128 */
930 if( ( ret = cmac_test_subkeys( verbose,
931 "AES 128",
932 aes_128_key,
933 128,
934 (const unsigned char*)aes_128_subkeys,
935 MBEDTLS_CIPHER_AES_128_ECB,
936 MBEDTLS_AES_BLOCK_SIZE,
937 NB_CMAC_TESTS_PER_KEY ) ) != 0 )
938 {
939 return( ret );
940 }
941
942 if( ( ret = cmac_test_wth_cipher( verbose,
943 "AES 128",
944 aes_128_key,
945 128,
946 test_message,
947 aes_message_lengths,
948 (const unsigned char*)aes_128_expected_result,
949 MBEDTLS_CIPHER_AES_128_ECB,
950 MBEDTLS_AES_BLOCK_SIZE,
951 NB_CMAC_TESTS_PER_KEY ) ) != 0 )
952 {
953 return( ret );
954 }
955
956 /* AES-192 */
957 if( ( ret = cmac_test_subkeys( verbose,
958 "AES 192",
959 aes_192_key,
960 192,
961 (const unsigned char*)aes_192_subkeys,
962 MBEDTLS_CIPHER_AES_192_ECB,
963 MBEDTLS_AES_BLOCK_SIZE,
964 NB_CMAC_TESTS_PER_KEY ) ) != 0 )
965 {
966 return( ret );
967 }
968
969 if( ( ret = cmac_test_wth_cipher( verbose,
970 "AES 192",
971 aes_192_key,
972 192,
973 test_message,
974 aes_message_lengths,
975 (const unsigned char*)aes_192_expected_result,
976 MBEDTLS_CIPHER_AES_192_ECB,
977 MBEDTLS_AES_BLOCK_SIZE,
978 NB_CMAC_TESTS_PER_KEY ) ) != 0 )
979 {
980 return( ret );
981 }
982
983 /* AES-256 */
984 if( ( ret = cmac_test_subkeys( verbose,
985 "AES 256",
986 aes_256_key,
987 256,
988 (const unsigned char*)aes_256_subkeys,
989 MBEDTLS_CIPHER_AES_256_ECB,
990 MBEDTLS_AES_BLOCK_SIZE,
991 NB_CMAC_TESTS_PER_KEY ) ) != 0 )
992 {
993 return( ret );
994 }
995
996 if( ( ret = cmac_test_wth_cipher ( verbose,
997 "AES 256",
998 aes_256_key,
999 256,
1000 test_message,
1001 aes_message_lengths,
1002 (const unsigned char*)aes_256_expected_result,
1003 MBEDTLS_CIPHER_AES_256_ECB,
1004 MBEDTLS_AES_BLOCK_SIZE,
1005 NB_CMAC_TESTS_PER_KEY ) ) != 0 )
1006 {
1007 return( ret );
1008 }
1009#endif /* MBEDTLS_AES_C */
1010
1011#if defined(MBEDTLS_DES_C)
1012 /* 3DES 2 key */
1013 if( ( ret = cmac_test_subkeys( verbose,
1014 "3DES 2 key",
1015 des3_2key_key,
1016 192,
1017 (const unsigned char*)des3_2key_subkeys,
1018 MBEDTLS_CIPHER_DES_EDE3_ECB,
1019 MBEDTLS_DES3_BLOCK_SIZE,
1020 NB_CMAC_TESTS_PER_KEY ) ) != 0 )
1021 {
1022 return( ret );
1023 }
1024
1025 if( ( ret = cmac_test_wth_cipher( verbose,
1026 "3DES 2 key",
1027 des3_2key_key,
1028 192,
1029 test_message,
1030 des3_message_lengths,
1031 (const unsigned char*)des3_2key_expected_result,
1032 MBEDTLS_CIPHER_DES_EDE3_ECB,
1033 MBEDTLS_DES3_BLOCK_SIZE,
1034 NB_CMAC_TESTS_PER_KEY ) ) != 0 )
1035 {
1036 return( ret );
1037 }
1038
1039 /* 3DES 3 key */
1040 if( ( ret = cmac_test_subkeys( verbose,
1041 "3DES 3 key",
1042 des3_3key_key,
1043 192,
1044 (const unsigned char*)des3_3key_subkeys,
1045 MBEDTLS_CIPHER_DES_EDE3_ECB,
1046 MBEDTLS_DES3_BLOCK_SIZE,
1047 NB_CMAC_TESTS_PER_KEY ) ) != 0 )
1048 {
1049 return( ret );
1050 }
1051
1052 if( ( ret = cmac_test_wth_cipher( verbose,
1053 "3DES 3 key",
1054 des3_3key_key,
1055 192,
1056 test_message,
1057 des3_message_lengths,
1058 (const unsigned char*)des3_3key_expected_result,
1059 MBEDTLS_CIPHER_DES_EDE3_ECB,
1060 MBEDTLS_DES3_BLOCK_SIZE,
1061 NB_CMAC_TESTS_PER_KEY ) ) != 0 )
1062 {
1063 return( ret );
1064 }
1065#endif /* MBEDTLS_DES_C */
1066
1067#if defined(MBEDTLS_AES_C)
1068 if( ( ret = test_aes128_cmac_prf( verbose ) ) != 0 )
1069 return( ret );
1070#endif /* MBEDTLS_AES_C */
1071
1072 if( verbose != 0 )
1073 mbedtls_printf( "\n" );
1074
1075 return( 0 );
1076}
1077
1078#endif /* MBEDTLS_SELF_TEST */
1079
1080#endif /* MBEDTLS_CMAC_C */
diff --git a/source/mbedtls/lib/platform_util.c b/source/mbedtls/lib/platform_util.c
deleted file mode 100644
index 0be18ac..0000000
--- a/source/mbedtls/lib/platform_util.c
+++ /dev/null
@@ -1,69 +0,0 @@
1/*
2 * Common and shared functions used by multiple modules in the Mbed TLS
3 * library.
4 *
5 * Copyright (C) 2018, Arm Limited, All Rights Reserved
6 * SPDX-License-Identifier: GPL-2.0
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License along
19 * with this program; if not, write to the Free Software Foundation, Inc.,
20 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21 *
22 * This file is part of Mbed TLS (https://tls.mbed.org)
23 */
24
25#if !defined(MBEDTLS_CONFIG_FILE)
26#include "mbedtls/config.h"
27#else
28#include MBEDTLS_CONFIG_FILE
29#endif
30
31#include "mbedtls/platform_util.h"
32
33#include <stddef.h>
34#include <string.h>
35
36#if !defined(MBEDTLS_PLATFORM_ZEROIZE_ALT)
37/*
38 * This implementation should never be optimized out by the compiler
39 *
40 * This implementation for mbedtls_platform_zeroize() was inspired from Colin
41 * Percival's blog article at:
42 *
43 * http://www.daemonology.net/blog/2014-09-04-how-to-zero-a-buffer.html
44 *
45 * It uses a volatile function pointer to the standard memset(). Because the
46 * pointer is volatile the compiler expects it to change at
47 * any time and will not optimize out the call that could potentially perform
48 * other operations on the input buffer instead of just setting it to 0.
49 * Nevertheless, as pointed out by davidtgoldblatt on Hacker News
50 * (refer to http://www.daemonology.net/blog/2014-09-05-erratum.html for
51 * details), optimizations of the following form are still possible:
52 *
53 * if( memset_func != memset )
54 * memset_func( buf, 0, len );
55 *
56 * Note that it is extremely difficult to guarantee that
57 * mbedtls_platform_zeroize() will not be optimized out by aggressive compilers
58 * in a portable way. For this reason, Mbed TLS also provides the configuration
59 * option MBEDTLS_PLATFORM_ZEROIZE_ALT, which allows users to configure
60 * mbedtls_platform_zeroize() to use a suitable implementation for their
61 * platform and needs.
62 */
63static void * (* const volatile memset_func)( void *, int, size_t ) = memset;
64
65void mbedtls_platform_zeroize( void *buf, size_t len )
66{
67 memset_func( buf, 0, len );
68}
69#endif /* MBEDTLS_PLATFORM_ZEROIZE_ALT */
diff --git a/source/sha256.c b/source/sha256.c
deleted file mode 100644
index 01a1e27..0000000
--- a/source/sha256.c
+++ /dev/null
@@ -1,113 +0,0 @@
1/* Based on linux source code */
2/*
3 * sha256_base.h - core logic for SHA-256 implementations
4 *
5 * Copyright (C) 2015 Linaro Ltd <ard.biesheuvel@linaro.org>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 */
11
12#ifdef __cplusplus
13extern "C" {
14#endif
15
16#include <string.h>
17#include "sha256.h"
18
19#define unlikely(x) __builtin_expect(!!(x), 0)
20
21void sha256_block_data_order (uint32_t *ctx, const void *in, size_t num);
22
23int sha256_init(struct sha256_state *sctx)
24{
25 sctx->state[0] = SHA256_H0;
26 sctx->state[1] = SHA256_H1;
27 sctx->state[2] = SHA256_H2;
28 sctx->state[3] = SHA256_H3;
29 sctx->state[4] = SHA256_H4;
30 sctx->state[5] = SHA256_H5;
31 sctx->state[6] = SHA256_H6;
32 sctx->state[7] = SHA256_H7;
33 sctx->count = 0;
34
35 return 0;
36}
37
38int sha256_update(struct sha256_state *sctx,
39 const void *data,
40 size_t len)
41{
42 const u8 *data8 = (const u8 *)data;
43 unsigned int len32 = (unsigned int)len;
44 unsigned int partial = sctx->count % SHA256_BLOCK_SIZE;
45
46 sctx->count += len32;
47
48 if (unlikely((partial + len32) >= SHA256_BLOCK_SIZE)) {
49 int blocks;
50
51 if (partial) {
52 int p = SHA256_BLOCK_SIZE - partial;
53
54 memcpy(sctx->buf + partial, data8, p);
55 data8 += p;
56 len32 -= p;
57
58 sha256_block_data_order(sctx->state, sctx->buf, 1);
59 }
60
61 blocks = len32 / SHA256_BLOCK_SIZE;
62 len32 %= SHA256_BLOCK_SIZE;
63
64 if (blocks) {
65 sha256_block_data_order(sctx->state, data8, blocks);
66 data8 += blocks * SHA256_BLOCK_SIZE;
67 }
68 partial = 0;
69 }
70 if (len32)
71 memcpy(sctx->buf + partial, data8, len32);
72
73 return 0;
74}
75
76int sha256_finalize(struct sha256_state *sctx)
77{
78 const int bit_offset = SHA256_BLOCK_SIZE - sizeof(u64);
79 u64 *bits = (u64 *)(sctx->buf + bit_offset);
80 unsigned int partial = sctx->count % SHA256_BLOCK_SIZE;
81
82 sctx->buf[partial++] = 0x80;
83 if (partial > bit_offset) {
84 memset(sctx->buf + partial, 0x0, SHA256_BLOCK_SIZE - partial);
85 partial = 0;
86
87 sha256_block_data_order(sctx->state, sctx->buf, 1);
88 }
89
90 memset(sctx->buf + partial, 0x0, bit_offset - partial);
91 *bits = __builtin_bswap64(sctx->count << 3);
92 sha256_block_data_order(sctx->state, sctx->buf, 1);
93
94 return 0;
95}
96
97int sha256_finish(struct sha256_state *sctx, void *out)
98{
99 unsigned int digest_size = 32;
100 u32 *digest = (u32 *)out;
101 int i;
102
103 // Switch: misalignment shouldn't be a problem here...
104 for (i = 0; digest_size > 0; i++, digest_size -= sizeof(u32))
105 *digest++ = __builtin_bswap32(sctx->state[i]);
106
107 *sctx = (struct sha256_state){};
108 return 0;
109}
110
111#ifdef __cplusplus
112}
113#endif
diff --git a/source/sha256.h b/source/sha256.h
deleted file mode 100644
index 5fdc35a..0000000
--- a/source/sha256.h
+++ /dev/null
@@ -1,36 +0,0 @@
1#pragma once
2
3/* Based on linux source code */
4
5#ifdef __cplusplus
6extern "C" {
7#endif
8
9#include <switch/types.h>
10
11#define SHA256_DIGEST_SIZE 32
12#define SHA256_BLOCK_SIZE 64
13
14#define SHA256_H0 0x6a09e667UL
15#define SHA256_H1 0xbb67ae85UL
16#define SHA256_H2 0x3c6ef372UL
17#define SHA256_H3 0xa54ff53aUL
18#define SHA256_H4 0x510e527fUL
19#define SHA256_H5 0x9b05688cUL
20#define SHA256_H6 0x1f83d9abUL
21#define SHA256_H7 0x5be0cd19UL
22
23struct sha256_state {
24 u32 state[SHA256_DIGEST_SIZE / 4];
25 u64 count;
26 u8 buf[SHA256_BLOCK_SIZE];
27};
28
29int sha256_init(struct sha256_state *sctx);
30int sha256_update(struct sha256_state *sctx, const void *data, size_t len);
31int sha256_finalize(struct sha256_state *sctx);
32int sha256_finish(struct sha256_state *sctx, void *out);
33
34#ifdef __cplusplus
35}
36#endif
diff --git a/source/sha256_armv8.s b/source/sha256_armv8.s
deleted file mode 100644
index a9b9363..0000000
--- a/source/sha256_armv8.s
+++ /dev/null
@@ -1,163 +0,0 @@
1.section .text.sha256_armv8, "ax", %progbits
2.align 5
3.arch armv8-a+crypto
4
5# SHA256 assembly implementation for ARMv8 AArch64 (based on linux source code)
6
7.global sha256_block_data_order
8.type sha256_block_data_order,%function
9sha256_block_data_order:
10
11.Lsha256prolog:
12
13 stp x29, x30, [sp,#-64]!
14 mov x29, sp
15 adr x3, .LKConstant256
16 str q8, [sp, #16]
17 ld1 {v16.4s-v19.4s}, [x3], #64
18 ld1 {v0.4s}, [x0], #16
19 ld1 {v20.4s-v23.4s}, [x3], #64
20 add x2, x1, x2, lsl #6
21 ld1 {v1.4s}, [x0]
22 ld1 {v24.4s-v27.4s}, [x3], #64
23 sub x0, x0, #16
24 str q9, [sp, #32]
25 str q10, [sp, #48]
26 ld1 {v28.4s-v31.4s}, [x3], #64
27
28.Lsha256loop:
29
30 ld1 {v5.16b-v8.16b}, [x1], #64
31 mov v2.16b, v0.16b
32 mov v3.16b, v1.16b
33
34 rev32 v5.16b, v5.16b
35 rev32 v6.16b, v6.16b
36 add v9.4s, v5.4s, v16.4s
37 rev32 v7.16b, v7.16b
38 add v10.4s, v6.4s, v17.4s
39 mov v4.16b, v2.16b
40 sha256h q2, q3, v9.4s
41 sha256h2 q3, q4, v9.4s
42 sha256su0 v5.4s, v6.4s
43 rev32 v8.16b, v8.16b
44 add v9.4s, v7.4s, v18.4s
45 mov v4.16b, v2.16b
46 sha256h q2, q3, v10.4s
47 sha256h2 q3, q4, v10.4s
48 sha256su0 v6.4s, v7.4s
49 sha256su1 v5.4s, v7.4s, v8.4s
50 add v10.4s, v8.4s, v19.4s
51 mov v4.16b, v2.16b
52 sha256h q2, q3, v9.4s
53 sha256h2 q3, q4, v9.4s
54 sha256su0 v7.4s, v8.4s
55 sha256su1 v6.4s, v8.4s, v5.4s
56 add v9.4s, v5.4s, v20.4s
57 mov v4.16b, v2.16b
58 sha256h q2, q3, v10.4s
59 sha256h2 q3, q4, v10.4s
60 sha256su0 v8.4s, v5.4s
61 sha256su1 v7.4s, v5.4s, v6.4s
62 add v10.4s, v6.4s, v21.4s
63 mov v4.16b, v2.16b
64 sha256h q2, q3, v9.4s
65 sha256h2 q3, q4, v9.4s
66 sha256su0 v5.4s, v6.4s
67 sha256su1 v8.4s, v6.4s, v7.4s
68 add v9.4s, v7.4s, v22.4s
69 mov v4.16b, v2.16b
70 sha256h q2, q3, v10.4s
71 sha256h2 q3, q4, v10.4s
72 sha256su0 v6.4s, v7.4s
73 sha256su1 v5.4s, v7.4s, v8.4s
74 add v10.4s, v8.4s, v23.4s
75 mov v4.16b, v2.16b
76 sha256h q2, q3, v9.4s
77 sha256h2 q3, q4, v9.4s
78 sha256su0 v7.4s, v8.4s
79 sha256su1 v6.4s, v8.4s, v5.4s
80 add v9.4s, v5.4s, v24.4s
81 mov v4.16b, v2.16b
82 sha256h q2, q3, v10.4s
83 sha256h2 q3, q4, v10.4s
84 sha256su0 v8.4s, v5.4s
85 sha256su1 v7.4s, v5.4s, v6.4s
86 add v10.4s, v6.4s, v25.4s
87 mov v4.16b, v2.16b
88 sha256h q2, q3, v9.4s
89 sha256h2 q3, q4, v9.4s
90 sha256su0 v5.4s, v6.4s
91 sha256su1 v8.4s, v6.4s, v7.4s
92 add v9.4s, v7.4s, v26.4s
93 mov v4.16b, v2.16b
94 sha256h q2, q3, v10.4s
95 sha256h2 q3, q4, v10.4s
96 sha256su0 v6.4s, v7.4s
97 sha256su1 v5.4s, v7.4s, v8.4s
98 add v10.4s, v8.4s, v27.4s
99 mov v4.16b, v2.16b
100 sha256h q2, q3, v9.4s
101 sha256h2 q3, q4, v9.4s
102 sha256su0 v7.4s, v8.4s
103 sha256su1 v6.4s, v8.4s, v5.4s
104 add v9.4s, v5.4s, v28.4s
105 mov v4.16b, v2.16b
106 sha256h q2, q3, v10.4s
107 sha256h2 q3, q4, v10.4s
108 sha256su0 v8.4s, v5.4s
109 sha256su1 v7.4s, v5.4s, v6.4s
110 add v10.4s, v6.4s, v29.4s
111 mov v4.16b, v2.16b
112 sha256h q2, q3, v9.4s
113 sha256h2 q3, q4, v9.4s
114 sha256su1 v8.4s, v6.4s, v7.4s
115 add v9.4s, v7.4s, v30.4s
116 mov v4.16b, v2.16b
117 sha256h q2, q3, v10.4s
118 sha256h2 q3, q4, v10.4s
119 add v10.4s, v8.4s, v31.4s
120 mov v4.16b, v2.16b
121 sha256h q2, q3, v9.4s
122 sha256h2 q3, q4, v9.4s
123 mov v4.16b, v2.16b
124 sha256h q2, q3, v10.4s
125 sha256h2 q3, q4, v10.4s
126 cmp x1, x2
127 add v1.4s, v1.4s, v3.4s
128 add v0.4s, v0.4s, v2.4s
129 b.ne .Lsha256loop
130
131.Lsha256epilog:
132
133 st1 {v0.4s,v1.4s}, [x0]
134 ldr q10, [sp, #48]
135 ldr q9, [sp, #32]
136 ldr q8, [sp, #16]
137 ldr x29, [sp], #64
138 ret
139
140.align 5
141.LKConstant256:
142.word 0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5
143.word 0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5
144.word 0xd807aa98,0x12835b01,0x243185be,0x550c7dc3
145.word 0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174
146.word 0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc
147.word 0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da
148.word 0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7
149.word 0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967
150.word 0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13
151.word 0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85
152.word 0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3
153.word 0xd192e819,0xd6990624,0xf40e3585,0x106aa070
154.word 0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5
155.word 0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3
156.word 0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208
157.word 0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2
158
159.size sha256_block_data_order,.-sha256_block_data_order
160.align 2
161
162
163
generated by cgit v1.2.3 (git 2.39.1) at 2024-09-20 07:34:11 +0000