1 //===- FuzzerUtil.cpp - Misc utils ----------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // Misc utils. 9 //===----------------------------------------------------------------------===// 10 11 #include "FuzzerUtil.h" 12 #include "FuzzerIO.h" 13 #include "FuzzerInternal.h" 14 #include <cassert> 15 #include <chrono> 16 #include <cstring> 17 #include <errno.h> 18 #include <mutex> 19 #include <signal.h> 20 #include <sstream> 21 #include <stdio.h> 22 #include <sys/types.h> 23 #include <thread> 24 25 namespace fuzzer { 26 27 void PrintHexArray(const uint8_t *Data, size_t Size, 28 const char *PrintAfter) { 29 for (size_t i = 0; i < Size; i++) 30 Printf("0x%x,", (unsigned)Data[i]); 31 Printf("%s", PrintAfter); 32 } 33 34 void Print(const Unit &v, const char *PrintAfter) { 35 PrintHexArray(v.data(), v.size(), PrintAfter); 36 } 37 38 void PrintASCIIByte(uint8_t Byte) { 39 if (Byte == '\\') 40 Printf("\\\\"); 41 else if (Byte == '"') 42 Printf("\\\""); 43 else if (Byte >= 32 && Byte < 127) 44 Printf("%c", Byte); 45 else 46 Printf("\\%03o", Byte); 47 } 48 49 void PrintASCII(const uint8_t *Data, size_t Size, const char *PrintAfter) { 50 for (size_t i = 0; i < Size; i++) 51 PrintASCIIByte(Data[i]); 52 Printf("%s", PrintAfter); 53 } 54 55 void PrintASCII(const Unit &U, const char *PrintAfter) { 56 PrintASCII(U.data(), U.size(), PrintAfter); 57 } 58 59 bool ToASCII(uint8_t *Data, size_t Size) { 60 bool Changed = false; 61 for (size_t i = 0; i < Size; i++) { 62 uint8_t &X = Data[i]; 63 auto NewX = X; 64 NewX &= 127; 65 if (!isspace(NewX) && !isprint(NewX)) 66 NewX = ' '; 67 Changed |= NewX != X; 68 X = NewX; 69 } 70 return Changed; 71 } 72 73 bool IsASCII(const Unit &U) { return IsASCII(U.data(), U.size()); } 74 75 bool IsASCII(const uint8_t *Data, size_t Size) { 76 for (size_t i = 0; i < Size; i++) 77 if (!(isprint(Data[i]) || isspace(Data[i]))) return false; 78 return true; 79 } 80 81 bool ParseOneDictionaryEntry(const std::string &Str, Unit *U) { 82 U->clear(); 83 if (Str.empty()) return false; 84 size_t L = 0, R = Str.size() - 1; // We are parsing the range [L,R]. 85 // Skip spaces from both sides. 86 while (L < R && isspace(Str[L])) L++; 87 while (R > L && isspace(Str[R])) R--; 88 if (R - L < 2) return false; 89 // Check the closing " 90 if (Str[R] != '"') return false; 91 R--; 92 // Find the opening " 93 while (L < R && Str[L] != '"') L++; 94 if (L >= R) return false; 95 assert(Str[L] == '\"'); 96 L++; 97 assert(L <= R); 98 for (size_t Pos = L; Pos <= R; Pos++) { 99 uint8_t V = (uint8_t)Str[Pos]; 100 if (!isprint(V) && !isspace(V)) return false; 101 if (V =='\\') { 102 // Handle '\\' 103 if (Pos + 1 <= R && (Str[Pos + 1] == '\\' || Str[Pos + 1] == '"')) { 104 U->push_back(Str[Pos + 1]); 105 Pos++; 106 continue; 107 } 108 // Handle '\xAB' 109 if (Pos + 3 <= R && Str[Pos + 1] == 'x' 110 && isxdigit(Str[Pos + 2]) && isxdigit(Str[Pos + 3])) { 111 char Hex[] = "0xAA"; 112 Hex[2] = Str[Pos + 2]; 113 Hex[3] = Str[Pos + 3]; 114 U->push_back(static_cast<uint8_t>(strtol(Hex, nullptr, 16))); 115 Pos += 3; 116 continue; 117 } 118 return false; // Invalid escape. 119 } else { 120 // Any other character. 121 U->push_back(V); 122 } 123 } 124 return true; 125 } 126 127 bool ParseDictionaryFile(const std::string &Text, std::vector<Unit> *Units) { 128 if (Text.empty()) { 129 Printf("ParseDictionaryFile: file does not exist or is empty\n"); 130 return false; 131 } 132 std::istringstream ISS(Text); 133 Units->clear(); 134 Unit U; 135 int LineNo = 0; 136 std::string S; 137 while (std::getline(ISS, S, '\n')) { 138 LineNo++; 139 size_t Pos = 0; 140 while (Pos < S.size() && isspace(S[Pos])) Pos++; // Skip spaces. 141 if (Pos == S.size()) continue; // Empty line. 142 if (S[Pos] == '#') continue; // Comment line. 143 if (ParseOneDictionaryEntry(S, &U)) { 144 Units->push_back(U); 145 } else { 146 Printf("ParseDictionaryFile: error in line %d\n\t\t%s\n", LineNo, 147 S.c_str()); 148 return false; 149 } 150 } 151 return true; 152 } 153 154 // Code duplicated (and tested) in llvm/include/llvm/Support/Base64.h 155 std::string Base64(const Unit &U) { 156 static const char Table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 157 "abcdefghijklmnopqrstuvwxyz" 158 "0123456789+/"; 159 std::string Buffer; 160 Buffer.resize(((U.size() + 2) / 3) * 4); 161 162 size_t i = 0, j = 0; 163 for (size_t n = U.size() / 3 * 3; i < n; i += 3, j += 4) { 164 uint32_t x = ((unsigned char)U[i] << 16) | ((unsigned char)U[i + 1] << 8) | 165 (unsigned char)U[i + 2]; 166 Buffer[j + 0] = Table[(x >> 18) & 63]; 167 Buffer[j + 1] = Table[(x >> 12) & 63]; 168 Buffer[j + 2] = Table[(x >> 6) & 63]; 169 Buffer[j + 3] = Table[x & 63]; 170 } 171 if (i + 1 == U.size()) { 172 uint32_t x = ((unsigned char)U[i] << 16); 173 Buffer[j + 0] = Table[(x >> 18) & 63]; 174 Buffer[j + 1] = Table[(x >> 12) & 63]; 175 Buffer[j + 2] = '='; 176 Buffer[j + 3] = '='; 177 } else if (i + 2 == U.size()) { 178 uint32_t x = ((unsigned char)U[i] << 16) | ((unsigned char)U[i + 1] << 8); 179 Buffer[j + 0] = Table[(x >> 18) & 63]; 180 Buffer[j + 1] = Table[(x >> 12) & 63]; 181 Buffer[j + 2] = Table[(x >> 6) & 63]; 182 Buffer[j + 3] = '='; 183 } 184 return Buffer; 185 } 186 187 static std::mutex SymbolizeMutex; 188 189 std::string DescribePC(const char *SymbolizedFMT, uintptr_t PC) { 190 std::unique_lock<std::mutex> l(SymbolizeMutex, std::try_to_lock); 191 if (!EF->__sanitizer_symbolize_pc || !l.owns_lock()) 192 return "<can not symbolize>"; 193 char PcDescr[1024] = {}; 194 EF->__sanitizer_symbolize_pc(reinterpret_cast<void*>(PC), 195 SymbolizedFMT, PcDescr, sizeof(PcDescr)); 196 PcDescr[sizeof(PcDescr) - 1] = 0; // Just in case. 197 return PcDescr; 198 } 199 200 void PrintPC(const char *SymbolizedFMT, const char *FallbackFMT, uintptr_t PC) { 201 if (EF->__sanitizer_symbolize_pc) 202 Printf("%s", DescribePC(SymbolizedFMT, PC).c_str()); 203 else 204 Printf(FallbackFMT, PC); 205 } 206 207 void PrintStackTrace() { 208 std::unique_lock<std::mutex> l(SymbolizeMutex, std::try_to_lock); 209 if (EF->__sanitizer_print_stack_trace && l.owns_lock()) 210 EF->__sanitizer_print_stack_trace(); 211 } 212 213 void PrintMemoryProfile() { 214 std::unique_lock<std::mutex> l(SymbolizeMutex, std::try_to_lock); 215 if (EF->__sanitizer_print_memory_profile && l.owns_lock()) 216 EF->__sanitizer_print_memory_profile(95, 8); 217 } 218 219 unsigned NumberOfCpuCores() { 220 unsigned N = std::thread::hardware_concurrency(); 221 if (!N) { 222 Printf("WARNING: std::thread::hardware_concurrency not well defined for " 223 "your platform. Assuming CPU count of 1.\n"); 224 N = 1; 225 } 226 return N; 227 } 228 229 uint64_t SimpleFastHash(const void *Data, size_t Size, uint64_t Initial) { 230 uint64_t Res = Initial; 231 const uint8_t *Bytes = static_cast<const uint8_t *>(Data); 232 for (size_t i = 0; i < Size; i++) 233 Res = Res * 11 + Bytes[i]; 234 return Res; 235 } 236 237 } // namespace fuzzer 238