Coverage Report

Created: 2022-08-24 06:37

/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 */