Рефакторинг

src/main/java/ru/serega6531/packmate/service/optimization/HttpChunksProcessor.java

@@ -0,0 +1,142 @@
+package ru.serega6531.packmate.service.optimization;
+
+import lombok.AllArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import ru.serega6531.packmate.model.Packet;
+import ru.serega6531.packmate.utils.Bytes;
+import ru.serega6531.packmate.utils.PacketUtils;
+
+import java.io.ByteArrayOutputStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+@Slf4j
+@AllArgsConstructor
+public class HttpChunksProcessor {
+
+    private List<Packet> packets;
+
+    public void processChunkedEncoding() {
+        boolean chunkStarted = false;
+        int start = -1;
+        List<Packet> chunk = new ArrayList<>();
+
+        for (int i = 0; i < packets.size(); i++) {
+            Packet packet = packets.get(i);
+            if (!packet.isIncoming()) {
+                String content = packet.getContentString();
+
+                boolean http = content.startsWith("HTTP/");
+                int contentPos = content.indexOf("\r\n\r\n");
+
+                if (http && contentPos != -1) {   // начало body
+                    String headers = content.substring(0, contentPos + 2);  // захватываем первые \r\n
+                    boolean chunked = headers.contains("Transfer-Encoding: chunked\r\n");
+                    if (chunked) {
+                        chunkStarted = true;
+                        start = i;
+                        chunk.add(packet);
+
+                        if (checkCompleteChunk(chunk, start)) {
+                            chunkStarted = false;
+                            chunk.clear();
+                            i = start + 1;
+                        }
+                    } else {
+                        chunkStarted = false;
+                        chunk.clear();
+                    }
+                } else if (chunkStarted) {
+                    chunk.add(packet);
+                    if (checkCompleteChunk(chunk, start)) {
+                        chunkStarted = false;
+                        chunk.clear();
+                        i = start + 1;
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * @return true если чанк завершен
+     */
+    private boolean checkCompleteChunk(List<Packet> chunk, int start) {
+        boolean end = chunk.get(chunk.size() - 1).getContentString().endsWith("\r\n0\r\n\r\n");
+
+        if (end) {
+            //noinspection OptionalGetWithoutIsPresent
+            final byte[] content = PacketUtils.mergePackets(chunk).get();
+
+            ByteArrayOutputStream output = new ByteArrayOutputStream(content.length);
+
+            final int contentStart = Bytes.indexOf(content, "\r\n\r\n".getBytes()) + 4;
+            output.write(content, 0, contentStart);
+
+            final byte[] body = Arrays.copyOfRange(content, contentStart, content.length);
+
+            int currentPos = 0;
+
+            while (true) {
+                final String found = readChunkSize(body, currentPos);
+                if (found != null) {
+                    final int chunkSize = Integer.parseInt(found, 16);
+
+                    if (chunkSize == 0) {  // конец потока чанков
+                        Packet result = Packet.builder()
+                                .incoming(false)
+                                .timestamp(chunk.get(0).getTimestamp())
+                                .ungzipped(false)
+                                .webSocketParsed(false)
+                                .content(output.toByteArray())
+                                .build();
+
+                        packets.removeAll(chunk);
+                        packets.add(start, result);
+
+                        return true;
+                    }
+
+                    currentPos += found.length() + 2;
+
+                    if (currentPos + chunkSize >= body.length) {
+                        log.warn("Failed to merge chunks, chunk size too big: {} + {} > {}", currentPos, chunkSize, body.length);
+                        return true;  // обнулить список, но не заменять пакеты
+                    }
+
+                    output.write(body, currentPos, chunkSize);
+                    currentPos += chunkSize;
+
+                    if (currentPos + 2 >= body.length || body[currentPos] != '\r' || body[currentPos + 1] != '\n') {
+                        log.warn("Failed to merge chunks, chunk doesn't end with \\r\\n");
+                        return true;  // обнулить список, но не заменять пакеты
+                    }
+
+                    currentPos += 2;
+                } else {
+                    log.warn("Failed to merge chunks, next chunk size not found");
+                    return true;  // обнулить список, но не заменять пакеты
+                }
+            }
+        }
+
+        return false;
+    }
+
+    private String readChunkSize(byte[] content, int start) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = start; i < content.length - 1; i++) {
+            byte b = content[i];
+
+            if ((b >= '0' && b <= '9') || (b >= 'a' && b <= 'f')) {
+                sb.append((char) b);
+            } else if (b == '\r' && content[i + 1] == '\n') {
+                return sb.toString();
+            }
+        }
+
+        return null;
+    }
+
+}

src/main/java/ru/serega6531/packmate/service/optimization/HttpGzipProcessor.java

@@ -0,0 +1,128 @@
+package ru.serega6531.packmate.service.optimization;
+
+import lombok.AllArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.io.IOUtils;
+import org.apache.commons.lang3.ArrayUtils;
+import ru.serega6531.packmate.model.Packet;
+import ru.serega6531.packmate.utils.Bytes;
+import ru.serega6531.packmate.utils.PacketUtils;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
+import java.util.zip.GZIPInputStream;
+import java.util.zip.ZipException;
+
+@Slf4j
+@AllArgsConstructor
+public class HttpGzipProcessor {
+
+    private static final byte[] GZIP_HEADER = {0x1f, (byte) 0x8b, 0x08};
+
+    private List<Packet> packets;
+
+    /**
+     * Попытаться распаковать GZIP из исходящих http пакетов. <br>
+     * GZIP поток начинается на найденном HTTP пакете с заголовком Content-Encoding: gzip
+     * (при этом заголовок HTTP может быть в другом пакете)<br>
+     * Поток заканчивается при обнаружении нового HTTP заголовка,
+     * при смене стороны передачи или при окончании всего стрима
+     */
+    public void unpackGzip() {
+        boolean gzipStarted = false;
+        int gzipStartPacket = 0;
+        int gzipEndPacket;
+
+        for (int i = 0; i < packets.size(); i++) {
+            Packet packet = packets.get(i);
+
+            if (packet.isIncoming() && gzipStarted) {   // поток gzip закончился
+                gzipEndPacket = i - 1;
+                if (extractGzip(gzipStartPacket, gzipEndPacket)) {
+                    gzipStarted = false;
+                    i = gzipStartPacket + 1;  // продвигаем указатель на следующий после склеенного блок
+                }
+            } else if (!packet.isIncoming()) {
+                String content = packet.getContentString();
+
+                int contentPos = content.indexOf("\r\n\r\n");
+                boolean http = content.startsWith("HTTP/");
+
+                if (http && gzipStarted) {  // начался новый http пакет, заканчиваем старый gzip поток
+                    gzipEndPacket = i - 1;
+                    if (extractGzip(gzipStartPacket, gzipEndPacket)) {
+                        gzipStarted = false;
+                        i = gzipStartPacket + 1;  // продвигаем указатель на следующий после склеенного блок
+                    }
+                }
+
+                if (contentPos != -1) {   // начало body
+                    String headers = content.substring(0, contentPos + 2);  // захватываем первые \r\n
+                    boolean gziped = headers.contains("Content-Encoding: gzip\r\n");
+                    if (gziped) {
+                        gzipStarted = true;
+                        gzipStartPacket = i;
+                    }
+                }
+            }
+        }
+
+        if (gzipStarted) {  // стрим закончился gzip пакетом
+            extractGzip(gzipStartPacket, packets.size() - 1);
+        }
+    }
+
+    /**
+     * Попытаться распаковать кусок пакетов с gzip body и вставить результат на их место
+     *
+     * @return получилось ли распаковать
+     */
+    private boolean extractGzip(int gzipStartPacket, int gzipEndPacket) {
+        List<Packet> cut = packets.subList(gzipStartPacket, gzipEndPacket + 1);
+
+        Packet decompressed = decompressGzipPackets(cut);
+        if (decompressed != null) {
+            packets.removeAll(cut);
+            packets.add(gzipStartPacket, decompressed);
+            return true;
+        }
+
+        return false;
+    }
+
+    private Packet decompressGzipPackets(List<Packet> cut) {
+        //noinspection OptionalGetWithoutIsPresent
+        final byte[] content = PacketUtils.mergePackets(cut).get();
+
+        final int gzipStart = Bytes.indexOf(content, GZIP_HEADER);
+        byte[] httpHeader = Arrays.copyOfRange(content, 0, gzipStart);
+        byte[] gzipBytes = Arrays.copyOfRange(content, gzipStart, content.length);
+
+        try {
+            final GZIPInputStream gzipStream = new GZIPInputStream(new ByteArrayInputStream(gzipBytes));
+            ByteArrayOutputStream out = new ByteArrayOutputStream();
+            IOUtils.copy(gzipStream, out);
+            byte[] newContent = ArrayUtils.addAll(httpHeader, out.toByteArray());
+
+            log.debug("GZIP decompressed: {} -> {} bytes", gzipBytes.length, out.size());
+
+            return Packet.builder()
+                    .incoming(false)
+                    .timestamp(cut.get(0).getTimestamp())
+                    .ungzipped(true)
+                    .webSocketParsed(false)
+                    .content(newContent)
+                    .build();
+        } catch (ZipException e) {
+            log.warn("Failed to decompress gzip, leaving as it is: {}", e.getMessage());
+        } catch (IOException e) {
+            log.error("decompress gzip", e);
+        }
+
+        return null;
+    }
+
+}

src/main/java/ru/serega6531/packmate/service/optimization/HttpUrldecodeProcessor.java

@@ -0,0 +1,46 @@
+package ru.serega6531.packmate.service.optimization;
+
+import lombok.AllArgsConstructor;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import ru.serega6531.packmate.model.Packet;
+
+import java.net.URLDecoder;
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+
+@AllArgsConstructor
+@Slf4j
+public class HttpUrldecodeProcessor {
+
+    private List<Packet> packets;
+
+    /**
+     * Декодирование urlencode с http пакета до смены стороны или окончания стрима
+     */
+    @SneakyThrows
+    public void urldecodeRequests() {
+        boolean httpStarted = false;
+
+        for (Packet packet : packets) {
+            if (packet.isIncoming()) {
+                String content = packet.getContentString();
+                if (content.contains("HTTP/")) {
+                    httpStarted = true;
+                }
+
+                if (httpStarted) {
+                    try {
+                        content = URLDecoder.decode(content, StandardCharsets.UTF_8.toString());
+                        packet.setContent(content.getBytes());
+                    } catch (IllegalArgumentException e) {
+                        log.warn("urldecode", e);
+                    }
+                }
+            } else {
+                httpStarted = false;
+            }
+        }
+    }
+
+}

src/main/java/ru/serega6531/packmate/service/optimization/PacketsMerger.java

@@ -0,0 +1,67 @@
+package ru.serega6531.packmate.service.optimization;
+
+import lombok.AllArgsConstructor;
+import ru.serega6531.packmate.model.Packet;
+import ru.serega6531.packmate.utils.PacketUtils;
+
+import java.util.List;
+
+@AllArgsConstructor
+public class PacketsMerger {
+
+    private List<Packet> packets;
+
+    /**
+     * Сжать соседние пакеты в одном направлении в один.
+     * Выполняется после других оптимизаций чтобы правильно определять границы пакетов.
+     */
+    public void mergeAdjacentPackets() {
+        int start = 0;
+        int packetsInRow = 0;
+        boolean incoming = true;
+
+        for (int i = 0; i < packets.size(); i++) {
+            Packet packet = packets.get(i);
+            if (packet.isIncoming() != incoming) {
+                if (packetsInRow > 1) {
+                    compress(start, i);
+
+                    i = start + 1;  // продвигаем указатель на следующий после склеенного блок
+                }
+                start = i;
+                packetsInRow = 1;
+            } else {
+                packetsInRow++;
+            }
+
+            incoming = packet.isIncoming();
+        }
+
+        if (packetsInRow > 1) {
+            compress(start, packets.size());
+        }
+    }
+
+    /**
+     * Сжать кусок со start по end в один пакет
+     */
+    private void compress(int start, int end) {
+        final List<Packet> cut = packets.subList(start, end);
+        final long timestamp = cut.get(0).getTimestamp();
+        final boolean ungzipped = cut.stream().anyMatch(Packet::isUngzipped);
+        final boolean webSocketParsed = cut.stream().anyMatch(Packet::isWebSocketParsed);
+        boolean incoming = cut.get(0).isIncoming();
+        //noinspection OptionalGetWithoutIsPresent
+        final byte[] content = PacketUtils.mergePackets(cut).get();
+
+        packets.removeAll(cut);
+        packets.add(start, Packet.builder()
+                .incoming(incoming)
+                .timestamp(timestamp)
+                .ungzipped(ungzipped)
+                .webSocketParsed(webSocketParsed)
+                .content(content)
+                .build());
+    }
+
+}

src/main/java/ru/serega6531/packmate/service/optimization/StreamOptimizer.java

@@ -0,0 +1,96 @@
+package ru.serega6531.packmate.service.optimization;
+
+import lombok.AllArgsConstructor;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import ru.serega6531.packmate.model.CtfService;
+import ru.serega6531.packmate.model.Packet;
+
+import java.util.List;
+
+@AllArgsConstructor
+@Slf4j
+public class StreamOptimizer {
+
+    private final CtfService service;
+    private List<Packet> packets;
+
+    /**
+     * Вызвать для выполнения оптимизаций на переданном списке пакетов.
+     */
+    public List<Packet> optimizeStream() {
+        if (service.isProcessChunkedEncoding()) {
+            processChunkedEncoding();
+        }
+
+        if (service.isUngzipHttp()) {
+            unpackGzip();
+        }
+
+        if (service.isParseWebSockets()) {
+            parseWebSockets();
+        }
+
+        if (service.isUrldecodeHttpRequests()) {
+            urldecodeRequests();
+        }
+
+        if (service.isMergeAdjacentPackets()) {
+            mergeAdjacentPackets();
+        }
+
+        return packets;
+    }
+
+    /**
+     * Сжать соседние пакеты в одном направлении в один.
+     * Выполняется после других оптимизаций чтобы правильно определять границы пакетов.
+     */
+    private void mergeAdjacentPackets() {
+        final PacketsMerger merger = new PacketsMerger(packets);
+        merger.mergeAdjacentPackets();
+    }
+
+    /**
+     * Декодирование urlencode с http пакета до смены стороны или окончания стрима
+     */
+    @SneakyThrows
+    private void urldecodeRequests() {
+        final HttpUrldecodeProcessor processor = new HttpUrldecodeProcessor(packets);
+        processor.urldecodeRequests();
+    }
+
+    /**
+     * https://ru.wikipedia.org/wiki/Chunked_transfer_encoding
+     */
+    private void processChunkedEncoding() {
+        HttpChunksProcessor processor = new HttpChunksProcessor(packets);
+        processor.processChunkedEncoding();
+    }
+
+    /**
+     * Попытаться распаковать GZIP из исходящих http пакетов. <br>
+     * GZIP поток начинается на найденном HTTP пакете с заголовком Content-Encoding: gzip
+     * (при этом заголовок HTTP может быть в другом пакете)<br>
+     * Поток заканчивается при обнаружении нового HTTP заголовка,
+     * при смене стороны передачи или при окончании всего стрима
+     */
+    private void unpackGzip() {
+        final HttpGzipProcessor processor = new HttpGzipProcessor(packets);
+        processor.unpackGzip();
+    }
+
+    private void parseWebSockets() {
+        if (!packets.get(0).getContentString().contains("HTTP/")) {
+            return;
+        }
+
+        final WebSocketsParser parser = new WebSocketsParser(packets);
+        if (!parser.isParsed()) {
+            return;
+        }
+
+        packets = parser.getParsedPackets();
+    }
+
+}

src/main/java/ru/serega6531/packmate/service/optimization/WebSocketsParser.java

@@ -0,0 +1,247 @@
+package ru.serega6531.packmate.service.optimization;
+
+import lombok.Getter;
+import lombok.extern.slf4j.Slf4j;
+import org.java_websocket.drafts.Draft_6455;
+import org.java_websocket.exceptions.InvalidDataException;
+import org.java_websocket.exceptions.InvalidHandshakeException;
+import org.java_websocket.extensions.permessage_deflate.PerMessageDeflateExtension;
+import org.java_websocket.framing.DataFrame;
+import org.java_websocket.framing.Framedata;
+import org.java_websocket.handshake.HandshakeImpl1Client;
+import org.java_websocket.handshake.HandshakeImpl1Server;
+import ru.serega6531.packmate.model.Packet;
+import ru.serega6531.packmate.utils.PacketUtils;
+
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.stream.Collectors;
+
+@Slf4j
+public class WebSocketsParser {
+
+    private static final java.util.regex.Pattern WEBSOCKET_KEY_PATTERN =
+            java.util.regex.Pattern.compile("Sec-WebSocket-Key: (.+)\\r\\n");
+    private static final java.util.regex.Pattern WEBSOCKET_EXTENSIONS_PATTERN =
+            java.util.regex.Pattern.compile("Sec-WebSocket-Extensions?: (.+)\\r\\n");
+    private static final java.util.regex.Pattern WEBSOCKET_VERSION_PATTERN =
+            java.util.regex.Pattern.compile("Sec-WebSocket-Version: (\\d+)\\r\\n");
+    private static final java.util.regex.Pattern WEBSOCKET_ACCEPT_PATTERN =
+            java.util.regex.Pattern.compile("Sec-WebSocket-Accept: (.+)\\r\\n");
+
+    private static final String WEBSOCKET_UPGRADE_HEADER = "upgrade: websocket\r\n";
+    private static final String WEBSOCKET_CONNECTION_HEADER = "connection: upgrade\r\n";
+
+    private final List<Packet> packets;
+
+    @Getter
+    private boolean parsed = false;
+    private List<Packet> parsedPackets;
+
+    public WebSocketsParser(List<Packet> packets) {
+        this.packets = packets;
+        detectWebSockets();
+    }
+
+    private void detectWebSockets() {
+        final List<Packet> clientHandshakePackets = packets.stream()
+                .takeWhile(Packet::isIncoming)
+                .collect(Collectors.toList());
+
+        final String clientHandshake = getHandshake(clientHandshakePackets);
+        if (clientHandshake == null) {
+            return;
+        }
+
+        int httpEnd = -1;
+        for (int i = clientHandshakePackets.size(); i < packets.size(); i++) {
+            if (packets.get(i).getContentString().endsWith("\r\n\r\n")) {
+                httpEnd = i + 1;
+                break;
+            }
+        }
+
+        if (httpEnd == -1) {
+            return;
+        }
+
+        final List<Packet> serverHandshakePackets = packets.subList(clientHandshakePackets.size(), httpEnd);
+        final String serverHandshake = getHandshake(serverHandshakePackets);
+        if (serverHandshake == null) {
+            return;
+        }
+
+        HandshakeImpl1Server serverHandshakeImpl = fillServerHandshake(serverHandshake);
+        HandshakeImpl1Client clientHandshakeImpl = fillClientHandshake(clientHandshake);
+
+        if (serverHandshakeImpl == null || clientHandshakeImpl == null) {
+            return;
+        }
+
+        Draft_6455 draft = new Draft_6455(new PerMessageDeflateExtension());
+
+        try {
+            draft.acceptHandshakeAsServer(clientHandshakeImpl);
+            draft.acceptHandshakeAsClient(clientHandshakeImpl, serverHandshakeImpl);
+        } catch (InvalidHandshakeException e) {
+            log.warn("WebSocket handshake", e);
+            return;
+        }
+
+        final List<Packet> wsPackets = packets.subList(
+                httpEnd,
+                packets.size());
+
+        if(wsPackets.isEmpty()) {
+            return;
+        }
+
+        final List<Packet> handshakes = packets.subList(0, httpEnd);
+
+        parse(wsPackets, handshakes, draft);
+    }
+
+    private void parse(final List<Packet> wsPackets, final List<Packet> handshakes, Draft_6455 draft) {
+        List<List<Packet>> sides = sliceToSides(wsPackets);
+        parsedPackets = new ArrayList<>(handshakes);
+
+        for (List<Packet> side : sides) {
+            final Packet lastPacket = side.get(0);
+
+            //noinspection OptionalGetWithoutIsPresent
+            final byte[] wsContent = PacketUtils.mergePackets(side).get();
+
+            final ByteBuffer buffer = ByteBuffer.wrap(wsContent);
+            List<Framedata> frames;
+
+            try {
+                frames = draft.translateFrame(buffer);
+            } catch (InvalidDataException e) {
+                log.warn("WebSocket data", e);
+                return;
+            }
+
+            for (Framedata frame : frames) {
+                if(frame instanceof DataFrame) {
+                    parsedPackets.add(Packet.builder()
+                            .content(frame.getPayloadData().array())
+                            .incoming(lastPacket.isIncoming())
+                            .timestamp(lastPacket.getTimestamp())
+                            .ttl(lastPacket.getTtl())
+                            .ungzipped(lastPacket.isUngzipped())
+                            .webSocketParsed(true)
+                            .build()
+                    );
+                }
+            }
+        }
+
+        parsed = true;
+    }
+
+    public List<Packet> getParsedPackets() {
+        if (!parsed) {
+            throw new IllegalStateException("WS is not parsed");
+        }
+
+        return parsedPackets;
+    }
+
+    private List<List<Packet>> sliceToSides(List<Packet> packets) {
+        List<List<Packet>> result = new ArrayList<>();
+        List<Packet> side = new ArrayList<>();
+        boolean incoming = true;
+
+        for (Packet packet : packets) {
+            if(packet.isIncoming() != incoming) {
+                incoming = packet.isIncoming();
+
+                if(!side.isEmpty()) {
+                    result.add(side);
+                    side = new ArrayList<>();
+                }
+            }
+
+            side.add(packet);
+        }
+
+        if(!side.isEmpty()) {
+            result.add(side);
+        }
+
+        return result;
+    }
+
+    private String getHandshake(final List<Packet> packets) {
+        final String handshake = PacketUtils.mergePackets(packets)
+                .map(String::new)
+                .orElse(null);
+
+        if (handshake == null ||
+                !handshake.toLowerCase().contains(WEBSOCKET_CONNECTION_HEADER) ||
+                !handshake.toLowerCase().contains(WEBSOCKET_UPGRADE_HEADER)) {
+            return null;
+        }
+
+        return handshake;
+    }
+
+    private HandshakeImpl1Client fillClientHandshake(String clientHandshake) {
+        Matcher matcher = WEBSOCKET_VERSION_PATTERN.matcher(clientHandshake);
+        if (!matcher.find()) {
+            return null;
+        }
+        String version = matcher.group(1);
+
+        matcher = WEBSOCKET_KEY_PATTERN.matcher(clientHandshake);
+        if (!matcher.find()) {
+            return null;
+        }
+        String key = matcher.group(1);
+
+        matcher = WEBSOCKET_EXTENSIONS_PATTERN.matcher(clientHandshake);
+        String extensions = null;
+        if (matcher.find()) {
+            extensions = matcher.group(1);
+        }
+
+        HandshakeImpl1Client clientHandshakeImpl = new HandshakeImpl1Client();
+
+        clientHandshakeImpl.put("Upgrade", "websocket");
+        clientHandshakeImpl.put("Connection", "Upgrade");
+        clientHandshakeImpl.put("Sec-WebSocket-Version", version);
+        clientHandshakeImpl.put("Sec-WebSocket-Key", key);
+
+        if(extensions != null) {
+            clientHandshakeImpl.put("Sec-WebSocket-Extensions", extensions);
+        }
+
+        return clientHandshakeImpl;
+    }
+
+    private HandshakeImpl1Server fillServerHandshake(String serverHandshake) {
+        Matcher matcher = WEBSOCKET_ACCEPT_PATTERN.matcher(serverHandshake);
+        if (!matcher.find()) {
+            return null;
+        }
+        String accept = matcher.group(1);
+
+        matcher = WEBSOCKET_EXTENSIONS_PATTERN.matcher(serverHandshake);
+        String extensions = null;
+        if (matcher.find()) {
+            extensions = matcher.group(1);
+        }
+
+        HandshakeImpl1Server serverHandshakeImpl = new HandshakeImpl1Server();
+
+        serverHandshakeImpl.put("Upgrade", "websocket");
+        serverHandshakeImpl.put("Connection", "Upgrade");
+        serverHandshakeImpl.put("Sec-WebSocket-Accept", accept);
+        serverHandshakeImpl.put("Sec-WebSocket-Extensions", extensions);
+
+        return serverHandshakeImpl;
+    }
+
+}