inital public release

src/output_modules/module_extended_file.c

@@ -0,0 +1,109 @@
+/*
+ * ZMap Copyright 2013 Regents of the University of Michigan 
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <assert.h>
+
+#include <sys/time.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include "../../lib/logger.h"
+
+#include "output_modules.h"
+
+static FILE *file = NULL;
+#define UNUSED __attribute__((unused))
+
+int extendedfile_init(struct state_conf *conf)
+{
+	assert(conf);
+	if (conf->output_filename) {
+		if (!strcmp(conf->output_filename, "-")) {
+			file = stdout;
+		} else {
+			if (!(file = fopen(conf->output_filename, "w"))) {
+				perror("Couldn't open output file");
+				exit(EXIT_FAILURE);
+			}
+		}
+		fprintf(file, "response, saddr, daddr, sport, "
+						"dport, seq, ack, in_cooldown, is_repeat, timestamp\n");
+	}
+	return EXIT_SUCCESS;
+}
+
+static void fprint_tv(FILE *f, struct timeval *tv) 
+{
+	char time_string[40]; 
+	struct tm *ptm = localtime(&tv->tv_sec); 
+	strftime(time_string, sizeof (time_string),
+					"%Y-%m-%d %H:%M:%S", ptm);
+	long milliseconds = tv->tv_usec / 1000; 
+	fprintf(f, "%s.%03ld\n", time_string, milliseconds); 
+} 
+
+
+int extendedfile_ip(ipaddr_n_t saddr, ipaddr_n_t daddr,
+		const char *response_type, int is_repeat,
+		int in_cooldown, const u_char *packet, size_t buflen)
+{
+	struct iphdr *ip_hdr = (struct iphdr *)&packet[sizeof(struct ethhdr)];
+	if (buflen < (sizeof(struct ethhdr) + ip_hdr->ihl*4 + sizeof(struct tcphdr)))
+		return EXIT_FAILURE;
+	struct tcphdr *tcp = (struct tcphdr *)((char *)ip_hdr + ip_hdr->ihl * 4);
+
+	if (file) {
+		struct in_addr addr;
+		addr.s_addr = saddr;
+		// inet_ntoa returns a <<const>> char * 
+		fprintf(file, "%s, %s, ", 
+				response_type, 
+				inet_ntoa(addr));
+		addr.s_addr = daddr;
+		fprintf(file, "%s, %u, %u, %u, %u, %i, %i,", 
+				inet_ntoa(addr),
+				ntohs(tcp->source),
+				ntohs(tcp->dest),
+				ntohl(tcp->seq),
+				ntohl(tcp->ack_seq),
+				in_cooldown,
+				is_repeat);
+		struct timeval t;
+		gettimeofday(&t, NULL);
+		fprint_tv(file, &t);
+		fflush(file);
+	}
+	return EXIT_SUCCESS;
+}
+
+int extendedfile_close(UNUSED struct state_conf* c, 
+		UNUSED struct state_send* s, UNUSED struct state_recv* r)
+{
+	if (file) {
+		fflush(file);
+		fclose(file);
+	}
+	return EXIT_SUCCESS;
+}
+
+output_module_t module_extended_file = {
+	.name = "extended_file",
+	.init = &extendedfile_init,
+	.start = NULL,
+	.update = NULL,
+	.update_interval = 0,
+	.close = &extendedfile_close,
+	.success_ip = &extendedfile_ip,
+	.other_ip = &extendedfile_ip
+};
+

src/output_modules/module_extended_file.h

@@ -0,0 +1,20 @@
+/*
+ * ZMap Copyright 2013 Regents of the University of Michigan 
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+#include <output_modules.h>
+
+int extendedfile_init(struct state_conf *conf);
+
+int extendedfile_ip(ipaddr_n_t saddr, ipaddr_n_t daddr,
+        port_n_t sport, port_n_t dport, struct timeval* t,
+        const char *response_type, int is_repeat,
+        int in_cooldown, const u_char *packet);
+
+int extendedfile_close(struct state_conf* c, struct state_send* s,
+		struct state_recv* r);
+

src/output_modules/module_redis.c

@@ -0,0 +1,96 @@
+/*
+ * ZMap Copyright 2013 Regents of the University of Michigan 
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include "../../lib/zdlibc/logger.h"
+#include "../../lib/zdlibc/redis.h"
+
+#include "output_modules.h"
+
+#define UNUSED __attribute__((unused))
+
+typedef struct scannable_t {
+	in_addr_t ip_address;
+	uint8_t source;
+} scannable_t;
+
+#define QUEUE_NAME "zmap_results"
+#define BUFFER_SIZE 500
+#define SOURCE_ZMAP 0
+
+static scannable_t* buffer;
+static int buffer_fill = 0;
+
+int redismodule_init(UNUSED struct state_conf *conf)
+{
+	buffer = calloc(BUFFER_SIZE, sizeof(scannable_t));
+	assert(buffer);
+	buffer_fill = 0;
+	return redis_init();
+}
+
+int redismodule_flush(void)
+{
+	if (redis_lpush(QUEUE_NAME, buffer,
+			buffer_fill, sizeof(scannable_t))) {
+		return EXIT_FAILURE;
+	}
+	buffer_fill = 0;
+	return EXIT_SUCCESS;
+}
+
+int redismodule_newip(ipaddr_n_t saddr, UNUSED ipaddr_n_t daddr,
+        UNUSED port_n_t sport, UNUSED port_n_t dport,
+        UNUSED const char *response_type, int is_repeat,
+        UNUSED int in_cooldown, UNUSED const u_char *packet)
+{
+	if (!is_repeat) {
+		buffer[buffer_fill].ip_address = saddr;
+		buffer[buffer_fill].source = SOURCE_ZMAP;
+
+		if (++buffer_fill == BUFFER_SIZE) {
+			if (redismodule_flush()) {
+				return EXIT_FAILURE;
+			}
+		}
+	}
+	return EXIT_SUCCESS;
+}
+
+int redismodule_close(UNUSED struct state_conf* c, 
+        UNUSED struct state_send* s,
+		UNUSED struct state_recv* r)
+{
+	if (redismodule_flush()) {
+		return EXIT_FAILURE;
+	}
+	if (redis_close()) {
+		return EXIT_FAILURE;
+	}
+	return EXIT_SUCCESS;
+}
+
+output_module_t module_redis = {
+	.name = "redis",
+	.init = &redismodule_init,
+	.start = NULL,
+	.update = NULL,
+	.update_interval = 0,
+	.close = &redismodule_close,
+	.success_ip = &redismodule_newip,
+	.other_ip = NULL
+};
+

src/output_modules/module_redis.h

@@ -0,0 +1,19 @@
+/*
+ * ZMap Copyright 2013 Regents of the University of Michigan 
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+#include <output_modules.h>
+
+int redismodule_init(struct state_conf *conf);
+
+int redismodule_newip(ipaddr_n_t saddr, ipaddr_n_t daddr,
+        port_n_t sport, port_n_t dport, struct timeval* t,
+        const char *response_type, int is_repeat,
+        int in_cooldown, const u_char *packet);
+
+int redismodule_close(struct state_conf* c,
+		struct state_send* s, struct state_recv* r);

src/output_modules/module_simple_file.c

@@ -0,0 +1,75 @@
+/*
+ * ZMap Copyright 2013 Regents of the University of Michigan 
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <assert.h>
+#include <logger.h>
+
+#include "output_modules.h"
+
+#define UNUSED __attribute__((unused))
+
+static FILE *file = NULL;
+
+int simplefile_init(struct state_conf *conf)
+{
+	assert(conf);
+	if (conf->output_filename) {
+		if (!strcmp(conf->output_filename, "-")) {
+			file = stdout;
+		} else {
+			if (!(file = fopen(conf->output_filename, "w"))) {
+				perror("Couldn't open output file");
+				exit(EXIT_FAILURE);
+			}
+		}
+	}
+	return EXIT_SUCCESS;
+}
+
+int simplefile_synack_newip(ipaddr_n_t saddr, UNUSED ipaddr_n_t daddr,
+		UNUSED const char *response_type,
+		int is_repeat, UNUSED int in_cooldown, UNUSED const u_char *packet,
+		UNUSED size_t buflen)
+{	
+	if (file && !is_repeat) {
+		struct in_addr addr;
+		addr.s_addr = saddr;
+		fprintf(file, "%s\n", inet_ntoa(addr));
+	}
+	fflush(file);
+	return EXIT_SUCCESS;
+}
+
+int simplefile_close(UNUSED struct state_conf* c, 
+	UNUSED struct state_send* s, 
+	UNUSED struct state_recv* r)
+{
+	if (file) {
+		fflush(file);
+		fclose(file);
+	}
+	return EXIT_SUCCESS;
+}
+
+output_module_t module_simple_file = {
+	.name = "simple_file",
+	.init = &simplefile_init,
+	.start = NULL,
+	.update = NULL,
+	.update_interval = 0,
+	.close = &simplefile_close,
+	.success_ip = &simplefile_synack_newip,
+	.other_ip = NULL,
+};

src/output_modules/output_modules.c

@@ -0,0 +1,54 @@
+/*
+ * ZMap Copyright 2013 Regents of the University of Michigan 
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+
+#include <stdio.h>
+#include <string.h>
+
+#include "output_modules.h"
+
+extern output_module_t module_simple_file;
+extern output_module_t module_extended_file;
+// ADD YOUR MODULE HERE
+
+#ifdef REDIS
+extern output_module_t module_redis;
+extern output_module_t module_ssldbfeed;
+#endif
+
+
+output_module_t* output_modules[] = {
+	&module_simple_file,
+	&module_extended_file,
+#ifdef REDIS
+	&module_redis,
+	&module_ssldbfeed,
+#endif
+	// ADD YOUR MODULE HERE
+};
+
+
+
+output_module_t* get_output_module_by_name(const char* name)
+{
+    int num_modules = (int) (sizeof(output_modules)/sizeof(output_modules[0]));
+	for (int i=0; i < num_modules; i++) {
+		if (!strcmp(output_modules[i]->name, name)) {
+			return output_modules[i];
+		}
+	}
+	return NULL;
+}
+
+void print_output_modules(void)
+{
+    int num_modules = (int) (sizeof(output_modules)/sizeof(output_modules[0]));
+	for (int i=0; i < num_modules; i++) {
+		printf("%s\n", output_modules[i]->name);
+	}
+}

src/output_modules/output_modules.h

@@ -0,0 +1,44 @@
+/*
+ * ZMap Copyright 2013 Regents of the University of Michigan 
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+#ifndef HEADER_OUTPUT_MODULES_H
+#define HEADER_OUTPUT_MODULES_H
+
+#include "../state.h"
+
+// called at scanner initialization
+typedef int (*output_init_cb)(struct state_conf *);
+
+// called on packet receipt
+typedef int (*output_packet_cb)(ipaddr_n_t src_ip, ipaddr_n_t dst_ip,
+				const char* response_type,
+				int is_repeat, int in_cooldown,
+				const u_char* packetbuf, size_t buflen);
+
+// called periodically during the scan
+typedef int (*output_update_cb)(struct state_conf*, struct state_send*, struct state_recv*);
+
+
+typedef struct output_module {
+	const char *name;
+	unsigned update_interval;
+
+	output_init_cb init;
+	output_update_cb start;
+	output_update_cb update;
+	output_update_cb close;
+	output_packet_cb success_ip;
+	output_packet_cb other_ip;
+
+} output_module_t;
+
+
+output_module_t* get_output_module_by_name(const char*);
+void print_output_modules(void);
+
+#endif // HEADER_OUTPUT_MODULES_H