Java 访问 Https接口 忽略证书
/**  
 * 证书信任管理器(用于https请求)  
 * @date 2013-08-08  
 */  
public class MyX509TrustManager implements X509TrustManager{  
    public void checkClientTrusted(X509Certificate[] arg0, String arg1)  
            throws CertificateException {  
    }  
    public void checkServerTrusted(X509Certificate[] arg0, String arg1)  
            throws CertificateException {  
    }  
    public X509Certificate[] getAcceptedIssuers() {  
        return null;  
    }  
    public static JSONObject httpRequest(String requestUrl, String requestMethod, String outputStr) {    
        JSONObject jsonObject = null;    
        StringBuffer buffer = new StringBuffer();    
        try {    
            // 创建SSLContext对象,并使用我们指定的信任管理器初始化    
            TrustManager[] tm = { new MyX509TrustManager() };    
            SSLContext sslContext = SSLContext.getInstance("SSL", "SunJSSE");    
            sslContext.init(null, tm, new java.security.SecureRandom());    
            // 从上述SSLContext对象中得到SSLSocketFactory对象    
            SSLSocketFactory ssf = sslContext.getSocketFactory();    

            URL url = new URL(requestUrl);    
            HttpsURLConnection httpUrlConn = (HttpsURLConnection) url.openConnection();    
            httpUrlConn.setSSLSocketFactory(ssf);    

            httpUrlConn.setDoOutput(true);    
            httpUrlConn.setDoInput(true);    
            httpUrlConn.setUseCaches(false);    
            // 设置请求方式(GET/POST)    
            httpUrlConn.setRequestMethod(requestMethod);    

            if ("GET".equalsIgnoreCase(requestMethod))  {  

             httpUrlConn.connect();    
            }  

            // 当有数据需要提交时    
            if (null != outputStr) {    
                OutputStream outputStream = httpUrlConn.getOutputStream();    
                // 注意编码格式,防止中文乱码    
                outputStream.write(outputStr.getBytes("UTF-8"));    
                outputStream.close();    
            }    

            // 将返回的输入流转换成字符串    
            InputStream inputStream = httpUrlConn.getInputStream();    
            InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "utf-8");    
            BufferedReader bufferedReader = new BufferedReader(inputStreamReader);    

            String str = null;    
            while ((str = bufferedReader.readLine()) != null) {    
                buffer.append(str);    
            }    
            bufferedReader.close();    
            inputStreamReader.close();    
            // 释放资源    
            inputStream.close();    
            inputStream = null;    
            httpUrlConn.disconnect();    
            jsonObject = JSONObject.parseObject(buffer.toString());    
        } catch (ConnectException ce) {    
         ce.printStackTrace();  
           // log.error("Weixin server connection timed out.");    
        } catch (Exception e) {    
            //log.error("https request error:{}", e);   
         e.printStackTrace();  
        }    
        return jsonObject;    
    }  
    public static void main(String[] args) {
        System.err.println(httpRequest("https://moni.byxgj.com:23134", "GET", null));
        ///createaccount?requestid=1&sa=sa07&sapass=c33&account=0&password=123456&name=张三&group=交易组1&mainaccount=21
    }
}  
 javax.net.ssl.SSLHandshakeException: java.security.cert.CertificateException: No name matching moni.byxgj.com found
    at sun.security.ssl.Alerts.getSSLException(Unknown Source)
    at sun.security.ssl.SSLSocketImpl.fatal(Unknown Source)
    at sun.security.ssl.Handshaker.fatalSE(Unknown Source)
    at sun.security.ssl.Handshaker.fatalSE(Unknown Source)
    at sun.security.ssl.ClientHandshaker.serverCertificate(Unknown Source)
    at sun.security.ssl.ClientHandshaker.processMessage(Unknown Source)
    at sun.security.ssl.Handshaker.processLoop(Unknown Source)
    at sun.security.ssl.Handshaker.process_record(Unknown Source)
    at sun.security.ssl.SSLSocketImpl.readRecord(Unknown Source)
    at sun.security.ssl.SSLSocketImpl.performInitialHandshake(Unknown Source)
    at sun.security.ssl.SSLSocketImpl.startHandshake(Unknown Source)
    at sun.security.ssl.SSLSocketImpl.startHandshake(Unknown Source)
    at sun.net.www.protocol.https.HttpsClient.afterConnect(Unknown Source)
    at sun.net.www.protocol.https.AbstractDelegateHttpsURLConnection.connect(Unknown Source)
    at sun.net.www.protocol.https.HttpsURLConnectionImpl.connect(Unknown Source)
    at com.wlq.test.MyX509TrustManager.httpRequest(MyX509TrustManager.java:57)
    at com.wlq.test.MyX509TrustManager.main(MyX509TrustManager.java:94)

