Coverage Report

Created: 2020-02-14 15:38

/src/botan/src/fuzzer/mode_padding.cpp
Line
Count
Source (jump to first uncovered line)
1
/*
2
* (C) 2018 Jack Lloyd
3
*
4
* Botan is released under the Simplified BSD License (see license.txt)
5
*/
6
7
#include "fuzzers.h"
8
#include <botan/mode_pad.h>
9
#include <botan/internal/tls_cbc.h>
10
11
namespace {
12
13
size_t ref_pkcs7_unpad(const uint8_t in[], size_t len)
14
139
   {
15
139
   if(len <= 2)
16
0
      return len;
17
139
18
139
   const size_t padding_length = in[len-1];
19
139
20
139
   if(padding_length == 0 || padding_length > len)
21
43
      return len;
22
96
23
96
   const size_t padding_start = len - padding_length;
24
96
25
507
   for(size_t i = padding_start; i != len; ++i)
26
491
      {
27
491
      if(in[i] != padding_length)
28
80
         return len;
29
491
      }
30
96
31
96
   return len - padding_length;
32
96
   }
33
34
size_t ref_x923_unpad(const uint8_t in[], size_t len)
35
139
   {
36
139
   if(len <= 2)
37
0
      return len;
38
139
39
139
   const size_t padding_length = in[len-1];
40
139
41
139
   if(padding_length == 0 || padding_length > len)
42
43
      return len;
43
96
   const size_t padding_start = len - padding_length;
44
96
45
403
   for(size_t i = padding_start; i != len - 1; ++i)
46
396
      {
47
396
      if(in[i] != 0)
48
89
         {
49
89
         return len;
50
89
         }
51
396
      }
52
96
53
96
   return len - padding_length;
54
96
   }
55
56
size_t ref_oneandzero_unpad(const uint8_t in[], size_t len)
57
196
   {
58
196
   if(len <= 2)
59
0
      return len;
60
196
61
196
   size_t idx = len - 1;
62
196
63
196
   for(;;)
64
4.19k
      {
65
4.19k
      if(in[idx] == 0)
66
4.00k
         {
67
4.00k
         if(idx == 0)
68
2
            return len;
69
4.00k
         idx -= 1;
70
4.00k
         continue;
71
4.00k
         }
72
194
      else if(in[idx] == 0x80)
73
10
         {
74
10
         return idx;
75
10
         }
76
184
      else
77
184
         return len;
78
4.19k
      }
79
196
80
196
   return len;
81
196
   }
82
83
size_t ref_esp_unpad(const uint8_t in[], size_t len)
84
139
   {
85
139
   if(len <= 2)
86
0
      return len;
87
139
88
139
   const size_t padding_bytes = in[len - 1];
89
139
90
139
   if(padding_bytes == 0 || padding_bytes > len)
91
43
      {
92
43
      return len;
93
43
      }
94
96
95
96
   const size_t padding_start = len - padding_bytes;
96
232
   for(size_t i = padding_start; i != len; ++i)
97
224
      {
98
224
      if(in[i] != (i - padding_start + 1))
99
88
         {
100
88
         return len;
101
88
         }
102
224
      }
103
96
104
96
   return len - padding_bytes;
105
96
   }
106
107
uint16_t ref_tls_cbc_unpad(const uint8_t in[], size_t len)
108
224
   {
109
224
   if(len == 0)
110
0
      return 0;
111
224
112
224
   const size_t padding_length = in[(len-1)];
113
224
114
224
   if(padding_length >= len)
115
82
      return 0;
116
142
117
142
   /*
118
142
   * TLS v1.0 and up require all the padding bytes be the same value
119
142
   * and allows up to 255 bytes.
120
142
   */
121
1.01k
   for(size_t i = 0; i != 1 + padding_length; ++i)
122
970
      {
123
970
      if(in[(len-i-1)] != padding_length)
124
97
         return 0;
125
970
      }
126
142
   return padding_length + 1;
127
142
   }
128
129
}
130
131
void fuzz(const uint8_t in[], size_t len)
132
224
   {
133
224
   static Botan::PKCS7_Padding pkcs7;
134
224
   static Botan::ANSI_X923_Padding x923;
135
224
   static Botan::OneAndZeros_Padding oneandzero;
136
224
   static Botan::ESP_Padding esp;
137
224
138
224
   if(pkcs7.valid_blocksize(len))
139
139
      {
140
139
      const size_t ct_pkcs7 = pkcs7.unpad(in, len);
141
139
      const size_t ref_pkcs7 = ref_pkcs7_unpad(in, len);
142
139
      FUZZER_ASSERT_EQUAL(ct_pkcs7, ref_pkcs7);
143
139
      }
144
224
145
224
   if(x923.valid_blocksize(len))
146
139
      {
147
139
      const size_t ct_x923 = x923.unpad(in, len);
148
139
      const size_t ref_x923 = ref_x923_unpad(in, len);
149
139
      FUZZER_ASSERT_EQUAL(ct_x923, ref_x923);
150
139
      }
151
224
152
224
   if(oneandzero.valid_blocksize(len))
153
196
      {
154
196
      const size_t ct_oneandzero = oneandzero.unpad(in, len);
155
196
      const size_t ref_oneandzero = ref_oneandzero_unpad(in, len);
156
196
      FUZZER_ASSERT_EQUAL(ct_oneandzero, ref_oneandzero);
157
196
      }
158
224
159
224
   if(esp.valid_blocksize(len))
160
139
      {
161
139
      const size_t ct_esp = esp.unpad(in, len);
162
139
      const size_t ref_esp = ref_esp_unpad(in, len);
163
139
      FUZZER_ASSERT_EQUAL(ct_esp, ref_esp);
164
139
      }
165
224
166
224
   const uint16_t ct_cbc = Botan::TLS::check_tls_cbc_padding(in, len);
167
224
   const uint16_t ref_cbc = ref_tls_cbc_unpad(in, len);
168
224
   FUZZER_ASSERT_EQUAL(ct_cbc, ref_cbc);
169
224
   }