fuzzing_common.c 4.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192
  1. /* Copyright (c) 2016-2017, The Tor Project, Inc. */
  2. /* See LICENSE for licensing information */
  3. #define CRYPTO_ED25519_PRIVATE
  4. #include "orconfig.h"
  5. #include "or.h"
  6. #include "backtrace.h"
  7. #include "config.h"
  8. #include "fuzzing.h"
  9. #include "crypto.h"
  10. #include "crypto_ed25519.h"
  11. static or_options_t *mock_options = NULL;
  12. static const or_options_t *
  13. mock_get_options(void)
  14. {
  15. return mock_options;
  16. }
  17. static int
  18. mock_crypto_pk_public_checksig__nocheck(const crypto_pk_t *env, char *to,
  19. size_t tolen,
  20. const char *from, size_t fromlen)
  21. {
  22. tor_assert(env && to && from);
  23. (void)fromlen;
  24. /* We could look at from[0..fromlen-1] ... */
  25. tor_assert(tolen >= crypto_pk_keysize(env));
  26. size_t siglen = MIN(20, crypto_pk_keysize(env));
  27. memset(to, 0x01, siglen);
  28. return (int)siglen;
  29. }
  30. static int
  31. mock_crypto_pk_public_checksig_digest__nocheck(crypto_pk_t *env,
  32. const char *data,
  33. size_t datalen,
  34. const char *sig,
  35. size_t siglen)
  36. {
  37. tor_assert(env && data && sig);
  38. (void)datalen;
  39. (void)siglen;
  40. /* We could look at data[..] and sig[..] */
  41. return 0;
  42. }
  43. static int
  44. mock_ed25519_checksig__nocheck(const ed25519_signature_t *signature,
  45. const uint8_t *msg, size_t len,
  46. const ed25519_public_key_t *pubkey)
  47. {
  48. tor_assert(signature && msg && pubkey);
  49. /* We could look at msg[0..len-1] ... */
  50. (void)len;
  51. return 0;
  52. }
  53. static int
  54. mock_ed25519_checksig_batch__nocheck(int *okay_out,
  55. const ed25519_checkable_t *checkable,
  56. int n_checkable)
  57. {
  58. tor_assert(checkable);
  59. int i;
  60. for (i = 0; i < n_checkable; ++i) {
  61. /* We could look at messages and signatures XXX */
  62. tor_assert(checkable[i].pubkey);
  63. tor_assert(checkable[i].msg);
  64. if (okay_out)
  65. okay_out[i] = 1;
  66. }
  67. return 0;
  68. }
  69. static int
  70. mock_ed25519_impl_spot_check__nocheck(void)
  71. {
  72. return 0;
  73. }
  74. void
  75. disable_signature_checking(void)
  76. {
  77. MOCK(crypto_pk_public_checksig,
  78. mock_crypto_pk_public_checksig__nocheck);
  79. MOCK(crypto_pk_public_checksig_digest,
  80. mock_crypto_pk_public_checksig_digest__nocheck);
  81. MOCK(ed25519_checksig, mock_ed25519_checksig__nocheck);
  82. MOCK(ed25519_checksig_batch, mock_ed25519_checksig_batch__nocheck);
  83. MOCK(ed25519_impl_spot_check, mock_ed25519_impl_spot_check__nocheck);
  84. }
  85. static void
  86. global_init(void)
  87. {
  88. tor_threads_init();
  89. tor_compress_init();
  90. {
  91. struct sipkey sipkey = { 1337, 7331 };
  92. siphash_set_global_key(&sipkey);
  93. }
  94. /* Initialise logging first */
  95. init_logging(1);
  96. configure_backtrace_handler(get_version());
  97. /* set up the options. */
  98. mock_options = tor_malloc_zero(sizeof(or_options_t));
  99. MOCK(get_options, mock_get_options);
  100. /* Make BUG() and nonfatal asserts crash */
  101. tor_set_failed_assertion_callback(abort);
  102. /* Make protocol warnings handled correctly. */
  103. init_protocol_warning_severity_level();
  104. }
  105. #ifdef LLVM_FUZZ
  106. int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size);
  107. int
  108. LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size)
  109. {
  110. static int initialized = 0;
  111. if (!initialized) {
  112. global_init();
  113. if (fuzz_init() < 0)
  114. abort();
  115. initialized = 1;
  116. }
  117. return fuzz_main(Data, Size);
  118. }
  119. #else /* Not LLVM_FUZZ, so AFL. */
  120. int
  121. main(int argc, char **argv)
  122. {
  123. size_t size;
  124. global_init();
  125. /* Disable logging by default to speed up fuzzing. */
  126. int loglevel = LOG_ERR;
  127. for (int i = 1; i < argc; ++i) {
  128. if (!strcmp(argv[i], "--warn")) {
  129. loglevel = LOG_WARN;
  130. } else if (!strcmp(argv[i], "--notice")) {
  131. loglevel = LOG_NOTICE;
  132. } else if (!strcmp(argv[i], "--info")) {
  133. loglevel = LOG_INFO;
  134. } else if (!strcmp(argv[i], "--debug")) {
  135. loglevel = LOG_DEBUG;
  136. }
  137. }
  138. {
  139. log_severity_list_t s;
  140. memset(&s, 0, sizeof(s));
  141. set_log_severity_config(loglevel, LOG_ERR, &s);
  142. /* ALWAYS log bug warnings. */
  143. s.masks[LOG_WARN-LOG_ERR] |= LD_BUG;
  144. add_stream_log(&s, "", fileno(stdout));
  145. }
  146. if (fuzz_init() < 0)
  147. abort();
  148. #ifdef __AFL_HAVE_MANUAL_CONTROL
  149. /* Tell AFL to pause and fork here - ignored if not using AFL */
  150. __AFL_INIT();
  151. #endif
  152. #define MAX_FUZZ_SIZE (128*1024)
  153. char *input = read_file_to_str_until_eof(0, MAX_FUZZ_SIZE, &size);
  154. tor_assert(input);
  155. char *raw = tor_memdup(input, size); /* Because input is nul-terminated */
  156. tor_free(input);
  157. fuzz_main((const uint8_t*)raw, size);
  158. tor_free(raw);
  159. if (fuzz_cleanup() < 0)
  160. abort();
  161. tor_free(mock_options);
  162. UNMOCK(get_options);
  163. return 0;
  164. }
  165. #endif