请问这个错怎么整?网上的方法全部测试过来了

 httpClient方法 报
 javax.net.ssl.SSLPeerUnverifiedException: peer not authenticated

ps:如果有直接可用demo,求分享

0

2个回答

0
wlq199101
wlq199101 报了一样的错,不过还是很感谢
接近 2 年之前 回复
package my;

import java.io.BufferedReader;

import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;

import java.io.IOException;

import java.io.InputStream;
import java.io.InputStreamReader;

import java.io.OutputStream;
import java.net.MalformedURLException;

import java.net.URL;

import java.net.URLDecoder;
import java.security.GeneralSecurityException;

import java.security.KeyStore;

import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import javax.net.ssl.HostnameVerifier;

import javax.net.ssl.HttpsURLConnection;

import javax.net.ssl.KeyManagerFactory;

import javax.net.ssl.SSLContext;

import javax.net.ssl.TrustManagerFactory;

public class HttpsPost {

private static HttpsURLConnection urlCon = null;
/**
* 获得KeyStore.
* @param keyStorePath
* 密钥库路径
* @param password
* 密码
* @return 密钥库
* @throws Exception
*/

public static KeyStore getKeyStore(String password, String keyStorePath)

throws Exception {

// 实例化密钥库

KeyStore ks = KeyStore.getInstance("JKS");

// 获得密钥库文件流

FileInputStream is = new FileInputStream(keyStorePath);

// 加载密钥库

ks.load(is, password.toCharArray());

// 关闭密钥库文件流

is.close();

return ks;

}

/** 
 * 获得SSLSocketFactory. 
 * @param password 
 *            密码 
 * @param keyStorePath 
 *            密钥库路径 
 * @param trustStorePath 
 *            信任库路径 
 * @return SSLSocketFactory 
 * @throws Exception 
 */  
public static SSLContext getSSLContext(String password,  
        String keyStorePath, String trustStorePath) throws Exception {  
    // 实例化密钥库  
    KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());  
    // 获得密钥库  
    KeyStore keyStore = getKeyStore(password, keyStorePath);  
    // 初始化密钥工厂  
    keyManagerFactory.init(keyStore, password.toCharArray());  

    // 实例化信任库  
    TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());  
    // 获得信任库  
    KeyStore trustStore = getKeyStore(password, trustStorePath);  
    // 初始化信任库  
    trustManagerFactory.init(trustStore);  
    // 实例化SSL上下文  
    SSLContext ctx = SSLContext.getInstance("TLS");  
    // 初始化SSL上下文  
    ctx.init(keyManagerFactory.getKeyManagers(),  
            trustManagerFactory.getTrustManagers(), null);  
    // 获得SSLSocketFactory  
    return ctx;  
}  

/** 
 * 初始化HttpsURLConnection. 
 * @param password 
 *            密码 
 * @param keyStorePath 
 *            密钥库路径 
 * @param trustStorePath 
 *            信任库路径 
 * @throws Exception 
 */  
public static void initHttpsURLConnection(String password,  
        String keyStorePath, String trustStorePath) throws Exception {  
    // 声明SSL上下文  
    SSLContext sslContext = null;  
    // 实例化主机名验证接口  
    HostnameVerifier hnv = new MyHostnameVerifier();  
    try {  
        sslContext = getSSLContext(password, keyStorePath, trustStorePath);  
    } catch (GeneralSecurityException e) {  
        e.printStackTrace();  
    }  
    if (sslContext != null) {  
        HttpsURLConnection.setDefaultSSLSocketFactory(sslContext  
                .getSocketFactory());  
    }  
    HttpsURLConnection.setDefaultHostnameVerifier(hnv);  
}  

