https通信实现方式

最新推荐文章于 2024-09-26 06:55:10 发布
最新推荐文章于 2024-09-26 06:55:10 发布
阅读量1.5k 收藏 4
点赞数
分类专栏： JAVA 项目中用到的
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cpp1781089410/article/details/81319558
版权

1. 不使用证书

1.1 客户端

1.1.1 该方式不校验证书和域名，与普通的访问http无明显差别

public void testPlainHttps() {
		URL reqURL;
		try {
			reqURL = new URL("https://www.oracle.com/sun/index.html");
			// 创建URL对象
			HttpsURLConnection httpsConn = (HttpsURLConnection) reqURL.openConnection();
 
			/*
			 * 下面这段代码实现向Web页面发送数据，实现与网页的交互访问 httpsConn.setDoOutput(true);
			 * OutputStreamWriter out = new
			 * OutputStreamWriter(huc.getOutputStream(), "8859_1"); 
			 * out.write("……" ); 
			 * out.flush(); 
			 * out.close();
			 */
 
			// 取得该连接的输入流，以读取响应内容
			InputStreamReader insr = new InputStreamReader(httpsConn.getInputStream());
			// 读取服务器的响应内容并显示
			int respInt = insr.read();
			while (respInt != -1) {
				System.out.print((char) respInt);
				respInt = insr.read();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

1.1.2 忽略证书和域名校验，实现方式是构造一个信任证书管理器（不做校验）

public String sendBankServer(String postData, String reqUrl) throws Exception {
        LOGGER.info("\n请求银行URL：" + reqUrl + "\n发送银行内容：" + postData);
        CloseableHttpClient httpClient = getIgnoredCertHttpClient();
        StringEntity stringEntity = new StringEntity(postData, "GBK");
        stringEntity.setContentEncoding("GBK");
        stringEntity.setContentType("text/xml; charset=GBK");
 
        HttpPost httpPost = new HttpPost(reqUrl);
        httpPost.setHeader("Content-Type", "text/xml; charset=GBK");
        httpPost.setHeader("Host", BANK_HOST);
        httpPost.setEntity(stringEntity);
 
        String responseBody = "";
        try {
            // 执行请求操作，并拿到结果（同步阻塞）
            CloseableHttpResponse response = httpClient.execute(httpPost);
            // 获取结果实体
            HttpEntity httpEntity = response.getEntity();
            if (httpEntity != null) {
                // 按指定编码转换结果实体为String类型
                responseBody = EntityUtils.toString(httpEntity, "GBK");
            }
            
            // 释放httpEntity占用的所有资源,实质是释放底层的流并将连接归还连接池
            EntityUtils.consume(httpEntity);
            // 释放链接
            response.close();
        } finally {
            httpClient.close();
        }
        LOGGER.info("收到银行回复：" + responseBody);
        return responseBody;
    }
 
    public CloseableHttpClient getIgnoredCertHttpClient() throws KeyManagementException, NoSuchAlgorithmException {
        // 实现一个X509TrustManager接口，信任证书用于绕过验证，不用修改里面的方法
        X509TrustManager trustManager = new X509TrustManager() {
            @Override
            public void checkClientTrusted(java.security.cert.X509Certificate[] paramArrayOfX509Certificate, String paramString) throws CertificateException {}
 
            @Override
            public void checkServerTrusted(java.security.cert.X509Certificate[] paramArrayOfX509Certificate, String paramString) throws CertificateException {}
 
            @Override
            public java.security.cert.X509Certificate[] getAcceptedIssuers() {
                return null;
            }
        };
 
        SSLContext sslContext = SSLContext.getInstance("SSLv3");
 
        // 采用绕过验证的方式处理https请求
        sslContext.init(null, new TrustManager[] { trustManager }, null);
 
        // 设置协议http和https对应的处理socket链接工厂的对象
        Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory> create()
                .register("http", PlainConnectionSocketFactory.INSTANCE)
                // 不校验主机名
                .register("https", new SSLConnectionSocketFactory(sslContext, new AllowAllHostnameVerifier()))
                .build();
 
        //创建http连接池管理器
        PoolingHttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
        // 请求参数设置
        RequestConfig requestConfig = RequestConfig.custom()
                // 从连接池中获取连接的超时时间
                .setConnectionRequestTimeout(MAX_TIMEOUT)
                // 与服务器连接超时时间：httpclient会创建一个异步线程用以创建socket连接，此处设置该socket的连接超时时间
                .setConnectTimeout(MAX_TIMEOUT)
                // socket读取数据时阻塞链路的超时时间,即从服务器获取响应数据的超时时间
                .setSocketTimeout(MAX_TIMEOUT)
                // 在提交请求之前测试连接是否可用The stale connection check can cause up to 30 millisecond overhead per request 
                //.setStaleConnectionCheckEnabled(true)
                // 不做认证
                .setAuthenticationEnabled(false)
                .build();
        // 创建自定义的httpclient对象
        CloseableHttpClient httpClient = HttpClients.custom().setConnectionManager(connManager)
                .setDefaultRequestConfig(requestConfig)
                .build();
 
        return httpClient;
    }

1.1.3 忽略证书和域名校验

package com.eplusing.communication;
 
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.URL;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
 
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.KeyManager;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
 
import org.junit.Test;
 
public class HttpsUtil {
	public static void main(String[] args) throws IOException {
		String uri = "https://f.hiphotos.baidu.com/image/pic/item/960a304e251f95cacc952852c5177f3e660952f5.jpg";
		byte[] bytes = HttpsUtil.doGet(uri);
		FileOutputStream fos = new FileOutputStream("file/金丝皇菊.jpg");
		fos.write(bytes);
		fos.close();
		System.out.println("done!");
	}
 
	private static final class DefaultTrustManager implements X509TrustManager {
		@Override
		public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
		}
 
		@Override
		public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
		}
 
		@Override
		public X509Certificate[] getAcceptedIssuers() {
			return null;
		}
	}
 
	private static HttpsURLConnection getHttpsURLConnection(String uri, String method) throws IOException {
		SSLContext ctx = null;
		try {
			ctx = SSLContext.getInstance("TLS");
			ctx.init(new KeyManager[0], new TrustManager[] { new DefaultTrustManager() }, new SecureRandom());
		} catch (KeyManagementException e) {
			e.printStackTrace();
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		}
		SSLSocketFactory ssf = ctx.getSocketFactory();
 
		URL url = new URL(uri);
		HttpsURLConnection httpsConn = (HttpsURLConnection) url.openConnection();
		httpsConn.setSSLSocketFactory(ssf);
		httpsConn.setHostnameVerifier(new HostnameVerifier() {
			@Override
			public boolean verify(String arg0, SSLSession arg1) {
				return true;
			}
		});
		httpsConn.setRequestMethod(method);
		httpsConn.setDoInput(true);
		httpsConn.setDoOutput(true);
		return httpsConn;
	}
	
	private static HttpsURLConnection getHttpsURLConnection2(String uri, String method) {
		//创建SSLContext对象，并使用我们指定的信任管理器初始化
		// 创建URL对象
		HttpsURLConnection httpsConn = null;
		try {
			TrustManager[] tm = {new DefaultTrustManager ()};
			SSLContext sslContext = SSLContext.getInstance("SSL","SunJSSE");
			sslContext.init(null, tm, new java.security.SecureRandom());
 
			//从上述SSLContext对象中得到SSLSocketFactory对象
			SSLSocketFactory ssf = sslContext.getSocketFactory();
 
			//创建HttpsURLConnection对象，并设置其SSLSocketFactory对象
			
			URL reqURL = new URL("https://www.oracle.com/sun/index.html");
			httpsConn = (HttpsURLConnection) reqURL.openConnection();
			
			httpsConn.setSSLSocketFactory(ssf);
			httpsConn.setHostnameVerifier(new HostnameVerifier() {
				@Override
				public boolean verify(String arg0, SSLSession arg1) {
					return true;
				}
			});
			httpsConn.setRequestMethod(method);
			httpsConn.setDoInput(true);
			httpsConn.setDoOutput(true);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return httpsConn;
	}
 
	private static byte[] getBytesFromStream(InputStream is) throws IOException {
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		byte[] kb = new byte[1024];
		int len;
		while ((len = is.read(kb)) != -1) {
			baos.write(kb, 0, len);
		}
		byte[] bytes = baos.toByteArray();
		baos.close();
		is.close();
		return bytes;
	}
 
	private static void setBytesToStream(OutputStream os, byte[] bytes) throws IOException {
		ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
		byte[] kb = new byte[1024];
		int len;
		while ((len = bais.read(kb)) != -1) {
			os.write(kb, 0, len);
		}
		os.flush();
		os.close();
		bais.close();
	}
 
	public static byte[] doGet(String uri) throws IOException {
		HttpsURLConnection httpsConn = getHttpsURLConnection(uri, "GET");
		return getBytesFromStream(httpsConn.getInputStream());
	}
 
	public static byte[] doPost(String uri, String data) throws IOException {
		HttpsURLConnection httpsConn = getHttpsURLConnection(uri, "POST");
		setBytesToStream(httpsConn.getOutputStream(), data.getBytes());
		return getBytesFromStream(httpsConn.getInputStream());
	}
}

1.2 服务端

 

2. 使用证书

public  CloseableHttpClient getHttpClient(String certFilePath,String keyStoryPwd) {
        FileInputStream instream = null;
        CloseableHttpClient httpclient = null;
        try {
            // 指定读取证书格式为PKCS12
            KeyStore keyStore = KeyStore.getInstance("PKCS12");
            // 读取本机存放的PKCS12证书文件
            instream = new FileInputStream(new File(certFilePath));
            // 指定PKCS12的密码(商户ID)
            keyStore.load(instream, keyStoryPwd.toCharArray());
 
            SSLContext sslcontext = SSLContexts.custom().loadKeyMaterial(keyStore, keyStoryPwd.toCharArray()).build();
            // 指定TLS版本
            SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslcontext,new String[] { "TLSv1" },null,
                    SSLConnectionSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER);
            // 设置httpclient的SSLSocketFactory
            httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
        } catch (KeyStoreException e) {
            LOGGER.error("私钥文件异常", e);
        } catch (FileNotFoundException e) {
            LOGGER.error("证书文件未找到", e);
        }catch (NoSuchAlgorithmException e) {
            LOGGER.error("算法异常", e);
        } catch (CertificateException e) {
            LOGGER.error("证书异常", e);
        } catch (IOException e) {
            LOGGER.error("读取证书文件异常", e);
        } catch (KeyManagementException e) {
            LOGGER.error("KeyManagementException异常", e);
        } catch (UnrecoverableKeyException e) {
            LOGGER.error("UnrecoverableKeyException异常", e);
        }finally{
            if(instream !=null){
                try {
                    instream.close();
                } catch (IOException e) {
                    LOGGER.error("inputStream close IOException:" + e.getMessage());
                }
            }
        }
        return httpclient;
    }
    
    protected String postRequest(String urlAddr, String reqXml) throws Exception {
 
        String responseXML = null;
        //import httpclient-4.3.6.jar
        CloseableHttpResponse response = null;
        String keyStoryPwd = "证书密钥";
        String certFilePath = "证书地址";
        
        CloseableHttpClient httpclient =  getHttpClient(certFilePath,keyStoryPwd);
 
        try {
            HttpPost httppost = new HttpPost(urlAddr);
            
            StringEntity pentity = new StringEntity(reqXml, Charset.forName("UTF-8"));
            pentity.setContentEncoding("UTF-8");
            pentity.setContentType("text/xml");
            httppost.setEntity(pentity);
 
            response = httpclient.execute(httppost);
            
            HttpEntity entity = response.getEntity();
            if (entity != null) {
                //import httpcore-4.3.3.jar EntityUtils
                byte[] buff = EntityUtils.toByteArray(entity);
                responseXML = new String(buff, "UTF-8");
            }
 
            LOGGER.info("receive:" + responseXML);
            return responseXML;
 
        } catch (IOException e) {
            LOGGER.error("读返回信息失败" + e.getMessage());
            
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                LOGGER.error("response close IOException:" + e.getMessage());
            }
            try {
                httpclient.close();
            } catch (IOException e) {
                LOGGER.error("httpclient close IOException:" + e.getMessage());
            }
        }
        return null;
    }

 

