Coverage Report

Created: 2021-05-04 09:02

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