Тестовая поддержка IPv6

docker/Dockerfile_db

@@ -1,4 +1,4 @@
-FROM postgres:12.2-alpine
+FROM postgres:13.3-alpine
 
 ARG POSTGRES_USER
 ARG POSTGRES_PASSWORD

src/main/java/ru/serega6531/packmate/model/pojo/UnfinishedStream.java

@@ -4,14 +4,14 @@ import lombok.AllArgsConstructor;
 import lombok.Getter;
 import ru.serega6531.packmate.model.enums.Protocol;
 
-import java.net.Inet4Address;
+import java.net.InetAddress;
 
 @AllArgsConstructor
 @Getter
 public class UnfinishedStream {
 
-    private final Inet4Address firstIp;
+    private final InetAddress firstIp;
-    private final Inet4Address secondIp;
+    private final InetAddress secondIp;
     private final int firstPort;
     private final int secondPort;
     private final Protocol protocol;

src/main/java/ru/serega6531/packmate/pcap/AbstractPcapWorker.java

@@ -8,17 +8,13 @@ import org.apache.commons.lang3.tuple.ImmutablePair;
 import org.pcap4j.core.BpfProgram;
 import org.pcap4j.core.PacketListener;
 import org.pcap4j.core.PcapHandle;
-import org.pcap4j.packet.IpV4Packet;
+import org.pcap4j.packet.*;
-import org.pcap4j.packet.Packet;
-import org.pcap4j.packet.TcpPacket;
-import org.pcap4j.packet.UdpPacket;
 import ru.serega6531.packmate.model.CtfService;
 import ru.serega6531.packmate.model.enums.Protocol;
 import ru.serega6531.packmate.model.pojo.UnfinishedStream;
 import ru.serega6531.packmate.service.ServicesService;
 import ru.serega6531.packmate.service.StreamService;
 
-import java.net.Inet4Address;
 import java.net.InetAddress;
 import java.net.UnknownHostException;
 import java.util.ArrayList;
@@ -50,8 +46,8 @@ public abstract class AbstractPcapWorker implements PcapWorker, PacketListener {
     private final ListMultimap<UnfinishedStream, ru.serega6531.packmate.model.Packet> unfinishedUdpStreams = ArrayListMultimap.create();
 
     // в следующих мапах в значениях находится srcIp соответствующего пакета
-    private final SetMultimap<UnfinishedStream, ImmutablePair<Inet4Address, Integer>> fins = HashMultimap.create();
+    private final SetMultimap<UnfinishedStream, ImmutablePair<InetAddress, Integer>> fins = HashMultimap.create();
-    private final SetMultimap<UnfinishedStream, ImmutablePair<Inet4Address, Integer>> acks = HashMultimap.create();
+    private final SetMultimap<UnfinishedStream, ImmutablePair<InetAddress, Integer>> acks = HashMultimap.create();
 
     protected AbstractPcapWorker(ServicesService servicesService,
                               StreamService streamService,
@@ -60,9 +56,6 @@ public abstract class AbstractPcapWorker implements PcapWorker, PacketListener {
         this.streamService = streamService;
 
         this.localIp = InetAddress.getByName(localIpString);
-        if (!(this.localIp instanceof Inet4Address)) {
-            throw new IllegalArgumentException("Only ipv4 local ips are supported");
-        }
 
         BasicThreadFactory factory = new BasicThreadFactory.Builder()
                 .namingPattern("pcap-loop").build();
@@ -70,26 +63,36 @@ public abstract class AbstractPcapWorker implements PcapWorker, PacketListener {
     }
 
     public void gotPacket(Packet rawPacket) {
-        if (!rawPacket.contains(IpV4Packet.class)) {
+        InetAddress sourceIp;
+        InetAddress destIp;
+        int ttl;
+
+        if (rawPacket.contains(IpV4Packet.class)) {
+            final IpV4Packet.IpV4Header ipHeader = rawPacket.get(IpV4Packet.class).getHeader();
+            sourceIp = ipHeader.getSrcAddr();
+            destIp = ipHeader.getDstAddr();
+            ttl = Byte.toUnsignedInt(ipHeader.getTtl());
+        } else if (rawPacket.contains(IpV6Packet.class)) {
+            final IpV6Packet.IpV6Header ipHeader = rawPacket.get(IpV6Packet.class).getHeader();
+            sourceIp = ipHeader.getSrcAddr();
+            destIp = ipHeader.getDstAddr();
+            ttl = Byte.toUnsignedInt(ipHeader.getHopLimit());
+        } else {
             return;
         }
 
         final long time = pcap.getTimestamp().getTime();
 
         if (rawPacket.contains(TcpPacket.class)) {
-            gotTcpPacket(rawPacket, time);
-        } else if (rawPacket.contains(UdpPacket.class)) {
-            gotUdpPacket(rawPacket, time);
-        }
-    }
-
-    private void gotTcpPacket(Packet rawPacket, long time) {
-        final IpV4Packet.IpV4Header ipHeader = rawPacket.get(IpV4Packet.class).getHeader();
-        Inet4Address sourceIp = ipHeader.getSrcAddr();
-        Inet4Address destIp = ipHeader.getDstAddr();
-        int ttl = Byte.toUnsignedInt(ipHeader.getTtl());
-
             final TcpPacket packet = rawPacket.get(TcpPacket.class);
+            gotTcpPacket(packet, sourceIp, destIp, ttl, time);
+        } else if (rawPacket.contains(UdpPacket.class)) {
+            final UdpPacket packet = rawPacket.get(UdpPacket.class);
+            gotUdpPacket(packet, sourceIp, destIp, ttl, time);
+        }
+    }
+
+    private void gotTcpPacket(TcpPacket packet, InetAddress sourceIp, InetAddress destIp, int ttl, long time) {
         final TcpPacket.TcpHeader tcpHeader = packet.getHeader();
         int sourcePort = tcpHeader.getSrcPort().valueAsInt();
         int destPort = tcpHeader.getDstPort().valueAsInt();
@@ -123,13 +126,7 @@ public abstract class AbstractPcapWorker implements PcapWorker, PacketListener {
         }
     }
 
-    private void gotUdpPacket(Packet rawPacket, long time) {
+    private void gotUdpPacket(UdpPacket packet, InetAddress sourceIp, InetAddress destIp, int ttl, long time) {
-        final IpV4Packet.IpV4Header ipHeader = rawPacket.get(IpV4Packet.class).getHeader();
-        Inet4Address sourceIp = ipHeader.getSrcAddr();
-        Inet4Address destIp = ipHeader.getDstAddr();
-        int ttl = Byte.toUnsignedInt(ipHeader.getTtl());
-
-        final UdpPacket packet = rawPacket.get(UdpPacket.class);
         final UdpPacket.UdpHeader udpHeader = packet.getHeader();
         int sourcePort = udpHeader.getSrcPort().valueAsInt();
         int destPort = udpHeader.getDstPort().valueAsInt();
@@ -158,7 +155,7 @@ public abstract class AbstractPcapWorker implements PcapWorker, PacketListener {
         }
     }
 
-    private UnfinishedStream addNewPacket(Inet4Address sourceIp, Inet4Address destIp, long time,
+    private UnfinishedStream addNewPacket(InetAddress sourceIp, InetAddress destIp, long time,
                                           int sourcePort, int destPort, int ttl, byte[] content, Protocol protocol) {
         var incoming = destIp.equals(localIp);
         var stream = new UnfinishedStream(sourceIp, destIp, sourcePort, destPort, protocol);
@@ -185,8 +182,8 @@ public abstract class AbstractPcapWorker implements PcapWorker, PacketListener {
      * Udp не имеет фазы закрытия, поэтому закрывается только по таймауту
      */
     private void checkTcpTermination(boolean ack, boolean fin, boolean rst,
-                                     ImmutablePair<Inet4Address, Integer> sourceIpAndPort,
+                                     ImmutablePair<InetAddress, Integer> sourceIpAndPort,
-                                     ImmutablePair<Inet4Address, Integer> destIpAndPort,
+                                     ImmutablePair<InetAddress, Integer> destIpAndPort,
                                      UnfinishedStream stream) {
 
         if (fin) {

src/main/java/ru/serega6531/packmate/service/ServicesService.java

@@ -12,7 +12,6 @@ import ru.serega6531.packmate.model.pojo.ServiceDto;
 import ru.serega6531.packmate.model.pojo.SubscriptionMessage;
 import ru.serega6531.packmate.repository.ServiceRepository;
 
-import java.net.Inet4Address;
 import java.net.InetAddress;
 import java.net.UnknownHostException;
 import java.util.Collection;
@@ -53,7 +52,7 @@ public class ServicesService {
         return services.get(id);
     }
 
-    public Optional<CtfService> findService(Inet4Address firstIp, int firstPort, Inet4Address secondIp, int secondPort) {
+    public Optional<CtfService> findService(InetAddress firstIp, int firstPort, InetAddress secondIp, int secondPort) {
         if (firstIp.equals(localIp)) {
             return findByPort(firstPort);
         } else if (secondIp.equals(localIp)) {