/** 
 * 发送请求. 
 * @param httpsUrl 
 *            请求的地址 
 * @param xmlStr 
 *            请求的数据 
 */  
public static String postLogin(String httpsUrl,Map<String, Object> map) {  
    String sessionId = "";  
    String cookieVal = "";  
    String key = null; 
    OutputStream out = null;
    try {  
        urlCon = (HttpsURLConnection) (new URL(httpsUrl)).openConnection();  
        urlCon.setDoInput(true);  
        urlCon.setDoOutput(true);  
        urlCon.setReadTimeout(500000);
        urlCon.setConnectTimeout(500000);
        urlCon.setRequestProperty("Connection", "Keep-Alive");  
        urlCon.setRequestMethod("POST");  
        urlCon.setUseCaches(false);  
        // POST请求 
        String params = "";
        out = urlCon.getOutputStream();
        if (map != null && map.size() >= 1) {
            Iterator<Entry<String, Object>> it = map.entrySet().iterator();
            while (it.hasNext()) {
                Map.Entry<String, Object> entry = (Entry<String, Object>) it.next();
                params += entry.getKey() + "=" + entry.getValue() + "&";
            }
        }
        out.write(params.getBytes());
        out.flush();
        out.close();

        for(int i = 1; (key = urlCon.getHeaderFieldKey(i)) != null; i++){  
            if(key.equalsIgnoreCase("set-cookie")){  
                cookieVal = urlCon.getHeaderField(i);  
                cookieVal = cookieVal.substring(0, cookieVal.indexOf(";"));  
                sessionId = sessionId + cookieVal + ";";  
            }  
        }  
        // 读取响应 
        BufferedReader reader = new BufferedReader(new InputStreamReader(urlCon.getInputStream()));
        String lines;
        StringBuffer sb = new StringBuffer("");
        while ((lines = reader.readLine()) != null) {
            lines = URLDecoder.decode(lines, "utf-8");
            sb.append(lines);
        }
        System.out.println(sb);
        reader.close();
        // 断开连接 
        urlCon.disconnect(); 
    } catch (MalformedURLException e) {  
        e.printStackTrace();  
    } catch (IOException e) {  
        e.printStackTrace();  
    } catch (Exception e) {  
        e.printStackTrace();  
    }
    return sessionId;
}  

/**
 * 验证证书并登录
 * @throws Exception 
 * 
 */
