/src/cryptofuzz-openssl-api/modules/wolfcrypt-openssl/module_internal.h
Line | Count | Source (jump to first uncovered line) |
1 | | #pragma once |
2 | | |
3 | | namespace cryptofuzz { |
4 | | namespace module { |
5 | | |
6 | | template <class T> |
7 | | class CTX_Copier { |
8 | | private: |
9 | | T* ctx = nullptr; |
10 | | Datasource& ds; |
11 | | |
12 | | T* newCTX(void) const; |
13 | | int copyCTX(T* dest, T* src) const; |
14 | | void freeCTX(T* ctx) const; |
15 | | |
16 | 26.2k | T* copy(void) { |
17 | 26.2k | bool doCopyCTX = true; |
18 | 26.2k | try { |
19 | 26.2k | doCopyCTX = ds.Get<bool>(); |
20 | 26.2k | } catch ( fuzzing::datasource::Datasource::OutOfData ) { } |
21 | | |
22 | 26.2k | if ( doCopyCTX == true ) { |
23 | 25.1k | T* tmpCtx = newCTX(); |
24 | 25.1k | if ( tmpCtx != nullptr ) { |
25 | 25.1k | if ( copyCTX(tmpCtx, ctx) == 1 ) { |
26 | | /* Copy succeeded, free the old ctx */ |
27 | 13.6k | freeCTX(ctx); |
28 | | |
29 | | /* Use the copied ctx */ |
30 | 13.6k | ctx = tmpCtx; |
31 | 13.6k | } else { |
32 | 11.4k | freeCTX(tmpCtx); |
33 | 11.4k | } |
34 | 25.1k | } |
35 | 25.1k | } |
36 | | |
37 | 26.2k | return ctx; |
38 | 26.2k | } cryptofuzz::module::CTX_Copier<WOLFSSL_EVP_MD_CTX>::copy() Line | Count | Source | 16 | 16.9k | T* copy(void) { | 17 | 16.9k | bool doCopyCTX = true; | 18 | 16.9k | try { | 19 | 16.9k | doCopyCTX = ds.Get<bool>(); | 20 | 16.9k | } catch ( fuzzing::datasource::Datasource::OutOfData ) { } | 21 | | | 22 | 16.9k | if ( doCopyCTX == true ) { | 23 | 16.4k | T* tmpCtx = newCTX(); | 24 | 16.4k | if ( tmpCtx != nullptr ) { | 25 | 16.4k | if ( copyCTX(tmpCtx, ctx) == 1 ) { | 26 | | /* Copy succeeded, free the old ctx */ | 27 | 13.1k | freeCTX(ctx); | 28 | | | 29 | | /* Use the copied ctx */ | 30 | 13.1k | ctx = tmpCtx; | 31 | 13.1k | } else { | 32 | 3.30k | freeCTX(tmpCtx); | 33 | 3.30k | } | 34 | 16.4k | } | 35 | 16.4k | } | 36 | | | 37 | 16.9k | return ctx; | 38 | 16.9k | } |
cryptofuzz::module::CTX_Copier<WOLFSSL_HMAC_CTX>::copy() Line | Count | Source | 16 | 974 | T* copy(void) { | 17 | 974 | bool doCopyCTX = true; | 18 | 974 | try { | 19 | 974 | doCopyCTX = ds.Get<bool>(); | 20 | 974 | } catch ( fuzzing::datasource::Datasource::OutOfData ) { } | 21 | | | 22 | 974 | if ( doCopyCTX == true ) { | 23 | 654 | T* tmpCtx = newCTX(); | 24 | 654 | if ( tmpCtx != nullptr ) { | 25 | 654 | if ( copyCTX(tmpCtx, ctx) == 1 ) { | 26 | | /* Copy succeeded, free the old ctx */ | 27 | 501 | freeCTX(ctx); | 28 | | | 29 | | /* Use the copied ctx */ | 30 | 501 | ctx = tmpCtx; | 31 | 501 | } else { | 32 | 153 | freeCTX(tmpCtx); | 33 | 153 | } | 34 | 654 | } | 35 | 654 | } | 36 | | | 37 | 974 | return ctx; | 38 | 974 | } |
cryptofuzz::module::CTX_Copier<WOLFSSL_EVP_CIPHER_CTX>::copy() Line | Count | Source | 16 | 8.40k | T* copy(void) { | 17 | 8.40k | bool doCopyCTX = true; | 18 | 8.40k | try { | 19 | 8.40k | doCopyCTX = ds.Get<bool>(); | 20 | 8.40k | } catch ( fuzzing::datasource::Datasource::OutOfData ) { } | 21 | | | 22 | 8.40k | if ( doCopyCTX == true ) { | 23 | 8.02k | T* tmpCtx = newCTX(); | 24 | 8.02k | if ( tmpCtx != nullptr ) { | 25 | 8.02k | if ( copyCTX(tmpCtx, ctx) == 1 ) { | 26 | | /* Copy succeeded, free the old ctx */ | 27 | 0 | freeCTX(ctx); | 28 | | | 29 | | /* Use the copied ctx */ | 30 | 0 | ctx = tmpCtx; | 31 | 8.02k | } else { | 32 | 8.02k | freeCTX(tmpCtx); | 33 | 8.02k | } | 34 | 8.02k | } | 35 | 8.02k | } | 36 | | | 37 | 8.40k | return ctx; | 38 | 8.40k | } |
|
39 | | |
40 | | public: |
41 | | CTX_Copier(Datasource& ds) : |
42 | 3.34k | ds(ds) { |
43 | 3.34k | ctx = newCTX(); |
44 | 3.34k | if ( ctx == nullptr ) { |
45 | 0 | abort(); |
46 | 0 | } |
47 | 3.34k | } cryptofuzz::module::CTX_Copier<WOLFSSL_EVP_MD_CTX>::CTX_Copier(fuzzing::datasource::Datasource&) Line | Count | Source | 42 | 1.29k | ds(ds) { | 43 | 1.29k | ctx = newCTX(); | 44 | 1.29k | if ( ctx == nullptr ) { | 45 | 0 | abort(); | 46 | 0 | } | 47 | 1.29k | } |
cryptofuzz::module::CTX_Copier<WOLFSSL_HMAC_CTX>::CTX_Copier(fuzzing::datasource::Datasource&) Line | Count | Source | 42 | 129 | ds(ds) { | 43 | 129 | ctx = newCTX(); | 44 | 129 | if ( ctx == nullptr ) { | 45 | 0 | abort(); | 46 | 0 | } | 47 | 129 | } |
cryptofuzz::module::CTX_Copier<WOLFSSL_EVP_CIPHER_CTX>::CTX_Copier(fuzzing::datasource::Datasource&) Line | Count | Source | 42 | 1.92k | ds(ds) { | 43 | 1.92k | ctx = newCTX(); | 44 | 1.92k | if ( ctx == nullptr ) { | 45 | 0 | abort(); | 46 | 0 | } | 47 | 1.92k | } |
|
48 | | |
49 | 26.2k | T* GetPtr(void) { |
50 | 26.2k | return copy(); |
51 | 26.2k | } cryptofuzz::module::CTX_Copier<WOLFSSL_EVP_MD_CTX>::GetPtr() Line | Count | Source | 49 | 16.9k | T* GetPtr(void) { | 50 | 16.9k | return copy(); | 51 | 16.9k | } |
cryptofuzz::module::CTX_Copier<WOLFSSL_HMAC_CTX>::GetPtr() Line | Count | Source | 49 | 974 | T* GetPtr(void) { | 50 | 974 | return copy(); | 51 | 974 | } |
cryptofuzz::module::CTX_Copier<WOLFSSL_EVP_CIPHER_CTX>::GetPtr() Line | Count | Source | 49 | 8.40k | T* GetPtr(void) { | 50 | 8.40k | return copy(); | 51 | 8.40k | } |
|
52 | | |
53 | 3.34k | ~CTX_Copier() { |
54 | 3.34k | freeCTX(ctx); |
55 | 3.34k | } cryptofuzz::module::CTX_Copier<WOLFSSL_EVP_MD_CTX>::~CTX_Copier() Line | Count | Source | 53 | 1.29k | ~CTX_Copier() { | 54 | 1.29k | freeCTX(ctx); | 55 | 1.29k | } |
cryptofuzz::module::CTX_Copier<WOLFSSL_HMAC_CTX>::~CTX_Copier() Line | Count | Source | 53 | 129 | ~CTX_Copier() { | 54 | 129 | freeCTX(ctx); | 55 | 129 | } |
cryptofuzz::module::CTX_Copier<WOLFSSL_EVP_CIPHER_CTX>::~CTX_Copier() Line | Count | Source | 53 | 1.92k | ~CTX_Copier() { | 54 | 1.92k | freeCTX(ctx); | 55 | 1.92k | } |
|
56 | | }; |
57 | | |
58 | | class EC_GROUP_Copier { |
59 | | private: |
60 | | bool locked = false; |
61 | | const int curveNID; |
62 | | EC_GROUP* group = nullptr; |
63 | | Datasource& ds; |
64 | | |
65 | 0 | EC_GROUP* newGroup(void) { |
66 | 0 | return EC_GROUP_new_by_curve_name(curveNID); |
67 | 0 | } |
68 | | |
69 | | #if !defined(CRYPTOFUZZ_BORINGSSL) && !defined(CRYPTOFUZZ_WOLFCRYPT_OPENSSL) |
70 | | int copyGroup(EC_GROUP* dest, EC_GROUP* src) { |
71 | | return EC_GROUP_copy(dest, src); |
72 | | } |
73 | | #endif |
74 | 0 | void freeGroup(EC_GROUP* group) { |
75 | 0 | /* noret */ EC_GROUP_free(group); |
76 | 0 | } |
77 | | |
78 | 0 | EC_GROUP* copy(void) { |
79 | 0 | bool doCopyGroup = true; |
80 | 0 | try { |
81 | 0 | doCopyGroup = ds.Get<bool>(); |
82 | 0 | } catch ( fuzzing::datasource::Datasource::OutOfData ) { } |
83 | 0 |
|
84 | 0 | if ( doCopyGroup == true ) { |
85 | 0 | #if !defined(CRYPTOFUZZ_BORINGSSL) && !defined(CRYPTOFUZZ_WOLFCRYPT_OPENSSL) |
86 | 0 | EC_GROUP* tmpGroup = newGroup(); |
87 | 0 | if ( tmpGroup != nullptr ) { |
88 | 0 | if ( copyGroup(tmpGroup, group) == 1 ) { |
89 | 0 | /* Copy succeeded, free the old group */ |
90 | 0 | freeGroup(group); |
91 | 0 |
|
92 | 0 | /* Use the copied group */ |
93 | 0 | group = tmpGroup; |
94 | 0 | } else { |
95 | 0 | freeGroup(tmpGroup); |
96 | 0 | } |
97 | 0 | } |
98 | 0 | #endif |
99 | 0 | } |
100 | 0 |
|
101 | 0 | return group; |
102 | 0 | } |
103 | | |
104 | | public: |
105 | | EC_GROUP_Copier(Datasource& ds, const int curveNID) : |
106 | 0 | curveNID(curveNID), ds(ds) { |
107 | 0 | group = newGroup(); |
108 | 0 | } |
109 | | |
110 | 0 | void Lock(void) { |
111 | 0 | locked = true; |
112 | 0 | } |
113 | | |
114 | 0 | EC_GROUP* GetPtr(void) { |
115 | 0 | if ( locked == true ) { |
116 | 0 | return group; |
117 | 0 | } else { |
118 | 0 | return copy(); |
119 | 0 | } |
120 | 0 | } |
121 | | |
122 | 0 | ~EC_GROUP_Copier() { |
123 | 0 | freeGroup(group); |
124 | 0 | } |
125 | | }; |
126 | | |
127 | | class EC_POINT_Copier { |
128 | | private: |
129 | | std::shared_ptr<EC_GROUP_Copier> group; |
130 | | EC_POINT* point = nullptr; |
131 | | Datasource& ds; |
132 | | |
133 | 0 | EC_POINT* newPoint(void) { |
134 | 0 | return EC_POINT_new(group->GetPtr()); |
135 | 0 | } |
136 | | |
137 | 0 | int copyPoint(EC_POINT* dest, EC_POINT* src) { |
138 | 0 | return EC_POINT_copy(dest, src); |
139 | 0 | } |
140 | 0 | void freePoint(EC_POINT* point) { |
141 | 0 | /* noret */ EC_POINT_free(point); |
142 | 0 | } |
143 | | |
144 | 0 | EC_POINT* copy(void) { |
145 | 0 | bool doCopyPoint = true; |
146 | 0 | try { |
147 | 0 | doCopyPoint = ds.Get<bool>(); |
148 | 0 | } catch ( fuzzing::datasource::Datasource::OutOfData ) { } |
149 | 0 |
|
150 | 0 | if ( doCopyPoint == true ) { |
151 | 0 | EC_POINT* tmpPoint = newPoint(); |
152 | 0 | if ( tmpPoint != nullptr ) { |
153 | 0 | if ( copyPoint(tmpPoint, point) == 1 ) { |
154 | 0 | /* Copy succeeded, free the old point */ |
155 | 0 | freePoint(point); |
156 | 0 |
|
157 | 0 | /* Use the copied point */ |
158 | 0 | point = tmpPoint; |
159 | 0 | } else { |
160 | 0 | freePoint(tmpPoint); |
161 | 0 | } |
162 | 0 | } |
163 | 0 | } |
164 | 0 |
|
165 | 0 | return point; |
166 | 0 | } |
167 | | |
168 | | public: |
169 | | EC_POINT_Copier(Datasource& ds, std::shared_ptr<EC_GROUP_Copier> group) : |
170 | 0 | group(group), ds(ds) { |
171 | 0 | point = newPoint(); |
172 | 0 | if ( point == nullptr ) { |
173 | 0 | abort(); |
174 | 0 | } |
175 | 0 | } |
176 | | |
177 | 0 | EC_POINT* GetPtr(void) { |
178 | 0 | return copy(); |
179 | 0 | } |
180 | | |
181 | 0 | ~EC_POINT_Copier() { |
182 | 0 | freePoint(point); |
183 | 0 | } |
184 | | }; |
185 | | |
186 | | #if !defined(CRYPTOFUZZ_OPENSSL_102) |
187 | 17.7k | template<> EVP_MD_CTX* CTX_Copier<EVP_MD_CTX>::newCTX(void) const { return EVP_MD_CTX_new(); } |
188 | | #else |
189 | | template<> EVP_MD_CTX* CTX_Copier<EVP_MD_CTX>::newCTX(void) const { |
190 | | EVP_MD_CTX* ret = (EVP_MD_CTX*)malloc(sizeof(*ret)); |
191 | | EVP_MD_CTX_init(ret); |
192 | | return ret; |
193 | | } |
194 | | #endif |
195 | | |
196 | 16.4k | template<> int CTX_Copier<EVP_MD_CTX>::copyCTX(EVP_MD_CTX* dest, EVP_MD_CTX* src) const { return EVP_MD_CTX_copy(dest, src); } |
197 | | |
198 | | #if !defined(CRYPTOFUZZ_OPENSSL_102) |
199 | 17.7k | template<> void CTX_Copier<EVP_MD_CTX>::freeCTX(EVP_MD_CTX* ctx) const { EVP_MD_CTX_free(ctx); } |
200 | | #else |
201 | | template<> void CTX_Copier<EVP_MD_CTX>::freeCTX(EVP_MD_CTX* ctx) const { EVP_MD_CTX_cleanup(ctx); free(ctx); } |
202 | | #endif |
203 | | |
204 | 9.95k | template<> EVP_CIPHER_CTX* CTX_Copier<EVP_CIPHER_CTX>::newCTX(void) const { return EVP_CIPHER_CTX_new(); } |
205 | 8.02k | template<> int CTX_Copier<EVP_CIPHER_CTX>::copyCTX(EVP_CIPHER_CTX* dest, EVP_CIPHER_CTX* src) const { |
206 | | #if !defined(CRYPTOFUZZ_WOLFCRYPT_OPENSSL) |
207 | | return EVP_CIPHER_CTX_copy(dest, src); |
208 | | #else |
209 | 8.02k | (void)dest; |
210 | 8.02k | (void)src; |
211 | | |
212 | | /* EVP_CIPHER_CTX_copy is not implemented in wolfCrypt; return failure */ |
213 | 8.02k | return 0; |
214 | 8.02k | #endif |
215 | 8.02k | } |
216 | 9.95k | template<> void CTX_Copier<EVP_CIPHER_CTX>::freeCTX(EVP_CIPHER_CTX* ctx) const { return EVP_CIPHER_CTX_free(ctx); } |
217 | | |
218 | | #if !defined(CRYPTOFUZZ_OPENSSL_102) |
219 | 783 | template<> HMAC_CTX* CTX_Copier<HMAC_CTX>::newCTX(void) const { return HMAC_CTX_new(); } |
220 | 654 | template<> int CTX_Copier<HMAC_CTX>::copyCTX(HMAC_CTX* dest, HMAC_CTX* src) const { return HMAC_CTX_copy(dest, src); } |
221 | 783 | template<> void CTX_Copier<HMAC_CTX>::freeCTX(HMAC_CTX* ctx) const { return HMAC_CTX_free(ctx); } |
222 | | #endif |
223 | | |
224 | | #if !defined(CRYPTOFUZZ_WOLFCRYPT_OPENSSL) |
225 | | template<> CMAC_CTX* CTX_Copier<CMAC_CTX>::newCTX(void) const { return CMAC_CTX_new(); } |
226 | | template<> int CTX_Copier<CMAC_CTX>::copyCTX(CMAC_CTX* dest, CMAC_CTX* src) const { return CMAC_CTX_copy(dest, src); } |
227 | | template<> void CTX_Copier<CMAC_CTX>::freeCTX(CMAC_CTX* ctx) const { return CMAC_CTX_free(ctx); } |
228 | | #endif |
229 | | |
230 | 0 | template<> EC_KEY* CTX_Copier<EC_KEY>::newCTX(void) const { return EC_KEY_new(); } |
231 | 0 | template<> int CTX_Copier<EC_KEY>::copyCTX(EC_KEY* dest, EC_KEY* src) const { |
232 | | #if !defined(CRYPTOFUZZ_BORINGSSL) && !defined(CRYPTOFUZZ_WOLFCRYPT_OPENSSL) |
233 | | return EC_KEY_copy(dest, src) == nullptr ? 0 : 1; |
234 | | #else |
235 | 0 | (void)dest; |
236 | 0 | (void)src; |
237 | 0 | return 0; |
238 | 0 | #endif |
239 | 0 | } |
240 | 0 | template<> void CTX_Copier<EC_KEY>::freeCTX(EC_KEY* ctx) const { return EC_KEY_free(ctx); } |
241 | | |
242 | | using CF_EVP_MD_CTX = CTX_Copier<EVP_MD_CTX>; |
243 | | using CF_EVP_CIPHER_CTX = CTX_Copier<EVP_CIPHER_CTX>; |
244 | | using CF_HMAC_CTX = CTX_Copier<HMAC_CTX>; |
245 | | #if !defined(CRYPTOFUZZ_WOLFCRYPT_OPENSSL) |
246 | | using CF_CMAC_CTX = CTX_Copier<CMAC_CTX>; |
247 | | #endif |
248 | | using CF_EC_KEY = CTX_Copier<EC_KEY>; |
249 | | using CF_EC_POINT = EC_POINT_Copier; |
250 | | using CF_EC_GROUP = EC_GROUP_Copier; |
251 | | } /* namespace module */ |
252 | | } /* namespace cryptofuzz */ |