Доделан поиск сигнатур

2019-04-30 22:35:57 +03:00
parent 64507a6d07
commit a121a5550d
6 changed files with 99 additions and 81 deletions
--- a/src/main/java/ru/serega6531/packmate/PcapWorker.java
+++ b/src/main/java/ru/serega6531/packmate/PcapWorker.java
@@ -14,9 +14,9 @@ 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.model.Stream;
 import ru.serega6531.packmate.model.UnfinishedStream;
-import ru.serega6531.packmate.service.*;
+import ru.serega6531.packmate.service.ServicesService;
+import ru.serega6531.packmate.service.StreamService;

 import javax.annotation.PreDestroy;
 import java.net.Inet4Address;
@@ -31,8 +31,6 @@ public class PcapWorker {

    private final ServicesService servicesService;
    private final StreamService streamService;
-    private final PacketService packetService;
-    private final StreamSubscriptionService subscriptionService;

    private final PcapNetworkInterface device;
    private PcapHandle pcap = null;
@@ -51,14 +49,10 @@ public class PcapWorker {
    @Autowired
    public PcapWorker(ServicesService servicesService,
                      StreamService streamService,
-                      PacketService packetService,
-                      StreamSubscriptionService subscriptionService,
                      @Value("${interface-name}") String interfaceName,
                      @Value("${local-ip}") String localIp) throws PcapNativeException {
        this.servicesService = servicesService;
        this.streamService = streamService;
-        this.packetService = packetService;
-        this.subscriptionService = subscriptionService;

        this.localIp = localIp;

@@ -143,7 +137,8 @@ public class PcapWorker {
        }

        if (sourceIpString != null && sourcePort != -1) {
-            final Optional<CtfService> serviceOptional = findService(sourceIpString, sourcePort, destIpString, destPort);
+            final Optional<CtfService> serviceOptional =
+                    servicesService.findService(localIp, sourceIpString, sourcePort, destIpString, destPort);

            if (serviceOptional.isPresent()) {
                String sourceIpAndPort = sourceIpString + ":" + sourcePort;
@@ -190,48 +185,14 @@ public class PcapWorker {
                    }

                    if (rst || (acksForStream.contains(sourceIpAndPort) && acksForStream.contains(destIpAndPort))) {
-                        log.info("Конец стрима");
-                        saveStream(stream);
-                    }
-                }
-            }
-        }
-    }
+                        streamService.saveNewStream(stream, unfinishedStreams.get(stream));

-    private void saveStream(UnfinishedStream unfinishedStream) {
-        final List<ru.serega6531.packmate.model.Packet> packets = unfinishedStreams.get(unfinishedStream);
-
-        Stream stream = new Stream();
-        stream.setProtocol(unfinishedStream.getProtocol());
-        stream.setStartTimestamp(packets.get(0).getTimestamp());
-        stream.setEndTimestamp(packets.get(packets.size() - 1).getTimestamp());
-        stream.setService(findService(
-                unfinishedStream.getFirstIp().getHostAddress(),
-                unfinishedStream.getFirstPort(),
-                unfinishedStream.getSecondIp().getHostAddress(),
-                unfinishedStream.getSecondPort()
-        ).get());
-
-        Stream savedStream = streamService.save(stream);
-
-        List<ru.serega6531.packmate.model.Packet> savedPackets = new ArrayList<>();
-        for (ru.serega6531.packmate.model.Packet packet : packets) {
-            packet.setStream(savedStream);
-            savedPackets.add(packetService.save(packet));
-        }
-
-        savedStream.setPackets(savedPackets);
-        savedStream = streamService.save(savedStream);
-        subscriptionService.broadcastNewStream(savedStream);
-    }
-
-    private Optional<CtfService> findService(String firstIp, int firstPort, String secondIp, int secondPort) {
-        if(firstIp.equals(localIp)) {
-            return servicesService.findByPort(firstPort);
-        } else if(secondIp.equals(localIp)) {
-            return servicesService.findByPort(secondPort);
-        }
-
-        return Optional.empty();
+                        unfinishedStreams.remove(stream);
+                        fins.remove(stream);
+                        acks.remove(stream);
+                    }
+                }
+            }
+        }
    }
 }
