Добавлен анализ пакета

src/main/java/ru/serega6531/packmate/PcapWorker.java

@@ -6,16 +6,21 @@ import org.pcap4j.core.PcapHandle;
 import org.pcap4j.core.PcapNativeException;
 import org.pcap4j.core.PcapNetworkInterface;
 import org.pcap4j.core.Pcaps;
+import org.pcap4j.packet.IpV4Packet;
 import org.pcap4j.packet.Packet;
+import org.pcap4j.packet.TcpPacket;
+import org.pcap4j.packet.UdpPacket;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Component;
+import ru.serega6531.packmate.model.CtfService;
 import ru.serega6531.packmate.service.PacketService;
 import ru.serega6531.packmate.service.PatternService;
 import ru.serega6531.packmate.service.ServicesService;
 import ru.serega6531.packmate.service.StreamService;
 
 import javax.annotation.PreDestroy;
+import java.util.Optional;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeoutException;
@@ -29,21 +34,26 @@ public class PcapWorker {
     private final PacketService packetService;
     private final PatternService patternService;
 
-    private PcapNetworkInterface device;
+    private final PcapNetworkInterface device;
     private PcapHandle pcap = null;
-    private ExecutorService executorService;
+    private final ExecutorService executorService;
+
+    private final String localIp;
 
     @Autowired
     public PcapWorker(ServicesService servicesService,
                       StreamService streamService,
                       PacketService packetService,
                       PatternService patternService,
-                      @Value("${interface-name}") String interfaceName) throws PcapNativeException {
+                      @Value("${interface-name}") String interfaceName,
+                      @Value("${local-ip}") String localIp) throws PcapNativeException {
         this.servicesService = servicesService;
         this.streamService = streamService;
         this.packetService = packetService;
         this.patternService = patternService;
 
+        this.localIp = localIp;
+
         BasicThreadFactory factory = new BasicThreadFactory.Builder()
                 .namingPattern("pcap-worker").build();
         executorService = Executors.newSingleThreadExecutor(factory);
@@ -84,7 +94,45 @@ public class PcapWorker {
         log.info("Intercept stopped");
     }
 
-    private void processPacket(Packet packet) {
-        System.out.println(packet);
+    private void processPacket(Packet rawPacket) {
+        String sourceIp = null;
+        String destIp = null;
+        int sourcePort = -1;
+        int destPort = -1;
+        byte[] content = null;
+
+        if(rawPacket.contains(IpV4Packet.class)){
+            final IpV4Packet.IpV4Header header = rawPacket.get(IpV4Packet.class).getHeader();
+            sourceIp = header.getSrcAddr().getHostAddress();
+            destIp = header.getDstAddr().getHostAddress();
+        }
+
+        if(rawPacket.contains(TcpPacket.class)) {
+            final TcpPacket packet = rawPacket.get(TcpPacket.class);
+            final TcpPacket.TcpHeader header = packet.getHeader();
+            sourcePort = header.getSrcPort().valueAsInt();
+            destPort = header.getDstPort().valueAsInt();
+            content = packet.getRawData();
+        } else if(rawPacket.contains(UdpPacket.class)) {
+            final UdpPacket packet = rawPacket.get(UdpPacket.class);
+            final UdpPacket.UdpHeader header = packet.getHeader();
+            sourcePort = header.getSrcPort().valueAsInt();
+            destPort = header.getDstPort().valueAsInt();
+            content = packet.getRawData();
+        }
+
+        if(sourceIp != null && sourcePort != -1) {
+            Optional<CtfService> serviceOptional = Optional.empty();
+
+            if(sourceIp.equals(localIp)) {
+                serviceOptional = servicesService.findByPort(sourcePort);
+            } else if(destIp.equals(localIp)) {
+                serviceOptional = servicesService.findByPort(destPort);
+            }
+
+            if(serviceOptional.isPresent()) {
+                log.info("{} {}:{} -> {}:{}", serviceOptional, sourceIp, sourcePort, destIp, destPort);
+            }
+        }
     }
 }

src/main/java/ru/serega6531/packmate/controller/ServiceController.java

@@ -25,7 +25,7 @@ public class ServiceController {
 
     @DeleteMapping("/{port}")
     public void deleteService(@PathVariable int port) {
-        service.deleteById(port);
+        service.deleteByPort(port);
     }
 
     @PostMapping

src/main/java/ru/serega6531/packmate/model/CtfService.java

@@ -1,6 +1,7 @@
 package ru.serega6531.packmate.model;
 
 import lombok.Data;
+import lombok.ToString;
 
 import javax.persistence.*;
 import java.util.List;
@@ -8,6 +9,7 @@ import java.util.List;
 @Data
 @Entity
 @Table(name = "service")
+@ToString(of = {"port", "name"})
 public class CtfService {
 
     @Id

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

@@ -7,6 +7,7 @@ import ru.serega6531.packmate.model.CtfService;
 import ru.serega6531.packmate.repository.ServiceRepository;
 
 import java.util.List;
+import java.util.Optional;
 
 @Service
 @Slf4j
@@ -19,12 +20,16 @@ public class ServicesService {
         this.repository = repository;
     }
 
+    public Optional<CtfService> findByPort(int port) {
+        return repository.findById(port);
+    }
+
     public List<CtfService> findAll() {
         return repository.findAll();
     }
 
-    public void deleteById(int id) {
-        repository.deleteById(id);
+    public void deleteByPort(int port) {
+        repository.deleteById(port);
     }
 
     public CtfService save(CtfService service) {