Coverage Report

Created: 2020-06-30 13:58

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