Updated IP, PDU and PacketSender so as to send forged ip packets successfully

src/ip.cpp

@@ -6,6 +6,8 @@
 #include "ip.h"
 #include "utils.h"
 
+#include <iostream>
+
 using namespace std;
 
 
@@ -15,7 +17,7 @@ Tins::IP::IP(const string &ip_dst, const string &ip_src) : PDU(IPPROTO_IP) {
         _ip.daddr = Utils::ip_to_int(ip_dst);
     if(ip_src.size())
         _ip.saddr = Utils::ip_to_int(ip_src);
-    
+
 }
 
 Tins::IP::IP(uint32_t ip_dst, uint32_t ip_src) : PDU(IPPROTO_IP) {
@@ -28,6 +30,7 @@ void Tins::IP::init_ip_fields() {
     memset(&_ip, 0, sizeof(iphdr));
     _ip.version = 4;
     _ip.ihl = sizeof(iphdr) / sizeof(uint32_t);
+    _ip.ttl = 128;
 }
 
 /* Setters */
@@ -82,8 +85,21 @@ uint32_t Tins::IP::header_size() const {
     return sizeof(iphdr);
 }
 
+bool Tins::IP::send(PacketSender* sender) {
+
+    struct sockaddr_in link_addr;
+
+    link_addr.sin_family = AF_INET;
+    link_addr.sin_port = 0;
+    link_addr.sin_addr.s_addr = _ip.daddr;
+
+    return sender->send_l3(this, (const struct sockaddr*)&link_addr, sizeof(link_addr));
+
+}
+
 void Tins::IP::write_serialization(uint8_t *buffer, uint32_t total_sz) {
-    uint32_t my_sz = header_size() + trailer_size(), new_flag = inner_pdu()->flag();
+    uint32_t my_sz = header_size() + trailer_size();
+    uint32_t new_flag = inner_pdu()? inner_pdu()->flag() : 255;
     assert(total_sz >= my_sz);
     if(new_flag == IPPROTO_IP)
         new_flag = IPPROTO_IPIP;
@@ -91,5 +107,6 @@ void Tins::IP::write_serialization(uint8_t *buffer, uint32_t total_sz) {
     _ip.protocol = new_flag;
     _ip.tot_len = total_sz;
     memcpy(buffer, &_ip, sizeof(iphdr));
+
     /* IP Options here... */
 }

src/packetsender.cpp

@@ -1,10 +1,11 @@
 #ifndef WIN32
     #include <sys/socket.h>
-	#include <sys/select.h>
-	#include <arpa/inet.h>
+    #include <sys/select.h>
+    #include <arpa/inet.h>
     #include <unistd.h>
     #include </usr/include/linux/if_ether.h>
     #include </usr/include/linux/if_packet.h>
+    #include <netdb.h>
 #endif
 #include <assert.h>
 #include <iostream>
@@ -12,37 +13,23 @@
 #include <string.h>
 #include "packetsender.h"
 
+const uint32_t Tins::PacketSender::IP_SOCKET = 0;
 
-bool Tins::PacketSender::open_socket(uint32_t flag) {
-    if(_sockets.find(flag) != _sockets.end())
+bool Tins::PacketSender::open_l3_socket() {
+    if(_sockets.find(IP_SOCKET) != _sockets.end())
         return true;
     int sockfd;
-    sockfd = socket(PF_PACKET, SOCK_RAW, 255);
+    sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
     if (sockfd < 0) {
-        std::cout << "Flag: " << flag << "\n";
+        std::cout << "No se pudo abrir el fucking socket\n";
         std::cout << "Errno: " << errno << "\n";
         return false;
     }
-    struct sockaddr_ll sa;
-    memset(&sa, 0, sizeof(sa));
-        sa.sll_family = AF_PACKET;
-        sa.sll_protocol = htons(ETH_P_IP);
-        sa.sll_ifindex = 1;                         
-        sa.sll_hatype = 1;
-        sa.sll_pkttype = PACKET_BROADCAST;
-        sa.sll_halen = 0;
-        sa.sll_addr[2] = 0xde;
-    if(bind(sockfd, (struct sockaddr *)&sa, sizeof(sockaddr_ll)) != 0) {
-        std::cout << "Error: " << errno << "\n";
-        return false;
-    }
-  /*  {				
-        int one = 1;
-        const int *val = &one;
-        if (setsockopt (sockfd, IPPROTO_IP, IP_HDRINCL, val, sizeof (one)) < 0)
-          std::cout << "Warning: Cannot set HDRINCL!\n";
-      }*/
-    _sockets[flag] = sockfd;
+
+    const int on = 1;
+    setsockopt(sockfd, IPPROTO_IP,IP_HDRINCL,(const void *)&on,sizeof(on));
+
+    _sockets[IP_SOCKET] = sockfd;
     return true;
 }
 
@@ -55,28 +42,23 @@ bool Tins::PacketSender::close_socket(uint32_t flag) {
     return true;
 }
 
-bool Tins::PacketSender::write(int sock, uint8_t *buffer, uint32_t size) {
-	uint32_t index = 0;
-    int ret;
-	while(size) {
-		if((ret = ::send(sock, &buffer[index], size, 0)) <= 0) {
-            std::cout << errno << "\n";
-            return false;
-        }
-		index += ret;
-		size -= ret;
-	}
-    /*if(!sendto(sock, buffer, size, 0,
-                      const struct sockaddr *dest_addr, socklen_t addrlen);))*/
-	return true;
+bool Tins::PacketSender::send(PDU *pdu) {
+    return pdu->send(this);
 }
 
-bool Tins::PacketSender::send(PDU *pdu) {
-    uint32_t sz, flag(pdu->flag());
-    uint8_t *buffer = pdu->serialize(sz);
+bool Tins::PacketSender::send_l3(PDU *pdu, const struct sockaddr* link_addr, uint32_t len_link_addr) {
     bool ret_val = true;
-    if(!open_socket(flag) || !write(_sockets[flag], buffer, sz))
+    if(!open_l3_socket())
         ret_val = false;
-    delete[] buffer;
+
+    if (ret_val) {
+        uint32_t sz;
+        int sock = _sockets[IP_SOCKET];
+        uint8_t *buffer = pdu->serialize(sz);
+        ret_val = (sendto(sock, buffer, sz, 0, link_addr, len_link_addr) != -1);
+        delete[] buffer;
+    }
+
     return ret_val;
+
 }

src/utils.cpp

@@ -22,12 +22,13 @@ uint32_t Tins::Utils::ip_to_int(const string &ip) {
     }
     if(bytes_found < 4 || (i < ip.size() && bytes_found == 4))
         throw std::runtime_error("Invalid ip address");
-    return result;
+    return ntohl(result);
 }
 
 string Tins::Utils::ip_to_string(uint32_t ip) {
     ostringstream oss;
     int mask(24);
+    ip = ntohl(ip);
     while(mask >=0) {
         oss << ((ip >> mask) & 0xff);
         if(mask)