JAVA使用socket方式发包

淡淡的烟草味﹌ 2023-10-13 21:03 3阅读 0赞

package com.bree.proxy.utils;
    
    import com.sun.org.apache.xml.internal.security.utils.Base64;
    
    import javax.net.ssl.*;
    import java.io.*;
    import java.net.*;
    import java.security.KeyManagementException;
    import java.security.NoSuchAlgorithmException;
    import java.security.SecureRandom;
    import java.security.cert.CertificateException;
    import java.security.cert.X509Certificate;
    import java.util.*;
    import java.util.logging.Level;
    import java.util.logging.Logger;
    
    public class ProxiedHttpsConnection extends HttpURLConnection {
    
        private final String proxyHost;
        private final int proxyPort;
        private static final byte[] NEWLINE = "\r\n".getBytes();//should be "ASCII7"
    
        private Socket socket;
        private final Map<String, List<String>> headers = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
        private final Map<String, List<String>> sendheaders = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
        private final Map<String, List<String>> proxyheaders = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
        private final Map<String, List<String>> proxyreturnheaders = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
        private int statusCode;
        private String statusLine;
        private boolean isDoneWriting;
    
        public ProxiedHttpsConnection(URL url,
                                      String proxyHost, int proxyPort, String username, String password)
                throws IOException {
            super(url);
            socket = new Socket();
            this.proxyHost = proxyHost;
            this.proxyPort = proxyPort;
            String encoded = Base64.encode((username + ":" + password).getBytes())
                    .replace("\r\n", "");
            proxyheaders.put("Proxy-Authorization", new ArrayList<>(Arrays.asList("Basic " + encoded)));
        }
    
        @Override
        public OutputStream getOutputStream() throws IOException {
            connect();
            afterWrite();
            return new FilterOutputStream(socket.getOutputStream()) {
                @Override
                public void write(byte[] b, int off, int len) throws IOException {
                    out.write(String.valueOf(len).getBytes());
                    out.write(NEWLINE);
                    out.write(b, off, len);
                    out.write(NEWLINE);
                }
    
                @Override
                public void write(byte[] b) throws IOException {
                    out.write(String.valueOf(b.length).getBytes());
                    out.write(NEWLINE);
                    out.write(b);
                    out.write(NEWLINE);
                }
    
                @Override
                public void write(int b) throws IOException {
                    out.write(String.valueOf(1).getBytes());
                    out.write(NEWLINE);
                    out.write(b);
                    out.write(NEWLINE);
                }
    
                @Override
                public void close() throws IOException {
                    afterWrite();
                }
    
            };
        }
    
        private boolean afterwritten = false;
    
        @Override
        public InputStream getInputStream() throws IOException {
            connect();
            return socket.getInputStream();
    
        }
    
        @Override
        public void setRequestMethod(String method) throws ProtocolException {
            this.method = method;
        }
    
        @Override
        public void setRequestProperty(String key, String value) {
            sendheaders.put(key, new ArrayList<>(Arrays.asList(value)));
        }
    
        @Override
        public void addRequestProperty(String key, String value) {
            sendheaders.computeIfAbsent(key, l -> new ArrayList<>()).add(value);
        }
    
        @Override
        public Map<String, List<String>> getHeaderFields() {
            return headers;
        }
    
        @Override
        public void connect() throws IOException {
            if (connected) {
                return;
            }
            connected = true;
            socket.setSoTimeout(getReadTimeout());
            socket.connect(new InetSocketAddress(proxyHost, proxyPort), getConnectTimeout());
            StringBuilder msg = new StringBuilder();
            msg.append("CONNECT ");
            msg.append(url.getHost());
            msg.append(':');
            msg.append(url.getPort() == -1 ? 443 : url.getPort());
            msg.append(" HTTP/1.0\r\n");
            for (Map.Entry<String, List<String>> header : proxyheaders.entrySet()) {
                for (String l : header.getValue()) {
                    msg.append(header.getKey()).append(": ").append(l);
                    msg.append("\r\n");
                }
            }
    
            msg.append("Connection: close\r\n");
            msg.append("\r\n");
            byte[] bytes;
            try {
                bytes = msg.toString().getBytes("ASCII7");
            } catch (UnsupportedEncodingException ignored) {
                bytes = msg.toString().getBytes();
            }
            socket.getOutputStream().write(bytes);
            socket.getOutputStream().flush();
            byte reply[] = new byte[200];
            byte header[] = new byte[200];
            int replyLen = 0;
            int headerLen = 0;
            int newlinesSeen = 0;
            boolean headerDone = false;
            /* Done on first newline */
            InputStream in = socket.getInputStream();
            while (newlinesSeen < 2) {
                int i = in.read();
                if (i < 0) {
                    throw new IOException("Unexpected EOF from remote server");
                }
                if (i == '\n') {
                    if (newlinesSeen != 0) {
                        String h = new String(header, 0, headerLen);
                        String[] split = h.split(": ");
                        if (split.length != 1) {
                            proxyreturnheaders.computeIfAbsent(split[0], l -> new ArrayList<>()).add(split[1]);
                        }
                    }
                    headerDone = true;
                    ++newlinesSeen;
                    headerLen = 0;
                } else if (i != '\r') {
                    newlinesSeen = 0;
                    if (!headerDone && replyLen < reply.length) {
                        reply[replyLen++] = (byte) i;
                    } else if (headerLen < reply.length) {
                        header[headerLen++] = (byte) i;
                    }
                }
            }
    
            String replyStr;
            try {
                replyStr = new String(reply, 0, replyLen, "ASCII7");
            } catch (UnsupportedEncodingException ignored) {
                replyStr = new String(reply, 0, replyLen);
            }
    
            // Some proxies return http/1.1, some http/1.0 even we asked for 1.0
            if (!replyStr.startsWith("HTTP/1.0 200") && !replyStr.startsWith("HTTP/1.1 200")) {
                throw new IOException("Unable to tunnel. Proxy returns \"" + replyStr + "\"");
            }
    
            SSLContext context = null;
            try {
                context = SSLContext.getInstance("SSL");
                context.init(null,
                        new TrustManager[] { new TrustAnyTrustManager() },
                        new SecureRandom());
            } catch (KeyManagementException e) {
                e.printStackTrace();
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            }
            SSLSocketFactory factory = context.getSocketFactory();
            SSLSocket s = (SSLSocket) factory
                    .createSocket(socket, url.getHost(), url.getPort(), true);
            s.startHandshake();
            socket = s;
            msg.setLength(0);
            msg.append(method);
            msg.append(" ");
           // msg.append(url.toExternalForm().split(String.valueOf(url.getPort()), -2)[1]);
            msg.append(url.toExternalForm().split(String.valueOf(url.getPort()), -2)[0]);
            msg.append(" HTTP/1.0\r\n");
            for (Map.Entry<String, List<String>> h : sendheaders.entrySet()) {
                for (String l : h.getValue()) {
                    msg.append(h.getKey()).append(": ").append(l);
                    msg.append("\r\n");
                }
            }
            if (method.equals("POST") || method.equals("PUT")) {
                msg.append("Transfer-Encoding: Chunked\r\n");
            }
            msg.append("Host: ").append(url.getHost()).append("\r\n");
            msg.append("Connection: close\r\n");
            msg.append("\r\n");
            try {
                bytes = msg.toString().getBytes("ASCII7");
            } catch (UnsupportedEncodingException ignored) {
                bytes = msg.toString().getBytes();
            }
            socket.getOutputStream().write(bytes);
            socket.getOutputStream().flush();
        }
    
        private void afterWrite() throws IOException {
            if (afterwritten) {
                return;
            }
            afterwritten = true;
            socket.getOutputStream().write(String.valueOf(0).getBytes());
            socket.getOutputStream().write(NEWLINE);
            socket.getOutputStream().write(NEWLINE);
            byte reply[] = new byte[200];
            byte header[] = new byte[200];
            int replyLen = 0;
            int headerLen = 0;
            int newlinesSeen = 0;
            boolean headerDone = false;
            /* Done on first newline */
            InputStream in = socket.getInputStream();
            while (newlinesSeen < 2) {
                int i = in.read();
                if (i < 0) {
                    throw new IOException("Unexpected EOF from remote server");
                }
                if (i == '\n') {
                    if (headerDone) {
                        String h = new String(header, 0, headerLen);
                        String[] split = h.split(": ");
                        if (split.length != 1) {
                            headers.computeIfAbsent(split[0], l -> new ArrayList<>()).add(split[1]);
                        }
                    }
                    headerDone = true;
                    ++newlinesSeen;
                    headerLen = 0;
                } else if (i != '\r') {
                    newlinesSeen = 0;
                    if (!headerDone && replyLen < reply.length) {
                        reply[replyLen++] = (byte) i;
                    } else if (headerLen < header.length) {
                        header[headerLen++] = (byte) i;
                    }
                }
            }
    
            String replyStr;
            try {
                replyStr = new String(reply, 0, replyLen, "ASCII7");
            } catch (UnsupportedEncodingException ignored) {
                replyStr = new String(reply, 0, replyLen);
            }
    
            /* We asked for HTTP/1.0, so we should get that back */
            if ((!replyStr.startsWith("HTTP/1.0 200")) && !replyStr.startsWith("HTTP/1.1 200")) {
                throw new IOException("Server returns \"" + replyStr + "\"");
            }
        }
    
        @Override
        public void disconnect() {
            try {
                socket.close();
            } catch (IOException ex) {
                Logger.getLogger(ProxiedHttpsConnection.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    
        @Override
        public boolean usingProxy() {
            return true;
        }
    
    
        private static class TrustAnyTrustManager implements X509TrustManager {
    
            public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
            }
    
            public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
            }
    
            public X509Certificate[] getAcceptedIssuers() {
                return new X509Certificate[] {};
            }
        }
    
        public static void main(String[] args) throws Exception {
            ProxiedHttpsConnection n = new ProxiedHttpsConnection(
                    new URL("https://fpcy.dlntax.gov.cn/WebQuery/yzmQuery?callback=jQuery110209213418538287719_1559285746349&fpdm=2102184130&fphm=02670770&r=0.00982363574892764&v=V1.0.07_001&nowtime=1559800014984&area=2102&publickey=4D40DF1E0BDE8E4E23B1ADDAB06FB2A4&_=1559285746355"),
                    "39.106.71.9", 3762, "proxytest", "tyy2019");
            n.setRequestMethod("GET");
            n.addRequestProperty("User-Agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
            //try (OutputStream out = n.getOutputStream()) {
            //  out.write("Hello?".getBytes());
            //}
            try (InputStream in = n.getInputStream()) {
                byte[] buff = new byte[1024];
                int length;
                while ((length = in.read(buff)) >= 0) {
                    System.out.write(buff, 0, length);
                }
            }
        }
    }

如有问题，请私信。

tL+8vMr1vbvB96Osx+vO8NPD09q3x7eo08PNvqGjDQoNCsTmz/LP4LnYv86zzKGiSlOyubu3vrO/zrPMoaJKQVZBz+C52L/Os8zI59Do0qrSsr/J0tTBqs+1UVGhow0KDQrX99XfIFFRIDQwNDU0MDIyOQ==