Coverage Report

Created: 2020-05-23 13:54

/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
135
   {
15
135
   if(len <= 2)
16
0
      return len;
17
135
18
135
   const size_t padding_length = in[len-1];
19
135
20
135
   if(padding_length == 0 || padding_length > len)
21
51
      return len;
22
84
23
84
   const size_t padding_start = len - padding_length;
24
84
25
533
   for(size_t i = padding_start; i != len; ++i)
26
514
      {
27
514
      if(in[i] != padding_length)
28
65
         return len;
29
514
      }
30
84
31
84
   return len - padding_length;
32
84
   }
33
34
size_t ref_x923_unpad(const uint8_t in[], size_t len)
35
135
   {
36
135
   if(len <= 2)
37
0
      return len;
38
135
39
135
   const size_t padding_length = in[len-1];
40
135
41
135
   if(padding_length == 0 || padding_length > len)
42
51
      return len;
43
84
   const size_t padding_start = len - padding_length;
44
84
45
292
   for(size_t i = padding_start; i != len - 1; ++i)
46
284
      {
47
284
      if(in[i] != 0)
48
76
         {
49
76
         return len;
50
76
         }
51
284
      }
52
84
53
84
   return len - padding_length;
54
84
   }
55
56
size_t ref_oneandzero_unpad(const uint8_t in[], size_t len)
57
192
   {
58
192
   if(len <= 2)
59
0
      return len;
60
192
61
192
   size_t idx = len - 1;
62
192
63
192
   for(;;)
64
1.49k
      {
65
1.49k
      if(in[idx] == 0)
66
1.30k
         {
67
1.30k
         if(idx == 0)
68
5
            return len;
69
1.30k
         idx -= 1;
70
1.30k
         continue;
71
1.30k
         }
72
187
      else if(in[idx] == 0x80)
73
5
         {
74
5
         return idx;
75
5
         }
76
182
      else
77
182
         return len;
78
1.49k
      }
79
192
80
192
   return len;
81
192
   }
82
83
size_t ref_esp_unpad(const uint8_t in[], size_t len)
84
135
   {
85
135
   if(len <= 2)
86
0
      return len;
87
135
88
135
   const size_t padding_bytes = in[len - 1];
89
135
90
135
   if(padding_bytes == 0 || padding_bytes > len)
91
51
      {
92
51
      return len;
93
51
      }
94
84
95
84
   const size_t padding_start = len - padding_bytes;
96
214
   for(size_t i = padding_start; i != len; ++i)
97
207
      {
98
207
      if(in[i] != (i - padding_start + 1))
99
77
         {
100
77
         return len;
101
77
         }
102
207
      }
103
84
104
84
   return len - padding_bytes;
105
84
   }
106
107
uint16_t ref_tls_cbc_unpad(const uint8_t in[], size_t len)
108
217
   {
109
217
   if(len == 0)
110
0
      return 0;
111
217
112
217
   const size_t padding_length = in[(len-1)];
113
217
114
217
   if(padding_length >= len)
115
83
      return 0;
116
134
117
134
   /*
118
134
   * TLS v1.0 and up require all the padding bytes be the same value
119
134
   * and allows up to 255 bytes.
120
134
   */
121
531
   for(size_t i = 0; i != 1 + padding_length; ++i)
122
480
      {
123
480
      if(in[(len-i-1)] != padding_length)
124
83
         return 0;
125
480
      }
126
134
   return padding_length + 1;
127
134
   }
128
129
}
130
131
void fuzz(const uint8_t in[], size_t len)
132
217
   {
133
217
   static Botan::PKCS7_Padding pkcs7;
134
217
   static Botan::ANSI_X923_Padding x923;
135
217
   static Botan::OneAndZeros_Padding oneandzero;
136
217
   static Botan::ESP_Padding esp;
137
217
138
217
   if(pkcs7.valid_blocksize(len))
139
135
      {
140
135
      const size_t ct_pkcs7 = pkcs7.unpad(in, len);
141
135
      const size_t ref_pkcs7 = ref_pkcs7_unpad(in, len);
142
135
      FUZZER_ASSERT_EQUAL(ct_pkcs7, ref_pkcs7);
143
135
      }
144
217
145
217
   if(x923.valid_blocksize(len))
146
135
      {
147
135
      const size_t ct_x923 = x923.unpad(in, len);
148
135
      const size_t ref_x923 = ref_x923_unpad(in, len);
149
135
      FUZZER_ASSERT_EQUAL(ct_x923, ref_x923);
150
135
      }
151
217
152
217
   if(oneandzero.valid_blocksize(len))
153
192
      {
154
192
      const size_t ct_oneandzero = oneandzero.unpad(in, len);
155
192
      const size_t ref_oneandzero = ref_oneandzero_unpad(in, len);
156
192
      FUZZER_ASSERT_EQUAL(ct_oneandzero, ref_oneandzero);
157
192
      }
158
217
159
217
   if(esp.valid_blocksize(len))
160
135
      {
161
135
      const size_t ct_esp = esp.unpad(in, len);
162
135
      const size_t ref_esp = ref_esp_unpad(in, len);
163
135
      FUZZER_ASSERT_EQUAL(ct_esp, ref_esp);
164
135
      }
165
217
166
217
   const uint16_t ct_cbc = Botan::TLS::check_tls_cbc_padding(in, len);
167
217
   const uint16_t ref_cbc = ref_tls_cbc_unpad(in, len);
168
217
   FUZZER_ASSERT_EQUAL(ct_cbc, ref_cbc);
169
217
   }