int main(int argc, char* argv[]) { LLVMFuzzerInitialize(&argc, &argv); if (argc < 2) { return LLVMFuzzerTestOneInput(" ", 1); } else { int nRet = 0; void* buf = NULL; int nLen = 0; FILE* f = fopen(argv[1], "rb"); if (!f) { fprintf(stderr, "%s does not exist.\n", argv[1]); exit(1); } fseek(f, 0, SEEK_END); nLen = (int)ftell(f); fseek(f, 0, SEEK_SET); buf = malloc(nLen); if (!buf) { fprintf(stderr, "malloc failed.\n"); fclose(f); exit(1); } if (fread(buf, nLen, 1, f) != 1) { fprintf(stderr, "fread failed.\n"); fclose(f); free(buf); exit(1); } fclose(f); nRet = LLVMFuzzerTestOneInput(buf, nLen); free(buf); return nRet; } }
int main(int argc, char* argv[]) { if( argc < 2 ) { const char str[] = "+proj=longlat +datum=WGS84 +nodefs\n+proj=longlat +datum=WGS84 +nodefs\n2 49"; int ret = LLVMFuzzerTestOneInput((const uint8_t*)(str), sizeof(str) - 1); if( ret ) return ret; const char str2[] = "+proj=longlat +datum=WGS84 +nodefs\n+proj=longlat +datum=WGS84 +nodefs\nBINARY_2D:\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFF"; ret = LLVMFuzzerTestOneInput((const uint8_t*)(str2), sizeof(str2) - 1); if( ret ) return ret; const char str3[] = "+proj=longlat +datum=WGS84 +nodefs\n+proj=longlat +datum=WGS84 +nodefs\nBINARY_3D:\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFF\x00\x00\x00\x00\x00\x00\x00\x00"; ret = LLVMFuzzerTestOneInput((const uint8_t*)(str3), sizeof(str3) - 1); if( ret ) return ret; return 0; } else { int nRet = 0; void* buf = NULL; int nLen = 0; FILE* f = fopen(argv[1], "rb"); if( !f ) { fprintf(stderr, "%s does not exist.\n", argv[1]); exit(1); } fseek(f, 0, SEEK_END); nLen = (int)ftell(f); fseek(f, 0, SEEK_SET); buf = malloc(nLen); if( !buf ) { fprintf(stderr, "malloc failed.\n"); fclose(f); exit(1); } fread(buf, nLen, 1, f); fclose(f); nRet = LLVMFuzzerTestOneInput((const uint8_t*)(buf), nLen); free(buf); return nRet; } }
int main(int argc, char *argv[]) { FILE *in = NULL; unsigned char *in_buf = NULL; uint64_t in_file_size; if (argc != 2) { fprintf(stderr, "Usage: isal_fuzz_inflate <infile>\n"); exit(1); } in = fopen(argv[1], "rb"); if (!in) { fprintf(stderr, "Can't open %s for reading\n", argv[1]); exit(1); } in_file_size = get_filesize(in); in_buf = malloc(in_file_size); if (in_buf == NULL) { fprintf(stderr, "Failed to malloc input and outputs buffers\n"); exit(1); } fread(in_buf, 1, in_file_size, in); return LLVMFuzzerTestOneInput(in_buf, in_file_size); }
int main(int argc, char **argv) { fprintf(stderr, "Running in AFl-fuzz mode\nUsage:\n" "afl-fuzz [afl-flags] %s [N] " "-- run N fuzzing iterations before " "re-spawning the process (default: 1000)\n", argv[0]); if (LLVMFuzzerInitialize) LLVMFuzzerInitialize(&argc, &argv); // Do any other expensive one-time initialization here. maybe_duplicate_stderr(); __afl_manual_init(); int N = 1000; if (argc >= 2) N = atoi(argv[1]); assert(N > 0); while (__afl_persistent_loop(N)) { ssize_t n_read = read(0, AflInputBuf, kMaxAflInputSize); if (n_read > 0) { // Copy AflInputBuf into a separate buffer to let asan find buffer // overflows. Don't use unique_ptr/etc to avoid extra dependencies. uint8_t *copy = new uint8_t[n_read]; memcpy(copy, AflInputBuf, n_read); LLVMFuzzerTestOneInput(copy, n_read); delete[] copy; } } }
int main(int argc, char **argv) { int i; for (i = 1; i < argc; i++) { size_t filesize = GetFileLength(argv[i]); FILE *stream = fopen(argv[i], "r"); unsigned char *text = NULL; if (stream == NULL) { perror(argv[i]); exit(EXIT_FAILURE); } text = (unsigned char *) malloc(filesize + 1); if (text == NULL) { espeak_ng_PrintStatusCodeMessage(ENOMEM, stderr, NULL); exit(EXIT_FAILURE); } fread(text, 1, filesize, stream); text[filesize] = 0; fclose(stream); LLVMFuzzerTestOneInput(text, filesize); free(text); } return EXIT_SUCCESS; }
int main() { const char szGEOJSON[] = "{ \"type\": \"FeatureCollection\", \"features\":[ { \"type\": \"Feature\", \"properties\": { \"AREA\": 5268.813, \"EAS_ID\": 170, \"PRFEDEA\": \"35043413\" }, \"geometry\": { \"type\": \"Polygon\", \"coordinates\": [ [ [ 479750.6875, 4764702.0 ], [ 479658.59375, 4764670.0 ], [ 479640.09375, 4764721.0 ], [ 479735.90625, 4764752.0 ], [ 479750.6875, 4764702.0 ] ] ] } } ] }"; LLVMFuzzerTestOneInput(reinterpret_cast<const uint8_t*>(szGEOJSON), strlen(szGEOJSON)); return 0; }
int main(int argc, char** argv) { assert(argc > 1); FILE *fd = fopen(argv[1], "rb"); fseek(fd, 0, SEEK_END); size_t needed = ftell(fd); char * data = malloc(needed); rewind(fd); fread(data, needed, 1, fd); return LLVMFuzzerTestOneInput(data, needed); }
int main(int argc, char **argv) { gpr_slice buffer; squelch = false; leak_check = false; GPR_ASSERT( GRPC_LOG_IF_ERROR("load_file", grpc_load_file(argv[1], 0, &buffer))); LLVMFuzzerTestOneInput(GPR_SLICE_START_PTR(buffer), GPR_SLICE_LENGTH(buffer)); gpr_slice_unref(buffer); return 0; }
int main(int argc, char** argv) { FILE* fp; uint8_t* Data; size_t Size; if (argc != 2) { return 1; } // opens the file, get its size, and reads it into a buffer fp = fopen(argv[1], "rb"); if (fp == NULL) { return 2; } if (fseek(fp, 0L, SEEK_END) != 0) { fclose(fp); return 2; } Size = ftell(fp); if (Size == (size_t)-1) { fclose(fp); return 2; } if (fseek(fp, 0L, SEEK_SET) != 0) { fclose(fp); return 2; } Data = (uint8_t*)malloc(Size); if (Data == NULL) { fclose(fp); return 2; } if (fread(Data, Size, 1, fp) != 1) { fclose(fp); return 2; } // lauch fuzzer LLVMFuzzerTestOneInput(Data, Size); fclose(fp); return 0; }
int main() { #ifdef __AFL_HAVE_MANUAL_CONTROL while (__AFL_LOOP(1000)) { #endif // copy stdin to byte vector std::vector<uint8_t> vec; char c; while (std::cin.get(c)) { vec.push_back(static_cast<uint8_t>(c)); } LLVMFuzzerTestOneInput(vec.data(), vec.size()); #ifdef __AFL_HAVE_MANUAL_CONTROL } #endif }
int main(int argc, char **argv) { fprintf(stderr, "StandaloneFuzzTargetMain: running %d inputs\n", argc - 1); LLVMFuzzerInitialize(&argc, &argv); for (int i = 1; i < argc; i++) { fprintf(stderr, "Running: %s\n", argv[i]); FILE *f = fopen(argv[i], "r"); assert(f); fseek(f, 0, SEEK_END); size_t len = ftell(f); fseek(f, 0, SEEK_SET); unsigned char *buf = (unsigned char*)malloc(len); size_t n_read = fread(buf, 1, len, f); assert(n_read == len); LLVMFuzzerTestOneInput(buf, len); free(buf); fprintf(stderr, "Done: %s: (%zd bytes)\n", argv[i], n_read); } }
int main(int argc, char **argv) { int i, j; for (i = 1; i < argc; i++) { char *name = argv[i]; ssize_t size; FILE *f = fopen(name, "rb"); char *buf; fprintf(stdout, "%s...\n", name); if (f == NULL) { perror("fopen() failed"); continue; } fseek(f, 0, SEEK_END); size = ftell(f); if (size < 0) { fclose(f); perror("ftell() failed"); continue; } fseek(f, 0, SEEK_SET); buf = malloc(size + 1); if (fread(buf, 1, size, f) != (size_t)size) { fclose(f); perror("fread() failed"); continue; } fclose(f); buf[size] = 0; for (j = 0; j < MIN_NUMBER_OF_RUNS; j++) { if (LLVMFuzzerTestOneInput((void *)buf, size) == EXIT_TEST_SKIP) { return EXIT_TEST_SKIP; } } free(buf); } return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { FILE *file = fopen("clusterfuzz-testcase", "r"); fseek(file, 0L, SEEK_END); long numbytes = ftell(file); fseek(file, 0L, SEEK_SET); uint8_t *buffer = (uint8_t*)calloc(numbytes, sizeof(uint8_t)); fread(buffer, sizeof(char), numbytes, file); fclose(file); while(true) { LLVMFuzzerTestOneInput(buffer, numbytes); } free(buffer); return 0; }
int main(int argc, char** argv) { FILE * fp; uint8_t Data[0x1000]; size_t Size; DIR *d; struct dirent *dir; int r = 0; int i; if (argc != 2) { return 1; } d = opendir(argv[1]); if (d == NULL) { printf("Invalid directory\n"); return 2; } if (chdir(argv[1]) != 0) { closedir(d); printf("Invalid directory\n"); return 2; } while((dir = readdir(d)) != NULL) { //opens the file, get its size, and reads it into a buffer if (dir->d_type != DT_REG) { continue; } printf("Running file %s ", dir->d_name); fflush(stdout); fp = fopen(dir->d_name, "rb"); if (fp == NULL) { r = 3; break; } if (fseek(fp, 0L, SEEK_END) != 0) { fclose(fp); r = 4; break; } Size = ftell(fp); if (Size == (size_t) -1) { fclose(fp); r = 5; break; } else if (Size > 0x1000) { fclose(fp); continue; } if (fseek(fp, 0L, SEEK_SET) != 0) { fclose(fp); r = 7; break; } if (fread(Data, Size, 1, fp) != 1) { fclose(fp); r = 8; break; } if (Size > 0) { printf("command cstool %s\n", get_platform_cstoolname(Data[0])); } for (i=0; i<Size; i++) { printf("%02x", Data[i]); } printf("\n"); //lauch fuzzer LLVMFuzzerTestOneInput(Data, Size); fclose(fp); } closedir(d); printf("Ok : whole directory finished\n"); return r; }
int main(int argc, char **argv) { int i; if (argc < 2) { printf("** No arguments given\n"); return 0; } for (i = 1; i < argc; i++) { size_t filelen; size_t readsize; unsigned char *buffer; FILE *f; /* Handle a literal string. Copy to an exact size buffer so that checks for overrunning work. */ if (argv[i][0] == '=') { readsize = strlen(argv[i]) - 1; printf("------ <Literal> ------\n"); printf("Length = %lu\n", readsize); printf("%.*s\n", (int)readsize, argv[i]+1); buffer = (unsigned char *)malloc(readsize); if (buffer == NULL) printf("** Failed to allocate %lu bytes of memory\n", readsize); else { memcpy(buffer, argv[i]+1, readsize); LLVMFuzzerTestOneInput(buffer, readsize); free(buffer); } continue; } /* Handle a string given in a file */ f = fopen(argv[i], "rb"); if (f == NULL) { printf("** Failed to open %s: %s\n", argv[i], strerror(errno)); continue; } printf("------ %s ------\n", argv[i]); fseek(f, 0, SEEK_END); filelen = ftell(f); fseek(f, 0, SEEK_SET); buffer = (unsigned char *)malloc(filelen); if (buffer == NULL) { printf("** Failed to allocate %lu bytes of memory\n", filelen); fclose(f); continue; } readsize = fread(buffer, 1, filelen, f); fclose(f); if (readsize != filelen) printf("** File size is %lu but fread() returned %lu\n", filelen, readsize); else { printf("Length = %lu\n", filelen); LLVMFuzzerTestOneInput(buffer, filelen); } free(buffer); } return 0; }
/* ** Read files named on the command-line and invoke the fuzzer for ** each one. */ int main(int argc, char **argv){ FILE *in; int i; int nErr = 0; uint8_t *zBuf = 0; size_t sz; unsigned mDebug = 0; for(i=1; i<argc; i++){ const char *zFilename = argv[i]; if( zFilename[0]=='-' ){ if( zFilename[1]=='-' ) zFilename++; if( strcmp(zFilename, "-show-errors")==0 ){ mDebug |= FUZZ_SHOW_ERRORS; ossfuzz_set_debug_flags(mDebug); }else if( strcmp(zFilename, "-show-max-delay")==0 ){ mDebug |= FUZZ_SHOW_MAX_DELAY; ossfuzz_set_debug_flags(mDebug); }else if( strcmp(zFilename, "-sql-trace")==0 ){ mDebug |= FUZZ_SQL_TRACE; ossfuzz_set_debug_flags(mDebug); }else { printf("unknown option \"%s\"\n", argv[i]); printf("should be one of: --show-errors --show-max-delay" " --sql-trace\n"); exit(1); } continue; } in = fopen(zFilename, "rb"); if( in==0 ){ fprintf(stderr, "cannot open \"%s\"\n", zFilename); nErr++; continue; } fseek(in, 0, SEEK_END); sz = ftell(in); rewind(in); zBuf = realloc(zBuf, sz); if( zBuf==0 ){ fprintf(stderr, "cannot malloc() for %d bytes\n", (int)sz); exit(1); } if( fread(zBuf, sz, 1, in)!=1 ){ fprintf(stderr, "cannot read %d bytes from \"%s\"\n", (int)sz, zFilename); nErr++; }else{ printf("%s... ", zFilename); if( mDebug ) printf("\n"); fflush(stdout); (void)LLVMFuzzerTestOneInput(zBuf, sz); if( mDebug ) printf("%s: ", zFilename); printf("ok\n"); } fclose(in); } free(zBuf); return nErr; }