From 93c4454143a511409efd692e3687d295e3db9314 Mon Sep 17 00:00:00 2001 From: Christian Pointner Date: Sun, 28 Dec 2008 10:08:58 +0000 Subject: added plain packet --- src/Makefile | 4 ++ src/plain_packet.c | 107 ++++++++++++++++++++++++++++++++++++++++++++++ src/plain_packet.h | 67 +++++++++++++++++++++++++++++ src/uanytun.c | 123 ++++++++++++++++++++++++++++++++++++++++++----------- 4 files changed, 275 insertions(+), 26 deletions(-) create mode 100644 src/plain_packet.c create mode 100644 src/plain_packet.h diff --git a/src/Makefile b/src/Makefile index 881f1ff..37cd8bf 100644 --- a/src/Makefile +++ b/src/Makefile @@ -49,6 +49,7 @@ OBJS = log.o \ signal.o \ tun.o \ udp.o \ + plain_packet.o \ uanytun.o EXECUTABLE = uanytun @@ -73,6 +74,9 @@ tun.o: tun.c tun.h udp.o: udp.c udp.h $(CC) $(CCFLAGS) $< -c +plain_packet.o: plain_packet.c plain_packet.h + $(CC) $(CCFLAGS) $< -c + distclean: clean find . -name *.o -exec rm -f {} \; find . -name "*.\~*" -exec rm -rf {} \; diff --git a/src/plain_packet.c b/src/plain_packet.c new file mode 100644 index 0000000..1ef05fe --- /dev/null +++ b/src/plain_packet.c @@ -0,0 +1,107 @@ +/* + * ľAnytun + * + * ľAnytun is a tiny implementation of SATP. Unlike Anytun which is a full + * featured implementation ľAnytun has no support for multiple connections + * or synchronisation. It is a small single threaded implementation intended + * to act as a client on small platforms. + * The secure anycast tunneling protocol (satp) defines a protocol used + * for communication between any combination of unicast and anycast + * tunnel endpoints. It has less protocol overhead than IPSec in Tunnel + * mode and allows tunneling of every ETHER TYPE protocol (e.g. + * ethernet, ip, arp ...). satp directly includes cryptography and + * message authentication based on the methodes used by SRTP. It is + * intended to deliver a generic, scaleable and secure solution for + * tunneling and relaying of packets of any protocol. + * + * + * Copyright (C) 2007-2008 Christian Pointner + * + * This file is part of ľAnytun. + * + * ľAnytun is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation. + * + * ľAnytun is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with ľAnytun. If not, see . + */ + +#include "datatypes.h" + +#include "plain_packet.h" + +#include +#include + +void plain_packet_init(plain_packet_t* packet) +{ + if(!packet) + return; + + memset (packet, 0, sizeof(*packet)); +} + +u_int8_t* plain_packet_get_packet(plain_packet_t* packet) +{ + if(!packet) + return NULL; + + return packet->data.buf_; +} + +u_int32_t plain_packet_get_length(plain_packet_t* packet) +{ + if(!packet) + return 0; + + return (packet->payload_length_ + sizeof(payload_type_t)); +} + +u_int8_t* plain_packet_get_payload(plain_packet_t* packet) +{ + if(!packet) + return NULL; + + return (packet->data.buf_ + sizeof(payload_type_t)); +} + +u_int32_t plain_packet_get_payload_length(plain_packet_t* packet) +{ + if(!packet) + return 0; + + return packet->payload_length_; +} + +void plain_packet_set_payload_length(plain_packet_t* packet, u_int32_t len) +{ + if(!packet) + return; + + if(len > PLAIN_PACKET_SIZE_MAX || (len + sizeof(payload_type_t)) > PLAIN_PACKET_SIZE_MAX) + len = PLAIN_PACKET_SIZE_MAX - sizeof(payload_type_t); + + packet->payload_length_ = len; +} + +payload_type_t plain_packet_get_type(plain_packet_t* packet) +{ + if(!packet) + return 0; + + return packet->data.payload_type_; +} + +void plain_packet_set_type(plain_packet_t* packet, payload_type_t type) +{ + if(!packet) + return; + + packet->data.payload_type_ = type; +} diff --git a/src/plain_packet.h b/src/plain_packet.h new file mode 100644 index 0000000..ac1c56f --- /dev/null +++ b/src/plain_packet.h @@ -0,0 +1,67 @@ +/* + * ľAnytun + * + * ľAnytun is a tiny implementation of SATP. Unlike Anytun which is a full + * featured implementation ľAnytun has no support for multiple connections + * or synchronisation. It is a small single threaded implementation intended + * to act as a client on small platforms. + * The secure anycast tunneling protocol (satp) defines a protocol used + * for communication between any combination of unicast and anycast + * tunnel endpoints. It has less protocol overhead than IPSec in Tunnel + * mode and allows tunneling of every ETHER TYPE protocol (e.g. + * ethernet, ip, arp ...). satp directly includes cryptography and + * message authentication based on the methodes used by SRTP. It is + * intended to deliver a generic, scaleable and secure solution for + * tunneling and relaying of packets of any protocol. + * + * + * Copyright (C) 2007-2008 Christian Pointner + * + * This file is part of ľAnytun. + * + * ľAnytun is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation. + * + * ľAnytun is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with ľAnytun. If not, see . + */ + +#ifndef _PLAIN_PACKET_H_ +#define _PLAIN_PACKET_H_ + +#define PLAIN_PACKET_SIZE_MAX 1600 + +#define PAYLOAD_TYPE_TAP 0x6558 +#define PAYLOAD_TYPE_TUN 0x0000 +#define PAYLOAD_TYPE_TUN4 0x0800 +#define PAYLOAD_TYPE_TUN6 0x86DD + +struct plain_packet_struct { + u_int32_t payload_length_; + union __attribute__ ((__packed__)) { + u_int8_t buf_[PLAIN_PACKET_SIZE_MAX]; + payload_type_t payload_type_; + } data; +}; +typedef struct plain_packet_struct plain_packet_t; + +void plain_packet_init(plain_packet_t* packet); + +u_int8_t* plain_packet_get_packet(plain_packet_t* packet); +u_int32_t plain_packet_get_length(plain_packet_t* packet); + +u_int8_t* plain_packet_get_payload(plain_packet_t* packet); +u_int32_t plain_packet_get_payload_length(plain_packet_t* packet); +void plain_packet_set_payload_length(plain_packet_t* packet, u_int32_t len); + +payload_type_t plain_packet_get_type(plain_packet_t* packet); +void plain_packet_set_type(plain_packet_t* packet, payload_type_t type); + + +#endif diff --git a/src/uanytun.c b/src/uanytun.c index 567a103..a546287 100644 --- a/src/uanytun.c +++ b/src/uanytun.c @@ -43,6 +43,8 @@ #include "tun.h" #include "udp.h" +#include "plain_packet.h" + #include "daemon.h" #include "sysexec.h" @@ -52,9 +54,10 @@ void main_loop(tun_device_t* dev, udp_socket_t* sock) u_int8_t buf[1600]; int len = 0; + udp_endpoint_t remote; unsigned int cnt = 0; + while(cnt < 5) { - udp_endpoint_t remote; len = udp_read(sock, buf, 1600, &remote); if(memcmp(&remote, &(sock->remote_end_), sizeof(remote))) { @@ -71,45 +74,113 @@ void main_loop(tun_device_t* dev, udp_socket_t* sock) } } +void print_hex_dump(const u_int8_t* buf, u_int32_t len) +{ + u_int32_t i; + + for(i=0; i < len; i++) { + printf("%02X ", buf[i]); + if(!((i+1)%8)) + printf(" "); + if(!((i+1)%16)) + printf("\n"); + } + printf("\n"); +} + int main(int argc, char* argv[]) { log_init("uanytun", DAEMON); signal_init(); + plain_packet_t packet; + plain_packet_init(&packet); + + printf("packet length: %d\n", plain_packet_get_length(&packet)); + printf("packet: \n"); + print_hex_dump(plain_packet_get_packet(&packet), plain_packet_get_length(&packet)); + printf("\npayload type: 0x%04X\n", plain_packet_get_type(&packet)); + printf("payload length: %d\n", plain_packet_get_payload_length(&packet)); + printf("payload: \n"); + print_hex_dump(plain_packet_get_payload(&packet), plain_packet_get_payload_length(&packet)); + printf("\n\n"); + + + plain_packet_set_payload_length(&packet, 20); + + + printf("packet length: %d\n", plain_packet_get_length(&packet)); + printf("packet: \n"); + print_hex_dump(plain_packet_get_packet(&packet), plain_packet_get_length(&packet)); + printf("\npayload type: 0x%04X\n", plain_packet_get_type(&packet)); + printf("payload length: %d\n", plain_packet_get_payload_length(&packet)); + printf("payload: \n"); + print_hex_dump(plain_packet_get_payload(&packet), plain_packet_get_payload_length(&packet)); + printf("\n\n"); + + u_int32_t i; + + for(i=0; iactual_name_); */ /* log_printf(NOTICE, "post-up script returned %d", ret); */ - udp_socket_t* sock; - udp_init(&sock, NULL, "4444"); - if(!sock) { - log_printf(ERR, "error on udp_init"); - exit(-1); - } - char* local_string = udp_get_local_end_string(sock); - log_printf(INFO, "listening on: %s", local_string); - free(local_string); - - udp_set_remote(sock, "1.2.3.4", "4444"); - char* remote_string = udp_get_remote_end_string(sock); - log_printf(INFO, "set remote end to: %s", remote_string); - free(remote_string); - - main_loop(dev, sock); - - tun_close(&dev); - udp_close(&sock); +/* udp_socket_t* sock; */ +/* udp_init(&sock, NULL, "4444"); */ +/* if(!sock) { */ +/* log_printf(ERR, "error on udp_init"); */ +/* exit(-1); */ +/* } */ +/* char* local_string = udp_get_local_end_string(sock); */ +/* log_printf(INFO, "listening on: %s", local_string); */ +/* free(local_string); */ + +/* udp_set_remote(sock, "1.2.3.4", "4444"); */ +/* char* remote_string = udp_get_remote_end_string(sock); */ +/* log_printf(INFO, "set remote end to: %s", remote_string); */ +/* free(remote_string); */ + +/* main_loop(dev, sock); */ + +/* tun_close(&dev); */ +/* udp_close(&sock); */ return 0; } -- cgit v1.2.3