From 721f4e7bb042b018a579c0168524af6ddea2a619 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anton=20Luka=20=C5=A0ijanec?= Date: Mon, 17 Jan 2022 00:11:24 +0100 Subject: nepreverjeno, se pa prevede --- domain2name.c | 99 ++++++++++++++++++++++++++++++---- domain2name_test.c | 9 ++++ main.c | 156 ++++++++++++++++++++++++++++++++++++++++------------- 3 files changed, 216 insertions(+), 48 deletions(-) diff --git a/domain2name.c b/domain2name.c index 46fd2a3..7c84fbb 100644 --- a/domain2name.c +++ b/domain2name.c @@ -1,8 +1,8 @@ -int domain2name_len (const char * s, int l) { - int r = 1; /* ending terminator */ - int o = 0; /* label offset */ - for (int i = 0; i < l; i++) { - if (s[i] == '.') { +int domain2name_len (const char * s, int l) { /* TODO make domain2name FAIL at empty label (..) */ + int r = 1; /* ending terminator */ /* make functions FAIL at label.length > 63 */ + int o = 0; /* label offset */ /* currently domain2name never fails */ + for (int i = 0; i < l; i++) { /* NOTE when using BOTH _len, check that they are */ + if (s[i] == '.') { /* NOT negative. d2n_len will fail in d future */ if (!o) /* double period or starting period, label is empty */ break; o = 0; @@ -15,9 +15,9 @@ int domain2name_len (const char * s, int l) { } return r; } -int domain2name (char * d, const char * s, int l) { /* l is length of s */ - char * c = d; /* where to write the label size when done with label */ - char * w = d; +int domain2name (char * n /* at least _len bytes */, const char * s, int l) { /* l is length of s */ + char * c = n; /* where to write the label size when done with label */ + char * w = n; int o = 0; /* label offset */ for (int i = 0; i <= l /* yes, we go one more ... */; i++) { if (i == l /* ... here */ || s[i] == '.') { /* end of label or end of last label */ @@ -36,5 +36,84 @@ int domain2name (char * d, const char * s, int l) { /* l is length of s */ *c = 63; /* it at 63 bytes */ } *w++ = '\0'; /* luckily this makes domain2name kind of safe for handling as a string (: */ - return w-d; /* we return number of bytes written */ -} /* d must be allocated for at least _len. */ + return w-n; /* we return number of bytes written */ +} /* no compression, it's 2022, net bandwidth is unlimited. n2d OFC does decompress ptrs acc2 std. */ +int name2domain_len (const char * u /* >= 512 bytes */, const char * n /* name */) { +#define N2DO(x) ((x) & ~(1 << 7 & 1 << 6)) /* pointer offset */ + int r = 0; + if (n < u+512 && *n == '\0') { + return 2; + } + while (n < u+512) { + if (*n & 1 << 7) { + if (!(*n & 1 << 6)) + return -1; /* 10xx xxxx not implemented - reserved for future use */ + n = u + N2DO(*n); + continue; + } + if (*n & 1 << 6) + return -2; /* 01xx xxxx not implemented - reserved for future use */ + if (!*n) + return r+1; + r += *n+1; + n += *n+1; + } + return -3; /* malformed packet */ +} /* returns number of bytes needed for buffer, passed as the first argument of name2domain(). */ +const char * name2domain (char * d /* >= _len B */, const char * u /* >= 512 B */, const char * n) { + char * w = d; /* if d is NULL nothing is written and last byte of name is returned */ + const char * r = NULL; + if (n < u+512 && *n == '\0') { + *w++ = '.'; + *w++ = '\0'; + return n; + } + while (n < u+512) { + if (*n & 1 << 7) { + if (!(*n & 1 << 6)) + return NULL; /* 10xx xxxx N/I - reserved for future use as per RFC */ + n = u + N2DO(*n); + r = n; + continue; + } + if (*n & 1 << 6) + return NULL; /* 01xx xxxx N/I - reserved for future use as per RFC */ + if (!*n) { /* end of name */ + if (w) + *w++ = '\0'; + return r ? r : n; + } + const char * x = n+*n; + n++; + if (!(x < u+512)) + return NULL; /* malformed packet */ + while (n <= x) + if (w) + *w++ = *n++; + else + n++; + if (w) + *w++ = '.'; + } + return NULL; /* malformed packet */ +} /* Returns ptr to last byte of name - '\0' or dnsptr. Ret. NULL on fail (_len also returned < 0) */ +int normalizedomain_len (const char * s, int l) { + int ž = domain2name_len(s, l); + if (ž < 0) + return -4; + char * b = alloca(ž); + if (domain2name(b, s, l) != ž) + return -5; + return name2domain_len(b, b); +} +int normalizedomain (char * d /* at least _len bytes */, const char * s, int l) { + int ž = domain2name_len(s, l); + if (ž < 0) + return -4; + char * b = alloca(ž); + if (domain2name(b, s, l) != ž) + return -5; + if (!name2domain(d, b, b)) + return -6; + return 0; +} diff --git a/domain2name_test.c b/domain2name_test.c index f0a6898..c88aa0a 100644 --- a/domain2name_test.c +++ b/domain2name_test.c @@ -10,6 +10,15 @@ int main (int argc, char * const argv[]) { int r, s = domain2name_len(argv[1], strlen(argv[1])); char * b = alloca(s); r = domain2name(b, argv[1], strlen(argv[1])); + fprintf(stderr, "strlen %d name2domain_len %d\n", strlen(argv[1]), name2domain_len(b, b)); + int l = name2domain_len(b, b); + if (l < 0) { + fprintf(stderr, "name2domain_len error: %d\n", l); + } else { + char * d = alloca(l); + name2domain(d, b, b); + fprintf(stderr, "name2domain: %s\n", d); + } printf("%4dB %4dB (-:\n", s, r); /* xxd has 16 bytes per row */ printf("%s", b); fflush(stdout); diff --git a/main.c b/main.c index fd77759..58fe58e 100644 --- a/main.c +++ b/main.c @@ -90,7 +90,7 @@ GLOBAL HEADER: 24 bytes LINKTYP 28 bits: pkt type //tcpdump.org/linktypes.html 101 IPv4/v6 1 ether | | PACKET HEADER: 16 bytes SECONDS 32 bits: UNIX timestamp - NANOSEC 32 bits: nanoseconds elapsed since the second, can also be microseconds - see MAGIC + SUBSECS 32 bits: nanoseconds elapsed since the second, can also be microseconds - see MAGIC CAPTURE 32 bits: number of bytes captured from the packet following the header ORIGLEN 32 bits: number of bytes of the original packet size (can be more than CAPTURE) */ @@ -115,10 +115,10 @@ HEADER: Option byte zero denotes an end of options, NOOP is option number 1 PADDING variable: zero bytes ensuring header is aligned into 32 bit words */ -/* UDP PACKET: HEADER DATA https://www.ietf.org/rfc/rfc768.txt +/* UDP PACKET: HEADER (8 bytes) DATA https://www.ietf.org/rfc/rfc768.txt SRCPORT 16 bits DSTPORT 16 bits - LENGTH 16 bits: size of packet including header in bytes + LENGTH 16 bits: size of packet including header in bytes+8 CHCKSUM 16 bits: same algo as IP, data: pseudoheader (srcip dstip 0x0011 LENGTH) header data */ #define MICROSECOND 0xA1B2C3D4 @@ -141,8 +141,8 @@ struct pcap_packet { uint32_t capture_length __attribute__((packed)); uint32_t original_length __attribute__((packed)); } __attribute__((packed)); -#define LOW_DELAY (1 << 0) -#define HIGH_THROUGHPUT (1 << 1) +#define LOW_DELAY (1 << 4) +#define HIGH_THROUGHPUT (1 << 3) #define HIGH_RELIABILITY (1 << 2) #define ROUTINE (0 << 5) #define PRIORITY (1 << 5) @@ -153,9 +153,9 @@ struct pcap_packet { #define INETCTRL (FLASH_OVERRIDE | IMMEDIATE) #define NETCTRL (FLASH_OVERRIDE | FLASH) #define HEADLENOR (1 << 6) /* always bitwiseOR the headlen with this to apply the version number */ -#define EVIL (1 << 13) +#define EVIL (1 << 15) #define DF (1 << 14) -#define MF (1 << 15) +#define MF (1 << 13) #define ICMP 1 #define TCP 6 #define UDP 17 @@ -164,7 +164,7 @@ struct ip { uint8_t srvtype; /* OR here: LOW_DELAY, HIGH_THROUGHPUT, HIGH_RELIABILITY, ROUTINE, ... */ uint16_t length __attribute__((packed)); /* header + data in 8 bit words */ uint16_t identifier __attribute__((packed)); - uint8_t foffset; /* fragment offset in 64 bit words. also or here any flags: EVIL, DF, MF */ + uint16_t foffset /* 64b wrds */ __attribute__((packed)); /* or any flags: EVIL, DF, MF */ uint8_t ttl; /* ignored for uint8_t */ uint8_t protocol; /* ignored for uint8_t */ uint16_t checksum; /* ignoref for uint8_t */ @@ -196,20 +196,20 @@ enum class { He, Any = 255 }; -#define RESPONSE (1 << 0) /* :FLAGS */ -#define QUESTION (0 << 0) -#define QUERY (1 << 1) /* must be set, even with response, this shows that it's normal query type */ -#define IQUERY (1 << 2) -#define STATUS (QUERY | IQUERY) -#define AA (1 << 5) -#define TC (1 << 6) -#define RD (1 << 7) -#define RA (1 << 8) -#define SUCCESS (1 << 12) -#define FORMAT_ERROR (1 << 13) -#define SERVFAIL (SUCCESS | FORMAT_ERROR) -#define NXDOMAIN (1 << 14) -#define NI (NXDOMAIN | SUCCESS) +#define RESPONSE (1 << 15) /* :FLAGS */ +#define QUESTION (0 << 15) +#define QUERY (0 << 11) +#define IQUERY (1 << 11) +#define STATUS (1 << 12) +#define AA (1 << 10) +#define TC (1 << 9) +#define RD (1 << 8) +#define RA (1 << 7) +#define SUCCESS (0 << 0) +#define FORMAT_ERROR (1 << 0) +#define SERVFAIL (1 << 1) +#define NXDOMAIN (FORMAT_ERROR | SERVFAIL) +#define NI (1 << 2) #define FORBIDDEN (NXDOMAIN | FORMAT_ERROR) struct header { uint16_t xid __attribute__((packed)); @@ -231,13 +231,13 @@ int logudp (int o /* fd */, struct sockaddr_in s, struct sockaddr_in d, char * u struct pcap_packet p = { .seconds = t.tv_sec, .subseconds = t.tv_nsec, - .capture_length = l, - .original_length = l + .capture_length = sizeof(struct ip) + l + 4*2, + .original_length = sizeof(struct ip) + l + 4*2 }; struct ip i = { .headlen = 5 | HEADLENOR, .srvtype = ROUTINE, - .length = htons(8+l), + .length = htons(8+l+sizeof i), .identifier = 0x6969, .foffset = 0, .ttl = 69, @@ -249,7 +249,7 @@ int logudp (int o /* fd */, struct sockaddr_in s, struct sockaddr_in d, char * u #define LOGUDP_L (sizeof p + sizeof i + 4*2 + l) char * c, * b = alloca(LOGUDP_L); /* to do in one write (thread safe) */ char * n = "\0"; /* as per udp rfc when no checksum was calculated (-: */ - uint16_t v = htons(l); + uint16_t v = htons(l+8); c = (char *) memcpy(b, &p, sizeof p) + sizeof p; c = (char *) memcpy(c, &i, sizeof i) + sizeof i; c = (char *) memcpy(c, &s.sin_port, 2) + 2; @@ -263,6 +263,53 @@ int logudp (int o /* fd */, struct sockaddr_in s, struct sockaddr_in d, char * u } return LOGUDP_L; } +struct in_addr parse_a (const char * u /* >=512B */, const char * d, int l, int n) { + struct in_addr r = { /* this uses heap and does not fix heap if realloc failed. */ + .s_addr = 0 /* returns 0.0.0.0 in case of error or if no more results for n. */ + }; + int y = normalizedomain_len(d, l); + if (y < 0) + return r; + char * ž = alloca(y); + if (normalizedomain(ž, d, l) < 0) + return r; + int š = ntohs(((const struct header *) u)->ancount); + char * o = NULL; + const char * c = u+sizeof(struct header); + while (š--) { /* there's got to be a cleaner way of */ + int č = name2domain_len(u, c); /* doing this ... someone please review */ + if (č < 0) /* all those functions and PLEASE run */ + goto r; /* this program AS UNPRIVILEDGED AS */ + if (!(o = realloc(o, č))) /* POSSIBLE! */ + goto r; + if (!(c = name2domain(o, u, c))) + goto r; + if (c+11 >= u+512) + goto r; + if (y != č) + goto c; + if (memcmp(o, ž, y)) + goto c; + if (ntohs(*(uint16_t *) c+1) != A) + goto c; + if (ntohs(*(uint16_t *) c+3) != In) + goto c; + if (ntohs(*(uint16_t *) c+5) != 4) /* this is actually a malformed packet, */ + goto c; /* A resource record must be four bytes */ + if (n--) + goto c; + r.s_addr = *(in_addr_t *) c+7; + goto r; +c: + c += ntohs(*(uint16_t *) c+5)+7; + if (c >= u+512) + goto r; + continue; + } +r: + free(o); + return r; +} /* returns nth IP of A record for domain d of length l in response packet u or 0.0.0.0 for err */ int finish = 0; int c = -1; /* child process */ void handler () { @@ -278,6 +325,7 @@ struct timespec lp = { /* last packet */ void child_handler () { if (clock_gettime(CLOCK_MONOTONIC, &lp) == -1) perror("clock_gettime(CLOCK_MONOTONIC, &lp)"); + fprintf(stderr, "recv child received signal\n"); } int main (int argc, char ** argv) { int r = 2; @@ -403,12 +451,14 @@ o: signal(SIGINT, child_handler); signal(SIGTERM, child_handler); while (1) { - char b[512]; /* max dns packet */ + char u[512]; /* max dns packet */ struct sockaddr_in f; socklen_t č = sizeof f; - if (recvfrom(s,b,512,!lp.tv_sec?MSG_DONTWAIT:0,(struct sockaddr*)&f,&č)==-1){ + int š; + if ((š = recvfrom(s, u, 512, lp.tv_sec ? MSG_DONTWAIT : 0, + (struct sockaddr *) &f, &č)) == -1) { if (errno != EWOULDBLOCK) { - perror("recvfrom(s,b,512,!lp.tv_sec?MSG_DONTWAIT:0,(str..."); + perror("recvfrom(s, u, 512, lp.tv_sec ? MSG_DONTWAIT : 0..."); return 1; } struct timespec z; @@ -428,26 +478,36 @@ o: perror("clock_gettime(CLOCK_MONOTONIC, &lp)"); return 2; } + int ž; + if ((ž = logudp(o, f, b, u, š)) < -1) { + fprintf(stderr, "logudp(o, f, b, u, š) == %d\n", ž); + return 3; + } fprintf(stderr, "received response from %s\n", inet_ntoa(f.sin_addr)); - } + } /* TODO: parse the response with parse_a etc above this line (: */ return 0; } while (!finish) { - if (!(t = host(n[i], ++j).s_addr)) { + if (!(h = host(n[i], ++j)).s_addr) { if (++i >= l) { int s; fprintf(stderr, "finished sending, waiting for last replies\n"); - kill(c, SIGINT); /* child waits */ + if (kill(c, SIGINT) == -1) { /* child waits */ + perror("kill(c, SIGINT)"); + r = 13; + goto r; + } + c = -1; if (wait(&s) == -1) { perror("wait(&s)"); - r = 13; + r = 14; goto r; } if (WIFEXITED(s) && !WEXITSTATUS(s)) { r = 0; goto r; } - r = 14; + r = 15; goto r; } else @@ -467,6 +527,10 @@ o: .arcount = 0 }; int v = domain2name_len(d, strlen(d)); + if (v < 0) { + r = 16; + goto r; + } #define L (sizeof h + v + 2*2) char * u = alloca(L); char * c; @@ -476,9 +540,22 @@ o: c += domain2name(c, d, strlen(d)); c = (char *) memcpy(c, &y, 2) + 2; c = (char *) memcpy(c, &k, 2) + 2; - logudp(o, b, e, u, L); - sendto(s, u, L, 0, (struct sockaddr *) &e, sizeof(struct sockaddr)); - usleep(t); + int ž; + if ((ž = logudp(o, b, e, u, L)) < -1) { + fprintf(stderr, "logudp(o, b, e, u, L) == %d\n", ž); + r = 17; + goto r; + } + if (sendto(s, u, L, 0, (struct sockaddr *) &e, sizeof(struct sockaddr)) == -1) { + perror("sendto(s, u, L, 0, (struct sockaddr *) &e, sizeof(struct sockaddr))"); + r = 18; + goto r; + } + if (usleep(t)) { + perror("usleep(t)"); + r = 19; + goto r; + } } if (finish) kill(c, SIGTERM); /* stop receiving */ @@ -486,7 +563,7 @@ r: if (!r && j != -1) { char * x = alloca(l*31+strlen("SCANNED \n0")); strcpy(x, "SCANNED "); - for (int m = 0; m < finish ? i : l; m++) { + for (int m = 0; m < (finish ? i : l); m++) { strcat(x, inet_ntoa(n[m].addr)); strcat(x, "/"); strcat(x, inet_ntoa(n[m].mask)); @@ -501,5 +578,8 @@ r: if (o != -1) if (close(o)) perror("close(o)"); + if (c != -1) + if (kill(c, SIGKILL) == -1) + perror("kill(c, SIGKILL)"); return r; } -- cgit v1.2.3