static int create_random_split (struct rspamd_cryptobox_segment *seg, int mseg, guchar *begin, guchar *end) { gsize remain = end - begin; gint used = 0; while (remain > 0 && used < mseg - 1) { seg->data = begin; seg->len = ottery_rand_range (remain - 1) + 1; begin += seg->len; remain -= seg->len; used ++; seg ++; } if (remain > 0) { seg->data = begin; seg->len = remain; used ++; } return used; }
static int create_realistic_split (struct rspamd_cryptobox_segment *seg, int mseg, guchar *begin, guchar *end) { gsize remain = end - begin; gint used = 0; static const int small_seg = 512, medium_seg = 2048; while (remain > 0 && used < mseg - 1) { seg->data = begin; if (ottery_rand_uint32 () % 2 == 0) { seg->len = ottery_rand_range (small_seg) + 1; } else { seg->len = ottery_rand_range (medium_seg) + small_seg; } if (seg->len > remain) { seg->len = remain; } begin += seg->len; remain -= seg->len; used ++; seg ++; } if (remain > 0) { seg->data = begin; seg->len = remain; used ++; } return used; }
void rspamd_radix_test_func (void) { #if 0 radix_tree_t *tree = radix_tree_create (); #endif radix_compressed_t *comp_tree = radix_create_compressed (); struct { guint32 addr; guint32 mask; guint8 addr6[16]; guint32 mask6; } *addrs; gsize nelts, i; gint lc; gboolean all_good = TRUE; gdouble ts1, ts2; double diff; /* Test suite for the compressed trie */ rspamd_radix_text_vec (); nelts = max_elts; /* First of all we generate many elements and push them to the array */ addrs = g_malloc (nelts * sizeof (addrs[0])); for (i = 0; i < nelts; i ++) { addrs[i].addr = ottery_rand_uint32 (); addrs[i].mask = masks[ottery_rand_range(G_N_ELEMENTS (masks) - 1)]; ottery_rand_bytes (addrs[i].addr6, sizeof(addrs[i].addr6)); addrs[i].mask6 = ottery_rand_range(128); } #if 0 msg_info ("old radix performance (%z elts)", nelts); ts1 = rspamd_get_ticks (); for (i = 0; i < nelts; i ++) { guint32 mask = G_MAXUINT32 << (32 - addrs[i].mask); radix32tree_insert (tree, addrs[i].addr, mask, 1); } ts2 = rspamd_get_ticks (); diff = (ts2 - ts1) * 1000.0; msg_info ("Added %z elements in %.6f ms", nelts, diff); ts1 = rspamd_get_ticks (); for (lc = 0; lc < lookup_cycles; lc ++) { for (i = 0; i < nelts; i ++) { g_assert (radix32tree_find (tree, addrs[i].addr) != RADIX_NO_VALUE); } } ts2 = rspamd_get_ticks (); diff = (ts2 - ts1) * 1000.0; msg_info ("Checked %z elements in %.6f ms", nelts, diff); ts1 = rspamd_get_ticks (); for (i = 0; i < nelts; i ++) { radix32tree_delete (tree, addrs[i].addr, addrs[i].mask); } ts2 = rspamd_get_ticks (); diff = (ts2 - ts1) * 1000.; msg_info ("Deleted %z elements in %.6f ms", nelts, diff); radix_tree_free (tree); #endif msg_info ("new radix performance (%z elts)", nelts); ts1 = rspamd_get_ticks (); for (i = 0; i < nelts; i ++) { radix_insert_compressed (comp_tree, addrs[i].addr6, sizeof (addrs[i].addr6), 128 - addrs[i].mask6, i); } ts2 = rspamd_get_ticks (); diff = (ts2 - ts1) * 1000.0; msg_info ("Added %z elements in %.6f ms", nelts, diff); ts1 = rspamd_get_ticks (); for (lc = 0; lc < lookup_cycles; lc ++) { for (i = 0; i < nelts; i ++) { if (radix_find_compressed (comp_tree, addrs[i].addr6, sizeof (addrs[i].addr6)) == RADIX_NO_VALUE) { all_good = FALSE; } } } #if 1 if (!all_good) { for (i = 0; i < nelts; i ++) { /* Used to write bad random vector */ char ipbuf[INET6_ADDRSTRLEN + 1]; inet_ntop(AF_INET6, addrs[i].addr6, ipbuf, sizeof(ipbuf)); msg_info("{\"%s\", NULL, \"%ud\", 0, 0, 0, 0},", ipbuf, addrs[i].mask6); } } #endif g_assert (all_good); ts2 = rspamd_get_ticks (); diff = (ts2 - ts1) * 1000.0; msg_info ("Checked %z elements in %.6f ms", nelts, diff); radix_destroy_compressed (comp_tree); g_free (addrs); }
void rspamd_http_test_func (void) { struct event_base *ev_base = event_init (); rspamd_mempool_t *pool = rspamd_mempool_new (rspamd_mempool_suggest_size ()); gpointer serv_key, client_key, peer_key; struct rspamd_keypair_cache *c; rspamd_mempool_mutex_t *mtx; rspamd_inet_addr_t addr; struct timespec ts1, ts2; gchar filepath[PATH_MAX], buf[512]; gint fd, i, j; pid_t sfd; GString *b32_key; double diff, total_diff = 0.0, latency[pconns * ntests], mean, std; rspamd_cryptobox_init (); rspamd_snprintf (filepath, sizeof (filepath), "/tmp/http-test-XXXXXX"); g_assert ((fd = mkstemp (filepath)) != -1); for (i = 0; i < file_blocks; i ++) { memset (buf, 0, sizeof (buf)); g_assert (write (fd, buf, sizeof (buf)) == sizeof (buf)); } mtx = rspamd_mempool_get_mutex (pool); rspamd_parse_inet_address (&addr, "127.0.0.1"); rspamd_inet_address_set_port (&addr, ottery_rand_range (30000) + 32768); serv_key = rspamd_http_connection_gen_key (); client_key = rspamd_http_connection_gen_key (); c = rspamd_keypair_cache_new (16); rspamd_mempool_lock_mutex (mtx); sfd = fork (); g_assert (sfd != -1); if (sfd == 0) { rspamd_http_server_func ("/tmp/", &addr, mtx, serv_key, c); exit (EXIT_SUCCESS); } rspamd_mempool_lock_mutex (mtx); /* Do client stuff */ for (i = 0; i < ntests; i ++) { for (j = 0; j < pconns; j ++) { rspamd_http_client_func (filepath + sizeof ("/tmp") - 1, &addr, NULL, NULL, c, ev_base, &latency[i * pconns + j]); } clock_gettime (CLOCK_MONOTONIC, &ts1); event_base_loop (ev_base, 0); clock_gettime (CLOCK_MONOTONIC, &ts2); diff = (ts2.tv_sec - ts1.tv_sec) * 1000. + /* Seconds */ (ts2.tv_nsec - ts1.tv_nsec) / 1000000.; /* Nanoseconds */ total_diff += diff; } msg_info ("Made %d connections of size %d in %.6f ms, %.6f cps", ntests * pconns, sizeof (buf) * file_blocks, total_diff, ntests * pconns / total_diff * 1000.); mean = rspamd_http_calculate_mean (latency, &std); msg_info ("Latency: %.6f ms mean, %.6f dev", mean, std); /* Now test encrypted */ b32_key = rspamd_http_connection_print_key (serv_key, RSPAMD_KEYPAIR_PUBKEY|RSPAMD_KEYPAIR_BASE32); g_assert (b32_key != NULL); peer_key = rspamd_http_connection_make_peer_key (b32_key->str); g_assert (peer_key != NULL); total_diff = 0.0; for (i = 0; i < ntests; i ++) { for (j = 0; j < pconns; j ++) { rspamd_http_client_func (filepath + sizeof ("/tmp") - 1, &addr, client_key, peer_key, c, ev_base, &latency[i * pconns + j]); } clock_gettime (CLOCK_MONOTONIC, &ts1); event_base_loop (ev_base, 0); clock_gettime (CLOCK_MONOTONIC, &ts2); diff = (ts2.tv_sec - ts1.tv_sec) * 1000. + /* Seconds */ (ts2.tv_nsec - ts1.tv_nsec) / 1000000.; /* Nanoseconds */ total_diff += diff; } msg_info ("Made %d encrypted connections of size %d in %.6f ms, %.6f cps", ntests * pconns, sizeof (buf) * file_blocks, total_diff, ntests * pconns / total_diff * 1000.); mean = rspamd_http_calculate_mean (latency, &std); msg_info ("Latency: %.6f ms mean, %.6f dev", mean, std); /* Restart server */ kill (sfd, SIGTERM); wait (&i); sfd = fork (); g_assert (sfd != -1); if (sfd == 0) { rspamd_http_server_func ("/tmp/", &addr, mtx, serv_key, NULL); exit (EXIT_SUCCESS); } rspamd_mempool_lock_mutex (mtx); total_diff = 0.0; for (i = 0; i < ntests; i ++) { for (j = 0; j < pconns; j ++) { rspamd_http_client_func (filepath + sizeof ("/tmp") - 1, &addr, client_key, peer_key, c, ev_base, &latency[i * pconns + j]); } clock_gettime (CLOCK_MONOTONIC, &ts1); event_base_loop (ev_base, 0); clock_gettime (CLOCK_MONOTONIC, &ts2); diff = (ts2.tv_sec - ts1.tv_sec) * 1000. + /* Seconds */ (ts2.tv_nsec - ts1.tv_nsec) / 1000000.; /* Nanoseconds */ total_diff += diff; } msg_info ("Made %d uncached encrypted connections of size %d in %.6f ms, %.6f cps", ntests * pconns, sizeof (buf) * file_blocks, total_diff, ntests * pconns / total_diff * 1000.); mean = rspamd_http_calculate_mean (latency, &std); msg_info ("Latency: %.6f ms mean, %.6f dev", mean, std); close (fd); unlink (filepath); kill (sfd, SIGTERM); }
void rspamd_cryptobox_test_func (void) { void *map; guchar *begin, *end; rspamd_nm_t key; rspamd_nonce_t nonce; rspamd_sig_t mac; struct rspamd_cryptobox_segment *seg; double t1, t2; gint i, cnt, ms; map = create_mapping (mapping_size, &begin, &end); ottery_rand_bytes (key, sizeof (key)); ottery_rand_bytes (nonce, sizeof (nonce)); memset (mac, 0, sizeof (mac)); seg = g_slice_alloc0 (sizeof (*seg) * max_seg * 10); /* Test baseline */ t1 = rspamd_get_ticks (); rspamd_cryptobox_encrypt_nm_inplace (begin, end - begin, nonce, key, mac); t2 = rspamd_get_ticks (); check_result (key, nonce, mac, begin, end); msg_info ("baseline encryption: %.6f", t2 - t1); /* A single chunk as vector */ seg[0].data = begin; seg[0].len = end - begin; t1 = rspamd_get_ticks (); rspamd_cryptobox_encryptv_nm_inplace (seg, 1, nonce, key, mac); t2 = rspamd_get_ticks (); check_result (key, nonce, mac, begin, end); msg_info ("bulk encryption: %.6f", t2 - t1); /* Two chunks as vector */ seg[0].data = begin; seg[0].len = (end - begin) / 2; seg[1].data = begin + seg[0].len; seg[1].len = (end - begin) - seg[0].len; t1 = rspamd_get_ticks (); rspamd_cryptobox_encryptv_nm_inplace (seg, 2, nonce, key, mac); t2 = rspamd_get_ticks (); check_result (key, nonce, mac, begin, end); msg_info ("2 equal chunks encryption: %.6f", t2 - t1); seg[0].data = begin; seg[0].len = 1; seg[1].data = begin + seg[0].len; seg[1].len = (end - begin) - seg[0].len; t1 = rspamd_get_ticks (); rspamd_cryptobox_encryptv_nm_inplace (seg, 2, nonce, key, mac); t2 = rspamd_get_ticks (); check_result (key, nonce, mac, begin, end); msg_info ("small and large chunks encryption: %.6f", t2 - t1); seg[0].data = begin; seg[0].len = (end - begin) - 3; seg[1].data = begin + seg[0].len; seg[1].len = (end - begin) - seg[0].len; t1 = rspamd_get_ticks (); rspamd_cryptobox_encryptv_nm_inplace (seg, 2, nonce, key, mac); t2 = rspamd_get_ticks (); check_result (key, nonce, mac, begin, end); msg_info ("large and small chunks encryption: %.6f", t2 - t1); /* Random two chunks as vector */ seg[0].data = begin; seg[0].len = ottery_rand_range (end - begin - 1) + 1; seg[1].data = begin + seg[0].len; seg[1].len = (end - begin) - seg[0].len; t1 = rspamd_get_ticks (); rspamd_cryptobox_encryptv_nm_inplace (seg, 2, nonce, key, mac); t2 = rspamd_get_ticks (); check_result (key, nonce, mac, begin, end); msg_info ("random 2 chunks encryption: %.6f", t2 - t1); /* 3 specific chunks */ seg[0].data = begin; seg[0].len = 2; seg[1].data = begin + seg[0].len; seg[1].len = 2049; seg[2].data = begin + seg[0].len + seg[1].len; seg[2].len = (end - begin) - seg[0].len - seg[1].len; t1 = rspamd_get_ticks (); rspamd_cryptobox_encryptv_nm_inplace (seg, 3, nonce, key, mac); t2 = rspamd_get_ticks (); check_result (key, nonce, mac, begin, end); msg_info ("small, medium and large chunks encryption: %.6f", t2 - t1); cnt = create_random_split (seg, max_seg, begin, end); t1 = rspamd_get_ticks (); rspamd_cryptobox_encryptv_nm_inplace (seg, cnt, nonce, key, mac); t2 = rspamd_get_ticks (); check_result (key, nonce, mac, begin, end); msg_info ("random split of %d chunks encryption: %.6f", cnt, t2 - t1); cnt = create_realistic_split (seg, max_seg, begin, end); t1 = rspamd_get_ticks (); rspamd_cryptobox_encryptv_nm_inplace (seg, cnt, nonce, key, mac); t2 = rspamd_get_ticks (); check_result (key, nonce, mac, begin, end); msg_info ("realistic split of %d chunks encryption: %.6f", cnt, t2 - t1); cnt = create_constrainted_split (seg, max_seg + 1, 32, begin, end); t1 = rspamd_get_ticks (); rspamd_cryptobox_encryptv_nm_inplace (seg, cnt, nonce, key, mac); t2 = rspamd_get_ticks (); check_result (key, nonce, mac, begin, end); msg_info ("constrainted split of %d chunks encryption: %.6f", cnt, t2 - t1); for (i = 0; i < random_fuzz_cnt; i ++) { ms = ottery_rand_range (i % max_seg * 2) + 1; cnt = create_random_split (seg, ms, begin, end); t1 = rspamd_get_ticks (); rspamd_cryptobox_encryptv_nm_inplace (seg, cnt, nonce, key, mac); t2 = rspamd_get_ticks (); check_result (key, nonce, mac, begin, end); if (i % 1000 == 0) { msg_info ("random fuzz iterations: %d", i); } } for (i = 0; i < random_fuzz_cnt; i ++) { ms = ottery_rand_range (i % max_seg * 2) + 1; cnt = create_realistic_split (seg, ms, begin, end); t1 = rspamd_get_ticks (); rspamd_cryptobox_encryptv_nm_inplace (seg, cnt, nonce, key, mac); t2 = rspamd_get_ticks (); check_result (key, nonce, mac, begin, end); if (i % 1000 == 0) { msg_info ("realistic fuzz iterations: %d", i); } } for (i = 0; i < random_fuzz_cnt; i ++) { ms = ottery_rand_range (i % max_seg * 10) + 1; cnt = create_constrainted_split (seg, ms, i, begin, end); t1 = rspamd_get_ticks (); rspamd_cryptobox_encryptv_nm_inplace (seg, cnt, nonce, key, mac); t2 = rspamd_get_ticks (); check_result (key, nonce, mac, begin, end); if (i % 1000 == 0) { msg_info ("constrainted fuzz iterations: %d", i); } } }