public static String initAndLogin(String httpsUrl, Map<String, Object> map)
        throws Exception {
    String keyStorePWD ="password";
    String string = HttpsPost.class.getResource("/").toString();
    String replace = string.replace("file:/", "");
    String keyStorePath ="密钥库路径";
    String trustStorePath ="信任库路径";
    //证书验证
    HttpsPost.initHttpsURLConnection(keyStorePWD, keyStorePath, trustStorePath);
    //发送登录请求
    return  postLogin(httpsUrl, map);
}


    /**
     * 通过拼接的方式构造请求内容,实现参数传输以及文件传输
     * @param actionUrl 访问的服务器URL
     * @param params 普通参数
     * @param files 文件参数
     * @return
     * @throws IOException
     */
    public static String post(String actionUrl, Map<String, String> params, Map<String, File> files,String cookieVal) throws IOException{

        String BOUNDARY = java.util.UUID.randomUUID().toString();
        String PREFIX = "--", LINEND = "\r\n";
        String MULTIPART_FROM_DATA = "multipart/form-data";
        String CHARSET = "UTF-8";
        URL url = new URL(actionUrl);
        urlCon = (HttpsURLConnection) url.openConnection();  

        urlCon.setReadTimeout(5 * 1000); // 缓存的最长时间
        urlCon.setDoInput(true);// 允许输入
        urlCon.setDoOutput(true);// 允许输出
        urlCon.setUseCaches(false); // 不允许使用缓存
        urlCon.setRequestMethod("POST");
        urlCon.setRequestProperty("Cookie",cookieVal);  
        urlCon.setRequestProperty("connection", "keep-alive");
        urlCon.setRequestProperty("Charsert", "UTF-8");
        urlCon.setRequestProperty("Content-Type", MULTIPART_FROM_DATA + ";boundary=" + BOUNDARY);

        // 首先组拼文本类型的参数
        StringBuilder sb = new StringBuilder();
        for (Map.Entry<String, String> entry : params.entrySet())
        {
            sb.append(PREFIX);
            sb.append(BOUNDARY);
            sb.append(LINEND);
            sb.append("Content-Disposition: form-data; name=\"" + entry.getKey() + "\"" + LINEND);
            sb.append(LINEND);
            sb.append(entry.getValue());
            sb.append(LINEND);
        }
            System.out.println(sb.toString());
        DataOutputStream outStream = new DataOutputStream(urlCon.getOutputStream());
        outStream.write(sb.toString().getBytes());
        InputStream in = null;
        // 发送文件数据
        if (files != null)
        {
            for (Map.Entry<String, File> file : files.entrySet())
            {
                StringBuilder sb1 = new StringBuilder();
                sb1.append(PREFIX);
                sb1.append(BOUNDARY);
                sb1.append(LINEND);
                sb1.append("Content-Disposition: form-data; name=\"" + file.getKey() + "\"; filename=\""  + file.getValue().getName() + "\"" + LINEND);
                sb1.append(LINEND);
                System.out.println(sb1);
                outStream.write(sb1.toString().getBytes());

                InputStream is = new FileInputStream(file.getValue());
                byte[] buffer = new byte[1024];
                int len = 0;
                while ((len = is.read(buffer)) != -1)
                {
                    outStream.write(buffer, 0, len);
                }

                is.close();
                outStream.write(LINEND.getBytes());
            }
            // 请求结束标志
            byte[] end_data = (PREFIX + BOUNDARY + PREFIX + LINEND).getBytes();
            outStream.write(end_data);
            outStream.flush();
            outStream.close();
            urlCon.disconnect();

            // 读取返回数据    
            BufferedReader reader = new BufferedReader(new InputStreamReader(urlCon.getInputStream()));
            String lines;
            StringBuffer ssb = new StringBuffer("");
            while ((lines = reader.readLine()) != null) {
                lines = URLDecoder.decode(lines, "utf-8");
                ssb.append(lines);
            }
            System.out.println(ssb.toString());
            reader.close();
            // 断开连接 
            urlCon.disconnect(); 

            return ssb.toString();
        }
        return null;
    }

    /**
     * 退出
     */
    public static String postLogout(String cookieVal,String httpsUrl) {
        StringBuffer sb = new StringBuffer("");
        OutputStream out = null;
        try {
            urlCon = (HttpsURLConnection) (new URL(httpsUrl)).openConnection();
            urlCon.setDoInput(true);
            urlCon.setDoOutput(true);
            urlCon.setReadTimeout(500000);
            urlCon.setConnectTimeout(500000);
            urlCon.setRequestMethod("POST");
            urlCon.setRequestProperty("Cookie",cookieVal);  
            urlCon.setUseCaches(false);
            // POST请求
            String params = "";
            out = urlCon.getOutputStream();
            out.write(params.getBytes());
            out.flush();
            out.close();

            BufferedReader reader = new BufferedReader(new InputStreamReader(urlCon.getInputStream()));
            String lines;

            while ((lines = reader.readLine()) != null) {
                lines = URLDecoder.decode(lines, "utf-8");
                sb.append(lines);
            }
            System.out.println(sb);
            reader.close();
            // 断开连接
             urlCon.disconnect();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return sb.toString();
    }
    /** 
     * 测试方法. 
     * @param args 
     * @throws Exception 
     */  
    public static void main(String[] args) throws Exception {  
        // 密码  
        String password = "xxxxx";  
        // 密钥库  
        String keyStorePath = "D:\\xxxx.xxxxx";  
        // 信任库  
        String trustStorePath = "D:\\xxxx.xxxx";  
        // 本地起的https服务  
        String httpsUrl = "https://xxxxx:xxx/xxxx/xxxxx";  
        // 传输文本  
    }  

}


package my;

import javax.net.ssl.HostnameVerifier;

import javax.net.ssl.SSLSession;