eplusing
关注
专栏目录
python实现HTTPS通信
tigerOrtiger的博客
06-07 1万+
python实现HTTPS通信 0x01 前言 之前有一个需要实现基于https通信的连接链路的工具，当时感觉很简单，以为https应该和实现http一样的简单，没想到最后想了好些时间，都没能实现出来，然后看了看网上的一些案例，五花八门，于是就在官方文档看到了ssl模块的使用，但是按照文档也没有实现，*_*! 最后根据https的一些资料和ssl 认证的方式，理清思路，实现了工具。 因此想记录一下，加深对https通信的理解，这里使用的是python。 0x02 HTTPS简述 HTTPS是一种通过
简述HTTPS的通信机制
willemwei023的博客
06-23 582
HTTPS是什么？ HTTPS = HTTP + 加密 + 认证 + 完整性保护。简单点说HTTPS可以看做是对HTTP的一个扩展，在HTTP的基础上添加了一些其他的东西。加密、认证和完整性保护，添加这么些东西就很明显是为了保证数据的安全性。 HTTP的不足： 通信使用明文（未加密），内容可能会被窃听 没有验证通信方的身份，可能遭遇伪装 无法证明报文的完整性，可能会被篡改 HTTPS的作用便是为了解决上述问题。HTTPS并不是一个新的协议，只是HTTP披了一层SSL或TLS的马甲。在四层模型中，HTT
浅析HTTPS的通信机制
万猫学社
03-06 2739
什么是HTTPS? HTTPS 是在HTTP（Hyper Text Transfer Protocol）的基础上加入SSL（Secure Sockets Layer），在HTTP的基础上通过传输加密和身份认证保证了传输过程的安全性 。依此避免HTTP的明文传输容易被窃听、不验证身份容易被伪装、无法验证报文完整性容易被篡改等问题。除了被广泛用于互联网上安全敏感的通讯，大部分网站也正在广泛采用 。 HTTPS的通信机制 HTTPS不仅仅是把http://换成https://看上去那么简单，HTTPS的通信机制要
万字图文详解HTTPS协议通信过程，结合抓包实战解析带你一次看透HTTPS！
最新发布
所有成功的背后，都是痛苦的坚持，所有的痛苦，都是傻瓜般的不放弃!
09-26 3063
HTTPS 被称为 HTTP Over SSL (基于SSL加密的HTTP)，这里的SSL (Secure Socket Layer) 被称为安全套接层，它是一种加密协议，不仅可应用于HTTP协议、还可应用于POP3协议、SMTP协议、VPN等。TLS (Transport Layer Security) 被称为传输层安全，TLS相对于SSL 3.0版本做了些修改和功能增强，相当于SSL的升级版本，所以有时也一起统称为 SSL，接入来本文若不明显强调，SSL就默认表示SSL/TLS。我们可以用公式。
https通信(HTTP+SSL)
weixin_42847086的博客
07-25 4258
1、https介绍 1.1 https是什么？ https不是一种新的协议，它是http+SSL(TLS)的结合体，SSL是一种独立协议，所有其它协议比如smtp等也可以跟ssl结合。https改变了通信方式，它由以前的http—–>tcp，改为http——>SSL—–>tcp；https采用了共享密钥加密+公开密钥加密的方式。 1.2 为什么使用？ 1.2.1 http通信存在...
HTTPS 通信原理简述
g270382086的博客
02-08 217
数字证书，解决公钥传输信任问题 如何解决公钥传输问题呢，从现实生活中的场景找答案，员工入职时，企业一般会要求提供学历证明，显然不是什么阿猫阿狗的本本都可称为学历，这个学历必须由第三方权威机构（Certificate Authority，简称 CA）即教育部颁发，同理，server 也可以向 CA 申请证书，在证书中附上公钥，然后将证书传给 client，证书由站点管理者向 CA 申请，申请的时候会提交 DNS 主机名等信息，CA 会根据这些信息生成证书 这样当 client 拿到证书后，就可以获得证书上的
Https通信原理
u012545728的博客
06-02 3600
简介：HTTP 协议（HyperText Transfer Protocol，超文本传输协议）：是客户端浏览器或其他程序与Web服务器之间的应用层通信协议 。HTTPS（全称：HyperText Transfer Protocol over Secure Socket Layer），可以理解为HTTP+SSL/TLS， 即 HTTP 下加入 SSL 层，HTTPS 的安全基础是 SSL，因此加密的...
实现Python与STM32通信方式
01-20
断断续续学了几周Stm32后,突然想实现上位机和下位机的通信,恰好自己学过一点python,便想通过python实现通信. 在网上看见python库pyserial可以实现此功能,便去官网找了一下 ,附上官网pyserial档链 接:...
LabVIEW实现Modbus通信：VISA串口实现
05-06
Modbus只是工业控制中常用的一种协议方式，本项目通过串口通信的方式实现基本的Mosbus操作。 VISA串口方式实现Modbus协议，本质上就是自己手写协议帧，每一类帧格式都需要自己来编写。 项目可直接运行~
DH-基于socket通信的javaDH通信实现 .rar
07-09
DH算法，全称为Diffie-Hellman密钥交换协议，是一种在不安全的网络环境中安全交换密钥的协议。在Java编程中，DH算法常被用于...这种实现方式对于开发安全的网络应用，如HTTPS、安全聊天软件等，具有重要的实践价值。
HTTPS通信的C++实现
weixin_34319817的博客
10-29 2843
为什么80%的码农都做不了架构师？>>> ...
ssl证书详解及HTTPS通讯方式
mastergu2的博客
05-23 353
SSL证书原理讲解 一直以来都对数字证书的签发，以及信任等事情一知半解。总算有个闲适的周末来总结和深入一下相关的知识。 CA: CA(Certificate Authority)是证书的签发机构，它是负责管理和签发证书的第三方机构，是受到广泛信任的机构。一般在我们的电脑中，浏览器里，或者手机里都会内置一批这样的受信机构的根证书。 证书信任链： 比如我是CA机构我签发了一封证书 我这份证书是信任B证书的另外B证书又信任了其他的C证书…那么这条链条下去的都可以信任。所以一旦CA机构的根证书不可信了，那么所有由他
Https的加密机制
qq_43489474的博客
08-31 272
Https的加密机制 1：对称加密 对称加密就是有一个密钥，他可以对一段内容进行加密，加密后只能用它才能解密看到内容 ​ 使用对称加密可行吗？ 如果通信双方各持有同一个密钥，且没有别人知道，这两方的通信安全当然可以是被保证的。 那么最大的问题是这个密钥怎么传输只让双方知晓，同时不被别人知道。如果浏览器生成一个密钥并传送给浏览器，这个传输过程种密钥被别人劫持到手了怎么办？之后他就可以用密钥解开双方传输的任何内容了，这样当然是不行的。 2：非对称加密 有两把密钥，一把公钥，一把私钥，用公钥加密的内容必须用
Https通信原理解析
TankyZhang的博客
03-14 809
Https原理解析 Https简单介绍 ​ 众所周知，https就是http的升级版协议，他比http更加安全，但它是如何实现安全机制的呢？其实剖开去看无非就是https在传输过程中把数据加密了，http在传输过程中不进行加密，直接就是以明文转为二进制流的形式在网络上进行传播，但是https则是传输之前将数据进行一次加密，在读取数据的时候进行解密。 加密方式介绍 ​ 那么上边我们提到了加密解密，我们就要考虑的是如何进行加解密？如果区分常见的加密方式就是对称加密和非对称加密。 对称加密：加密和解密的双方使用
Https交互流程《转》
刨根问底，挖到祖坟
02-24 227
最经看了一些关于https的东西，比较乱，现在做个总结（不一定正确，而且很多细节没挖掘，只是目前的一个粗浅认识） Https流程图 从这个图我们可以看出： 由于浏览器和服务器之间对数据传输进行了对称加密，从而保证了数据的安全性，但是现在有一个问题，如何保证浏览器生成的随机数（对称加密的密钥）能安全的传递给服务器端？ 如果这把密钥被第三方窃取，那么浏览器和服务器之间传递的数据就能被轻而易举的解密...
前后端通信与 http/https 协议
weixin_49809163的博客
06-21 1218
HTTP 协议前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np impo
基于Https post get方式通讯协议数据访问接口
am的博客
08-02 174
/** * 基于Https post 方式通讯协议数据访问接口 * @param ipAddress ip地址 * @param visitUrl 通讯接口地址 * @param userName 用户账号 * @param passWord 用户密码 * @return */ public static Map<String,Object> doPost(String ipAddress,String visitUrl,S...
一篇文章让您了解HTTPS
qq_34874784的博客
11-04 1876
前段时间在做HTTPS相关的需求碰到了一些问题，今天有空整理一下HTTPS的相关知识，希望对您能有所帮助。 HTTPS 什么是HTTPS HTTPS，即HTTP Security，是建立在SSL / TSL协议之上，其中，TSL是SSL协议的升级版，TLS 1.0通常被标示为SSL 3.1，TLS 1.1为SSL 3.2，TLS 1.2为SSL 3.3，可以理解为同一套协议。他的作用主要以下三点： 防止窃听。 所有信息都是加密传播，第三方无法窃听。 防止篡改。具有校验机制，一.
Netty实现SSL双向验证完整实例
热门推荐
moonpure的专栏
09-27 1万+
一、证书准备      要使用ssl双向验证，就必须先要生成服务端和客户端的证书，并相互添加信任，具体流程如下(本人调试这个用例的时候，花了很多时间来验证证书是否正确，以及握手失败的原因，这里证书生成过程只要按流程走，本人能保证绝对没有问题) 现在打开cmd，在哪个目录下打开，证书就会放在哪个目录下： 第一步:   生成Netty服务端私钥和证书仓库命令  keytool -genkey ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值