1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
// Copyright 2015 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/strings/string_number_conversions.h"
#include <stddef.h>
#include <stdint.h>
#include <string>
#include <string_view>
#include <vector>
#include "base/check.h"
#include "base/check_op.h"
template <class NumberType, class StringPieceType, class StringType>
void CheckRoundtripsT(const uint8_t* data,
const size_t size,
StringType (*num_to_string)(NumberType),
bool (*string_to_num)(StringPieceType, NumberType*)) {
// Ensure we can read a NumberType from |data|
if (size < sizeof(NumberType)) {
return;
}
const NumberType v1 = *reinterpret_cast<const NumberType*>(data);
// Because we started with an arbitrary NumberType value, not an arbitrary
// string, we expect that the function |string_to_num| (e.g. StringToInt) will
// return true, indicating a perfect conversion.
NumberType v2;
CHECK(string_to_num(num_to_string(v1), &v2));
// Given that this was a perfect conversion, we expect the original NumberType
// value to equal the newly parsed one.
CHECK_EQ(v1, v2);
}
template <class NumberType>
void CheckRoundtrips(const uint8_t* data,
const size_t size,
bool (*string_to_num)(std::string_view, NumberType*)) {
return CheckRoundtripsT<NumberType, std::string_view, std::string>(
data, size, &base::NumberToString, string_to_num);
}
template <class NumberType>
void CheckRoundtrips16(const uint8_t* data,
const size_t size,
bool (*string_to_num)(std::u16string_view,
NumberType*)) {
return CheckRoundtripsT<NumberType, std::u16string_view, std::u16string>(
data, size, &base::NumberToString16, string_to_num);
}
// Entry point for LibFuzzer.
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
// For each instantiation of NumberToString f and its corresponding StringTo*
// function g, check that f(g(x)) = x holds for fuzzer-determined values of x.
CheckRoundtrips<int>(data, size, &base::StringToInt);
CheckRoundtrips16<int>(data, size, &base::StringToInt);
CheckRoundtrips<unsigned int>(data, size, &base::StringToUint);
CheckRoundtrips16<unsigned int>(data, size, &base::StringToUint);
CheckRoundtrips<int64_t>(data, size, &base::StringToInt64);
CheckRoundtrips16<int64_t>(data, size, &base::StringToInt64);
CheckRoundtrips<uint64_t>(data, size, &base::StringToUint64);
CheckRoundtrips16<uint64_t>(data, size, &base::StringToUint64);
CheckRoundtrips<size_t>(data, size, &base::StringToSizeT);
CheckRoundtrips16<size_t>(data, size, &base::StringToSizeT);
std::string_view string_piece_input(reinterpret_cast<const char*>(data),
size);
std::string string_input(reinterpret_cast<const char*>(data), size);
int out_int;
base::StringToInt(string_piece_input, &out_int);
unsigned out_uint;
base::StringToUint(string_piece_input, &out_uint);
int64_t out_int64;
base::StringToInt64(string_piece_input, &out_int64);
uint64_t out_uint64;
base::StringToUint64(string_piece_input, &out_uint64);
size_t out_size;
base::StringToSizeT(string_piece_input, &out_size);
// Test for std::u16string_view if size is even.
if (size % 2 == 0) {
std::u16string_view string_piece_input16(
reinterpret_cast<const char16_t*>(data), size / 2);
base::StringToInt(string_piece_input16, &out_int);
base::StringToUint(string_piece_input16, &out_uint);
base::StringToInt64(string_piece_input16, &out_int64);
base::StringToUint64(string_piece_input16, &out_uint64);
base::StringToSizeT(string_piece_input16, &out_size);
}
double out_double;
base::StringToDouble(string_input, &out_double);
base::HexStringToInt(string_piece_input, &out_int);
base::HexStringToUInt(string_piece_input, &out_uint);
base::HexStringToInt64(string_piece_input, &out_int64);
base::HexStringToUInt64(string_piece_input, &out_uint64);
std::vector<uint8_t> out_bytes;
base::HexStringToBytes(string_piece_input, &out_bytes);
base::HexEncode(data, size);
// Convert the numbers back to strings.
base::NumberToString(out_int);
base::NumberToString16(out_int);
base::NumberToString(out_uint);
base::NumberToString16(out_uint);
base::NumberToString(out_int64);
base::NumberToString16(out_int64);
base::NumberToString(out_uint64);
base::NumberToString16(out_uint64);
base::NumberToString(out_double);
base::NumberToString16(out_double);
return 0;
}
|