/**

  • 实现用于主机名验证的基接口。
  • 在握手期间,如果 URL 的主机名和服务器的标识主机名不匹配,则验证机制可以回调此接口的实现程序来确定是否应该允许此连接。 */
    public class MyHostnameVerifier implements HostnameVerifier {
    @Override
    public boolean verify(String hostname, SSLSession session) {
    return true;
    }
    }
0
Csdn user default icon
上传中...
上传图片
插入图片
抄袭、复制答案,以达到刷声望分或其他目的的行为,在CSDN问答是严格禁止的,一经发现立刻封号。是时候展现真正的技术了!
其他相关推荐
java实现https请求绕过证书检测
import org.apache.http.HttpEntity; import org.apache.http.client.config.RequestConfig; import org.apache.http.client.methods.CloseableHttpResponse; import org.apache.http.client.methods.HttpPost; imp...
Java Https请求,跳过证书,直接访问
Java Https请求,跳过证书,直接访问 相关jar包全有 直接下载就能调试
httpClient实例httpClient调用 http/https实例 忽略SSL验证
以上自己测试是可行的,直接拿过去导入即可,直接用main
httpClient4.5.2版本,绕过证书调用https地址
前段时间有个对接需求,提供一个https地址,供第三方调用,但是对方一直报协议错误,并要求我们提供安全证书。然而我们并没有,于是我写了个绕过证书的方法供他们测试使用,这里直接用的post请求,入参是xml(其实入参什么的不重要,最后都要转的)。 httpclient-4.5.2.jar,httpclient-cache-4.5.2.jar,httpcore-4.4.6.jar   前端时...
httpclient发送https的get请求忽略证书
1.首先创建一个HttpsClient类 import java.security.KeyManagementException; import java.security.NoSuchAlgorithmException; import java.security.cert.CertificateException; import java.security.cert.
Java 信任所有SSL证书,HTTPS请求抛错,忽略证书请求完美解决
错误信息: PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target 详细错误信息:   javax.net.ssl.SSLHandshakeExcept...
Cxf跳过Https安全认证
自定义类实现:ClientLifeCycleListener public class SkipSecurityAuthenticationListener implements ClientLifeCycleListener { @Override public void clientCreated(Client client) { if (client.getConduit()...
使用httpClient访问https远程服务器调用远程接口并且传递参数以及忽略SSL证书的问题
使用httpClient访问https远程服务器调用远程接口并且传递参数以及忽略SSL证书的问题 首先写一个httpClient主要调用远程API和参数传递 import com.hxsj.inspection.common.util.SSLClient; import org.apache.http.HttpEntity; import org.apache.http.HttpResponse;...
java发送http和https请求(忽略证书)
通过java发送http请求和https请求(忽略证书)
Java用HttpsURLConnection访问https网站的时候如何跳过SSL证书的验证?
在Java的编程世界里面,我们有的时候,会经常访问一些HTTPS的网站,那么访问这些HTTPS的网站的时候,如果当前这个网站是自己企业内部的已知 的网站,或者我们信任的网站,这个时候,我们为了编写程序的方便,就不需要把当前网站的服务器的根证书已经子证书导入到JKS里面,让在程序在链接的时候对服务器的服务器名和证书名进行对比。说了这么多,那么应该如何做呢?其实也挺简单的,请看下面的Java代码。
https 请求绕过证书认证 Get或Post(证书过期,忽略证书)
javax.net.ssl.SSLHandshakeException: sun.security.validator.ValidatorException: PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certificatio...
创建忽略证书验证的CloseableHttpClient
项目中需要创建忽略证书的http请求,在网上搜索了一下,好多都是大段大段的代码,并且不清不楚的。 。本人阅读java源码,现提供最简洁的创建忽略证书验证的https请求。 /** * 获取忽略证书验证的client * * @return * @throws Exception */ public CloseableHttpClient getIgnoeSSLClient() ...
okHttp3.0直接访问https报错问题,忽略https证书
直接上代码:  //okHttp3添加信任所有证书 public static OkHttpClient getUnsafeOkHttpClient() { try { final TrustManager[] trustAllCerts = new TrustManager[]{ new X509TrustManager() { ...
使用HttpClient4.3.1模拟Http请求与无信任证书访问Https
package com.paic.pmit.core.util; import java.io.IOException; import java.io.UnsupportedEncodingException; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.uti
Java实现免证书访问Https请求
创建证书管理器类 import java.security.cert.CertificateException; import java.security.cert.X509Certificate; import javax.net.ssl.X509TrustManager; /** * 证书信任管理器(用于https请求) * */ public class MyX509Tr...
HTTPS 请求忽略证书验证
参考文章https://blog.csdn.net/shumeng_xiaoyan/article/details/76503601 步骤1,实现自己的x509TrustManager类,并复写三种方法 public class My509TrustManager implements X509TrustManager { @Override public void chec...
Android-工作遭遇-URLConnection原生请求http和https忽略证书
Android网络请求框架非常多,github一搜就是一堆.我的博客就不讲这些,我就讲讲原生已经够用了. HttpURLConnection是Android提供的一个网络请求库,个人认为,还是蛮好用的. HttpsURLConnection是本身就继承自HttpURLConnection的类 首先是忽略证书这一块.有些请求涉及到请求证书.加载证书似乎很麻烦.(不麻烦,我不想加载) 首先需要...
OKHttp3忽略Https证书
public class ComHttpClient { protected OkHttpClient client; public ComHttpClient() { init(); } private static int READ_TIMEOUT = 30000; private static int CONNECT_TIMEOU...
关于https请求,ssl不安全证书
# 忽略https 请求的证书校验 import ssl ssl._create_default_https_context = ssl._create_unverified_context
java实现读取证书访问https接口
java实现读取证书访问https接口java实现读取证书访问https接口
HttpClient详细实例,Httoclient调用https实例,避免https SSL认证
最近公司将原有的http协议接口,更改为了可支持https的双向接口,在查阅资料同时,将解决过程与大家分享。 使用的框架是Struts2,如有变动可自行修改相应代码。 首先,我们看看httpClient是个什么东西,它有什么作用,它能干嘛,它地基本用法? 百度介绍:http://baike.baidu.com/link?url=_gKuBTJc3HqNGmSEoXyVwW0mlUE2
httpclient忽略证书验证允许https请求
public static void enableSSL(DefaultHttpClient httpclient) {     // 调用ssl     try {         SSLContext sslcontext = SSLContext.getInstance("TLS");         sslcontext.init(null, new TrustManager[]{
java https post(不带证书的)
import java.io.*; import java.net.*; import java.security.KeyManagementException; import java.security.NoSuchAlgorithmException; import java.security.cert.CertificateException; import java.securi
OKHttp HTTPS 请求支持所有Https服务器 证书验证忽略客户端证书,(3)
不对客户端证书校验,默认通过所有的验证。import android.content.Context; import java.security.GeneralSecurityException; import java.security.cert.CertificateException; import java.security.cert.X509Certificate;import javax
Java 请求https接口不需要安装证书
Java 请求https接口不需要安装证书,获取到信任的cilent
使用jmeter测试https绕过证书实验
背景:由http转https,采购解析https的板卡,评估性能。使用LR测试时发现不同网段的请求有的网段会被拦截(具体原因还未来得及细查)。随后改用jmeter测试。顺便就研究了一下能否绕过https证书,做了个demo记录一下,备用 示例 一个能用jmeter调用的java请求。添加依赖jar:httpclient相关包、jmeter相关包(ApacheJMeter_core.jar、Ap...
谈谈Retrofit连接https证书问题
谈谈Retrofit连接https证书问题背景最近项目需要用到自定义证书,心里想这可咋办? 当然第一步打开百度 谷歌就一顿猛怼,但是怼了半天之后发现那些文章几乎都是从某一篇复制过去的。都基本是一样的,所以索性按照他们的指引去查阅了相关的API,后来竟然奇迹的发现搞定了!心里很是高兴,所以特来分享。 项目环境 retrofit 1.9 okhttp 2.3 话不多说上代码了 首先需要在资源目录中添加
java httpClient请求时https类型网站遇到ssl证书不受信任
添加创建HTTPClient方法 /** * 创建一个SSL信任所有证书的httpClient对象 * * @return */ public static CloseableHttpClient createSSLClientDefault() { try { SSLContext sslContext =...
忽略git-SSL证书
有的时候我们用 git clone 命令去下载项目的时候 会报这样的错误 git clone https://XXXXX.git Cloning into 'XXXX'... fatal: unable to access 'https://XXXXX.git/': SSL certificate problem: unable to get local issuer certificate...
使用自定义证书并忽略验证的HTTPS连接Post请求方式的封装
使用自定义证书并忽略验证的HTTPS连接Post请求方式的封装 使用自定义证书并忽略验证的HTTPS连接方式 解决证书不被系统承认的方法,就是跳过系统校验。要跳过系统校验,就不能再使用系统标准的SSL SocketFactory了,需要自定义一个。 然后为了在这个自定义SSL SocketFactory里跳过校验,还需要自定义一个TrustManager,在其中忽
关于ios项目绕过证书访问https
听说苹果发布了声明,将于年底将所有iOS应用的http访问强制改为https访问。个人认为这是个好事,启用HTTPS网络连接之后,数据传输的安全性将大幅提示,不容易被黑客拦截破译。 所以得跟上形势不是,这也许就是程序员的无奈,相当一个不过是的好程序员就得不断的学习新的知识。下面就是我用NSURLSession封装好的数据请求类。 说明:请求方法结合了MD5加密,大家看代码的时候注意看NSURLSe
HttpClient配置SSL绕过https证书
HttpClient简介HTTP 协议可能是现在 Internet 上使用得最多、最重要的协议了,越来越多的 Java 应用程序需要直接通过 HTTP 协议来访问网络资源。虽然在 JDK 的 java.net 包中已经提供了访问 HTTP 协议的基本功能,但是对于大部分应用程序来说,JDK 库本身提供的功能还不够丰富和灵活。HttpClient 是 Apache Jakarta Common 下的子
RestTemplete 忽略安全证书
try { restTemplate = new RestTemplate(generateHttpRequestFactory()); } catch (Throwable e) { logger.error(&quot;Processing request failed. Catch T...
HttpClient配置SSL绕过https证书实例
HttpClient配置SSL绕过https证书实例,附件中包含所需httpclient组件jar库。博客地址:http://blog.csdn.net/irokay/article/details/78801307。
设置https请求忽略安全证书
前两天要调用第三方的接口遇到了安全证书的问题,找了各种方法下面贴一下自己汇总的解决办法: 第一个写法(这个写法是最简单的,亲测有效,但是这个写法用到了jdk1.8的lambda表达式,1.8之前的版本就不支持): private static CloseableHttpClient httpClient; //jdk1.8用此代码 static { try { ...
camel 配置 https访问配置
https 认证分为单向认证(一般指的是客户端认证服务器)和双向认证(除了客户端要认证服务器外,服务器也要认证客户端)。 单向认证 当访问单向认证的时候,主要看服务器的证书是否经过CA认证,如果通过ca认证,我们的访问跟不通的http访问没什么区别,因为受信ca的证书在操作系统中默认带有。当访问不是受信的证书的时候,我们需要设置trusManager。如果使用camel,可以这样设置。
调用https协议的webservice,以及证书手动加载
调用https协议的webservice,以及证书手动加载。
java访问https网址下载文件(含证书)
我使用jdk1.7,新建的是java项目,注意java compiler也是1.7,你需要把jar包拿过去,类拿过去
python requests模块https请求免证书设置
上代码 #!usr/bin/python # -*- coding: utf-8 -*- from bs4 import BeautifulSoup import requests import sys reload(sys) sys.setdefaultencoding('utf-8') url = &quot;https://www.shiyanlou.com/courses/?category...
java实现 HTTP/HTTPS请求绕过证书检测代码实现
1、开发需求 需要实现在服务端发起HTTP/HTTPS请求,访问其他程序资源。 2、URLConnection和HTTPClient的比较 HttpClient是个很不错的开源框架,封装了访问http的请求头,参数,内容体,响应等等, DefaultHttpClient和它的兄弟AndroidHttpClient都是HttpClient具体的实现类,它们都拥有众多的API,而且实现比较稳定,b
相关热词 c#异步发送kafka c#窗体编号 c# 操作二进制文件 c# 反射 机制 c#线程 窗体失去响应 c#角度转弧度 c# 解析gps数据 c# vs设置 语法版本 c# json含回车 c#多线程demo