--- a/src/main/java/ru/serega6531/packmate/model/CtfService.java
+++ b/src/main/java/ru/serega6531/packmate/model/CtfService.java
@@ -10,7 +10,7 @@ import java.util.List;
@Data
@Entity
@Table(name = "service")
-@ToString(of = {"port", "name"})
+@ToString(exclude = "streams")
 public class CtfService {

    @Id
--- a/src/main/java/ru/serega6531/packmate/model/Pattern.java
+++ b/src/main/java/ru/serega6531/packmate/model/Pattern.java
@@ -3,9 +3,8 @@ package ru.serega6531.packmate.model;
 import lombok.Data;
 import org.hibernate.annotations.GenericGenerator;

-import javax.persistence.Entity;
-import javax.persistence.GeneratedValue;
-import javax.persistence.Id;
+import javax.persistence.*;
+import java.util.List;

@Data
@Entity
@@ -30,4 +29,7 @@ public class Pattern {

    private String color;  // для вставки в css

+    @ManyToMany(mappedBy = "foundPatterns", cascade = CascadeType.ALL)
+    private List<Stream> matchedStreams;
+
 }
--- a/src/main/java/ru/serega6531/packmate/model/Stream.java
+++ b/src/main/java/ru/serega6531/packmate/model/Stream.java
@@ -2,14 +2,15 @@ package ru.serega6531.packmate.model;

 import com.fasterxml.jackson.annotation.JsonIgnore;
 import lombok.Data;
+import lombok.ToString;
 import org.hibernate.annotations.GenericGenerator;
 import ru.serega6531.packmate.Protocol;

 import javax.persistence.*;
 import java.util.List;
-import java.util.Set;

@Data
+@ToString(exclude = "packets")
@Entity
@GenericGenerator(
        name = "stream_generator",
@@ -40,6 +41,7 @@ public class Stream {

    private long endTimestamp;

-    private Set<Pattern> foundPatterns;
+    @ManyToMany(cascade = CascadeType.ALL)
+    private List<Pattern> foundPatterns;

 }
--- a/src/main/java/ru/serega6531/packmate/service/ServicesService.java
+++ b/src/main/java/ru/serega6531/packmate/service/ServicesService.java
@@ -20,6 +20,16 @@ public class ServicesService {
        this.repository = repository;
    }

+    public Optional<CtfService> findService(String localIp, String firstIp, int firstPort, String secondIp, int secondPort) {
+        if(firstIp.equals(localIp)) {
+            return findByPort(firstPort);
+        } else if(secondIp.equals(localIp)) {
+            return findByPort(secondPort);
+        }
+
+        return Optional.empty();
+    }
+
    public Optional<CtfService> findByPort(int port) {
        return repository.findById(port);
    }
--- a/src/main/java/ru/serega6531/packmate/service/StreamService.java
+++ b/src/main/java/ru/serega6531/packmate/service/StreamService.java
@@ -2,15 +2,16 @@ package ru.serega6531.packmate.service;

 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import ru.serega6531.packmate.model.Packet;
 import ru.serega6531.packmate.model.Pattern;
 import ru.serega6531.packmate.model.Stream;
+import ru.serega6531.packmate.model.UnfinishedStream;
 import ru.serega6531.packmate.repository.StreamRepository;

-import java.util.HashSet;
-import java.util.List;
-import java.util.Optional;
-import java.util.Set;
+import java.util.*;

@Service
@Slf4j
@@ -18,26 +19,68 @@ public class StreamService {

    private final StreamRepository repository;
    private final PatternService patternService;
+    private final ServicesService servicesService;
+    private final PacketService packetService;
+    private final StreamSubscriptionService subscriptionService;
+
+    private final String localIp;

    @Autowired
-    public StreamService(StreamRepository repository, PatternService patternService) {
+    public StreamService(StreamRepository repository,
+                         PatternService patternService,
+                         ServicesService servicesService,
+                         PacketService packetService,
+                         StreamSubscriptionService subscriptionService,
+                         @Value("${local-ip}") String localIp) {
        this.repository = repository;
        this.patternService = patternService;
+        this.servicesService = servicesService;
+        this.packetService = packetService;
+        this.subscriptionService = subscriptionService;
+        this.localIp = localIp;
+    }
+
+    @Transactional
+    public void saveNewStream(UnfinishedStream unfinishedStream, List<Packet> packets) {
+        Stream stream = new Stream();
+        stream.setProtocol(unfinishedStream.getProtocol());
+        stream.setStartTimestamp(packets.get(0).getTimestamp());
+        stream.setEndTimestamp(packets.get(packets.size() - 1).getTimestamp());
+        stream.setService(servicesService.findService(
+                localIp,
+                unfinishedStream.getFirstIp().getHostAddress(),
+                unfinishedStream.getFirstPort(),
+                unfinishedStream.getSecondIp().getHostAddress(),
+                unfinishedStream.getSecondPort()
+        ).get());
+
+        Stream savedStream = save(stream);
+
+        List<ru.serega6531.packmate.model.Packet> savedPackets = new ArrayList<>();
+        Set<Pattern> matches = new HashSet<>();
+
+        for (ru.serega6531.packmate.model.Packet packet : packets) {
+            packet.setStream(savedStream);
+            savedPackets.add(packetService.save(packet));
+            matches.addAll(patternService.findMatching(packet.getContent()));
+        }
+
+        savedStream.setFoundPatterns(new ArrayList<>(matches));
+        savedStream.setPackets(savedPackets);
+        savedStream = save(savedStream);
+
+        subscriptionService.broadcastNewStream(savedStream);
    }

    public Stream save(Stream stream) {
-        if(!stream.getPackets().isEmpty()) {
-            Set<Pattern> matches = new HashSet<>();
-
-            stream.getPackets().forEach(packet -> {
-                matches.addAll(patternService.findMatching(packet.getContent()));
-            });
-
-            stream.setFoundPatterns(matches);
+        Stream saved;
+        if(stream.getId() == null) {
+            saved = repository.save(stream);
+            log.info("Создан стрим с id {}", saved.getId());
+        } else {
+            saved = repository.save(stream);
        }

-        final Stream saved = repository.save(stream);
-        log.info("Создан стрим с id {}", saved.getId());
        return saved;
    }