精华内容
下载资源
问答
  • 利用xposed绕过安卓SSL证书的强校验

    千次阅读 2016-03-06 17:54:57
    https协议验证服务器身份的方式通常有三种,一是根据浏览器或者说操作系统(Android)自带的证书链;二是使用自签名证书;三是自签名证书加上SSL Pinning特性。第一种需要到知名证书机构购买证书,需要一定预算。第...

    什么是SSL pinning

    https协议验证服务器身份的方式通常有三种,一是根据浏览器或者说操作系统(Android)自带的证书链;二是使用自签名证书;三是自签名证书加上SSL Pinning特性。第一种需要到知名证书机构购买证书,需要一定预算。第二种多见于内网使用。第三种在是安全性最高的,但是需要浏览器插件或客户端使用了SSL Pinning特性。
    Android应用程序在使用https协议时也使用类似的3种方式验证服务器身份,分别是系统证书库、自带证书库、自带证书库 + SSL Pinning特性。
    所以SSL Pinning,即SSL证书绑定,是验证服务器身份的一种方式,是在https协议建立通信时增加的代码逻辑,它通过自己的方式验证服务器身份,然后决定通信是否继续下去。它唯一指定了服务器的身份,所以安全性较高。

    JustTrustMe

    当客户端使用了SSL pinning的时候,手机导入burpsuite证书的方式也无法抓到通信包。除了修改apk验证证书逻辑重新打包的方式外,最简单的方法是使用xposed相关模块。

    xposed安装方法:

    下载xposed安装包

    安装xposed框架到手机:

    adb install <xposed-installer-you-just-downloaded>.apk
    

    安装并启用justtrustme模块

    重启手机就可以抓到之前抓不到的https通信了。

    参考资料

    http://www.nsfocus.com.cn/upload/contents/2015/07/2015_07241353337959.pdf

    原文地址: http://xdxd.love/2015/12/30/%E5%88%A9%E7%94%A8xposed%E7%BB%95%E8%BF%87%E5%AE%89%E5%8D%93SSL%E8%AF%81%E4%B9%A6%E7%9A%84%E5%BC%BA%E6%A0%A1%E9%AA%8C/

    展开全文
  • Apache Axis2/C在实现上存在安全绕过漏洞,成功利用后可允许攻击者执行中间人攻击或模拟受信任的服务器。 <* 参考 Seth Arnold *> 转载于:https://www.cnblogs.com/security4399/a...

    漏洞版本:

    Apache Group Axis2/C

    漏洞描述:

    Axis2是一个用C语言实现的Web服务引擎。
    
    Apache Axis2/C在实现上存在安全绕过漏洞,成功利用后可允许攻击者执行中间人攻击或模拟受信任的服务器。
    <* 参考
    Seth Arnold
    *>

    转载于:https://www.cnblogs.com/security4399/archive/2013/01/14/2860361.html

    展开全文
  • 因为请求接口的证书是自签名的不被信任,请求提示如下错误: ...绕过SSL证书校验: CertificateValidationIgnored.java package com.inspur.hlSSLzs; import java.io.IOException; import j...

    背景描述:org.apache.commons.httpclient.HttpClient请求https URL。因为请求接口的证书是自签名的不被信任,请求提示如下错误:

    绕过SSL证书校验:

    CertificateValidationIgnored.java

    package com.*****.hlSSLzs;
    import java.io.IOException;
    import java.net.InetAddress;
    import java.net.Socket;
    import java.net.UnknownHostException;
    
    import javax.net.ssl.SSLContext;
    import javax.net.ssl.TrustManager;
    
    import org.apache.commons.httpclient.ConnectTimeoutException;
    import org.apache.commons.httpclient.HttpClientError;
    import org.apache.commons.httpclient.params.HttpConnectionParams;
    import org.apache.commons.httpclient.protocol.ControllerThreadSocketFactory;
    import org.apache.commons.httpclient.protocol.SecureProtocolSocketFactory;
    
    public class CertificateValidationIgnored implements SecureProtocolSocketFactory {
    
    	private SSLContext sslContext = null;
    
    	/**
    	 * Constructor for MySecureProtocolSocketFactory.
    	 */
    	public CertificateValidationIgnored() {
    	}
    
    	/**
    	 * @return
    	 */
    	private static SSLContext createEasySSLContext() {
    		try {
    			SSLContext context = SSLContext.getInstance("SSL");
    			context.init(null, new TrustManager[] {new MyX509TrustManager()}, null);
    			return context;
    		} catch (Exception e) {
    			throw new HttpClientError(e.toString());
    		}
    	}
    
    /**
    * @return
    */
    private SSLContext getSSLContext() {
    if (this.sslContext == null) {
    this.sslContext = createEasySSLContext();
    }
    return this.sslContext;
    }
    
    /*
    * (non-Javadoc)
    * @see
    * org.apache.commons.httpclient.protocol.ProtocolSocketFactory#createSocket(java.lang.String,
    * int, java.net.InetAddress, int)
    */
    public Socket createSocket(String host, int port, InetAddress clientHost, int clientPort) throws IOException,
    UnknownHostException {
    
    return getSSLContext().getSocketFactory().createSocket(host, port, clientHost, clientPort);
    }
    
    /*
    * (non-Javadoc)
    * @see
    * org.apache.commons.httpclient.protocol.ProtocolSocketFactory#createSocket(java.lang.String,
    * int, java.net.InetAddress, int, org.apache.commons.httpclient.params.HttpConnectionParams)
    */
    public Socket createSocket(final String host, final int port, final InetAddress localAddress, final int localPort,
    final HttpConnectionParams params) throws IOException, UnknownHostException, ConnectTimeoutException {
    if (params == null) {
    throw new IllegalArgumentException("Parameters may not be null");
    }
    int timeout = params.getConnectionTimeout();
    if (timeout == 0) {
    return createSocket(host, port, localAddress, localPort);
    } else {
    return ControllerThreadSocketFactory.createSocket(this, host, port, localAddress, localPort, timeout);
    }
    }
    
    /*
    * (non-Javadoc)
    * @see SecureProtocolSocketFactory#createSocket(java.lang.String,int)
    */
    public Socket createSocket(String host, int port) throws IOException, UnknownHostException {
    return getSSLContext().getSocketFactory().createSocket(host, port);
    }
    
    /*
    * (non-Javadoc)
    * @see SecureProtocolSocketFactory#createSocket(java.net.Socket,java.lang.String,int,boolean)
    */
    public Socket createSocket(Socket socket, String host, int port, boolean autoClose) throws IOException,
    UnknownHostException {
    return getSSLContext().getSocketFactory().createSocket(socket, host, port, autoClose);
    }
    }
    
     
    

    MyX509TrustManager.java

    package com.****.hlSSLzs;
    
    
    import java.security.cert.CertificateException;
    import java.security.cert.X509Certificate;
    
    import javax.net.ssl.X509TrustManager;
    
    public class MyX509TrustManager implements X509TrustManager {
    
    /*
    * (non-Javadoc)
    * @see javax.net.ssl.X509TrustManager#checkClientTrusted(java.security.cert.X509Certificate[],
    * java.lang.String)
    */
    public void checkClientTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {
    
    }
    
    /*
    * (non-Javadoc)
    * @see javax.net.ssl.X509TrustManager#checkServerTrusted(java.security.cert.X509Certificate[],
    * java.lang.String)
    */
    public void checkServerTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {
    
    }
    
    /*
    * (non-Javadoc)
    * @see javax.net.ssl.X509TrustManager#getAcceptedIssuers()
    */
    public X509Certificate[] getAcceptedIssuers() {
    return null;
    }
    
    }
    

    使用上面两个类,创建HttpClient对象:

    package com.***.pjYzm;
    import org.apache.commons.httpclient.*;
    import org.apache.commons.httpclient.methods.*;
    import org.apache.commons.httpclient.params.HttpMethodParams;
    import org.apache.commons.httpclient.protocol.Protocol;
    import org.apache.commons.httpclient.protocol.ProtocolSocketFactory;
    import org.apache.http.HttpResponse;
    import org.apache.http.client.config.RequestConfig;
    import org.apache.http.client.methods.HttpPost;
    import org.apache.http.entity.StringEntity;
    import org.apache.http.impl.client.CloseableHttpClient;
    import org.apache.http.impl.client.HttpClients;
    import org.apache.http.util.EntityUtils;
    import org.apache.commons.httpclient.cookie.*;
    import java.util.*;
    import org.jsoup.*;
    import org.jsoup.nodes.*;
    import org.jsoup.select.*;
    
    import com.***.hlSSLzs.CertificateValidationIgnored;
    
    import net.sf.json.JSONObject;
    
    import java.io.*;
    import java.net.MalformedURLException;
    import java.net.URL;
    	/**
    	 *<p>Tile:LoginTest.java<p>
    	 *<p>Description:获取cookie和验证码模拟登录教务系统<p>
    	 * @author YXS<p>
    	 * @data2018年6月3日
    	 */
    	public class postRequstDemo {
    	
    		public static String getHTML() throws Exception {
    			String cookie1 = "";
    			String html = "null";
    			
    			//构造httpclient实例并且忽略服务端SSL证书校验
    			ProtocolSocketFactory fcty = new CertificateValidationIgnored();
    			Protocol.registerProtocol("https", new Protocol("https", fcty, 443));
    			HttpClient httpClient=new HttpClient();
    			
    			try {
    				
    					//进行登录后的操作
    					/**税(费)种认定信息接口调用_cui_xyang*/
    					String urlszrd = "http://localhost:8080/service/sfzrd/getSfzrdxxList";
    					//模拟登录,按实际服务器端要求选用Post 或 Get请求方式
    					PostMethod postMethodszrd = new PostMethod(urlszrd);
    					
    					//设置登录时需要的信息
    					JSONObject parameters = new JSONObject();
    					parameters.put("rdyxqq", "");
    					parameters.put("rdyxqz", "");
    					parameters.put("djxh", "1011*********747");
    					String  toJson = parameters.toString();
    					RequestEntity se = new StringRequestEntity (toJson ,"application/json" ,"UTF-8");
    					postMethodszrd.setRequestEntity(se);
    					postMethodszrd.setRequestHeader("Content-Type","application/json");
    					//默认的重试策略
    					postMethodszrd.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler());
    					postMethodszrd.getParams().setParameter(HttpMethodParams.SO_TIMEOUT, 5000);//设置超时时间
    				
    					try{
    						//设置HttpClient接收Cookie
    						httpClient.getParams().setCookiePolicy(CookiePolicy.BROWSER_COMPATIBILITY);
    						
    						int statusCode = httpClient.executeMethod(postMethodszrd);
    						html = postMethodszrd.getResponseBodyAsString();
    						System.out.println(statusCode);
    						if(statusCode == 200){
    							System.out.println("税(费)种认定信息接口调用成功!");
    							System.out.println("税(费)种认定信息接口调用返回报文:"+html);
    						}
    					}catch(Exception e){
    						e.printStackTrace();
    					}
    				
    				}catch(Exception e){
    					e.printStackTrace();
    				}
    			return html;
    			
    			}
    		
    	
    		public static void main(String[] args) throws Exception {
    			postRequstDemo.getHTML();
    			
    		}
    	
    
    }
    

     

    展开全文
  • 经过app的SSL证书验证之后,就是这样子,别人无法获取报文,除非服务器的证书信任Charles的证书前言1、目前采用的是AFSSLPinningModePublicKey 方式验证。 2、 若想采用AFSSLPinningModeCertificate方式验证,请...

    前言

    • 原文

    https://kunnan.blog.csdn.net/article/details/77115940

    • 效果:
      这里写图片描述

    经过app的SSL证书验证之后,就是这样子,别人无法获取报文,除非服务器的证书信任Charles的证书

    验证方法:

    (void)connection:(NSURLConnection *)connection willSendRequestForAuthenticationChallenge:(NSURLAuthenticationChallenge *)challenge;

    • 针对NSURLSession

    - (void)URLSession:(NSURLSession *)session didReceiveChallenge:(NSURLAuthenticationChallenge *)challenge

    ​ completionHandler:(void (^)(NSURLSessionAuthChallengeDisposition disposition, NSURLCredential * _Nullable credential))completionHandler; 获取证书信息进行验证

    I 、 app侧进行 SSL证书验证

    1.0 HTTPS连接建立过程

    AFSecurityPolicy用于验证HTTPS请求的证书 ,先来看看HTTPS的原理和证书相关的几个问题。

    • HTTPS连接建立过程:

    客户端和服务端建立一个连接,服务端返回一个证书,客户端里存有各个受信任的证书机构根证书,用这些根证书对服务端返回的证书进行验证,经验证如果证书是可信任的,就生成一个pre-master secret,用这个证书的公钥加密后发送给服务端,服务端用私钥解密后得到pre-master secret,再根据某种算法生成master secret,客户端也同样根据这种算法从pre-master secret生成master secret,随后双方的通信都用这个master secret对传输数据进行加密解密。

    • 证书是怎样验证的?怎样保证中间人不能伪造证书?

    首先要知道非对称加密算法的特点,非对称加密有一对公钥私钥,用公钥加密的数据只能通过对应的私钥解密,用私钥加密的数据只能通过对应的公钥解密。
    例子:一个证书颁发机构(CA),颁发了一个证书A,服务器用这个证书建立https连接。客户端在信任列表里有这个CA机构的根证书。
    首先CA机构颁发的证书A里包含有证书内容F,以及证书加密内容F1,加密内容F1就是用这个证书机构的私钥对内容F加密的结果。(这中间还有一次hash算法)
    建立https连接时,服务端返回证书A给客户端,客户端的系统里的CA机构根证书有这个CA机构的公钥,用这个公钥对证书A的加密内容F1解密得到F2,跟证书A里内容F对比,若相等就通过验证。

    整个流程大致是:F->CA私钥加密->F1->客户端CA公钥解密->F。因为中间人不会有CA机构的私钥,客户端无法通过CA公钥解密,所以伪造的证书肯定无法通过验证。

    • 什么是SSL Pinning?

    可以理解为证书绑定,是指客户端直接保存服务端的证书,建立https连接时直接对比服务端返回的和客户端保存的两个证书是否一样,一样就表明证书是真的,不再去系统的信任证书机构里寻找验证。这适用于非浏览器应用,因为浏览器跟很多未知服务端打交道,无法把每个服务端的证书都保存到本地,但CS架构的像手机APP事先已经知道要进行通信的服务端,可以直接在客户端保存这个服务端的证书用于校验。

    为什么直接对比就能保证证书没问题?如果中间人从客户端取出证书,再伪装成服务端跟其他客户端通信,它发送给客户端的这个证书不就能通过验证吗?确实可以通过验证,但后续的流程走不下去,因为下一步客户端会用证书里的公钥加密,中间人没有这个证书的私钥就解不出内容,也就截获不到数据,这个证书的私钥只有真正的服务端有,中间人伪造证书主要伪造的是公钥。
    为什么要用SSL Pinning?正常的验证方式不够吗?如果服务端的证书是从受信任的的CA机构颁发的,验证是没问题的,但CA机构颁发证书比较昂贵,小企业或个人用户可能会选择自己颁发证书,这样就无法通过系统受信任的CA机构列表验证这个证书的真伪了,所以需要SSL Pinning这样的方式去验证。当然更重要的是可以防止通过手动设置信任证书进行代理抓包,比如Charles

    1.1 关于 DER 的概念:

    1.2 AFSecurityPolicy

    NSURLConnection已经封装了https连接的建立、数据的加密解密功能,我们直接使用NSURLConnection是可以访问https网站的,但NSURLConnection并没有验证证书是否合法,无法避免中间人攻击。要做到真正安全通讯,需要我们手动去验证服务端返回的证书,AFSecurityPolicy封装了证书验证的过程,让用户可以轻易使用,除了去系统信任CA机构列表验证,还支持SSL Pinning方式的验证。

    1.2.1 使用方法

    • 把服务端证书(需要转换成cer格式)放到APP项目资源里,AFSecurityPolicy会自动寻找根目录下所有cer文件
    //把服务端证书(需要转换成cer格式)放到APP项目资源里,AFSecurityPolicy会自动寻找根目录下所有cer文件
    AFSecurityPolicy *securityPolicy = [AFSecurityPolicy policyWithPinningMode:AFSSLPinningModePublicKey];
    securityPolicy.allowInvalidCertificates = YES;
    [AFHTTPRequestOperationManager manager].securityPolicy = securityPolicy;
    [manager GET:@"https://example.com/" parameters:nil success:^(AFHTTPRequestOperation *operation, id responseObject) {
    } failure:^(AFHTTPRequestOperation *operation, NSError *error) {
    }];
    
    
    • 1、目前采用的是AFSSLPinningModePublicKey 方式验证。
    • 2、 若想采用AFSSLPinningModeCertificate方式验证,需要服务端提供正确的cer 证书。

    使用AFSSLPinningModeCertificate 方式验证的时候,获取 DER 表示的数据时
    发生如下错误: Create a certificate Return NULL 。根据“@result Return NULL if the passed-in data is not a valid DER-encoded ”,从而推测cer证书 is not a valid DER-encoded。

    1.2.2 使用 AFSecurityPolicy 时,总共有三种验证服务器是否被信任的方式:

    AFSSLPinningModeNone
      • 这个模式不做本地证书验证(不做 SSL Pinning 操作)
      • 直接从客户端系统中的受信任颁发机构 CA 列表中去验证
    
    AFSSLPinningModePublicKey
      • 客户端需要一份证书文件的拷贝
      • 验证时只验证证书里的公钥,不验证证书的有效期等信息
      • 即使伪造证书的公钥,也不能解密传输的数据,必须要私钥
    
    AFSSLPinningModeCertificate
      • 客户端需要一份证书文件的拷贝
      • 第一步验证、先验证证书的域名/有效期等信息
      • 第二步验证、对比服务端返回的证书跟客户端存储的证书是否一致
    

    1.3 AFNetworkingssl证书认证的步骤

    1.3.1 获取到站点的证书:

    • 使用以下openssl命令来获取到服务器的公开二进制证书(以google为例):
    "openssl s_client -connect www.google.com:443 </dev/null 2>/dev/null | openssl x509 -outform DER > https.cer"
    
    

    1.3.2 web端服务器必须要提供一个叫SSL的证书

    证书里面包含有一个叫.crt的文件,你需要将它转换成.cer的格式,转换方法如下:openssl x509 -in your certificate.crt -out your certificate.cer -outform der

    • 转换成功后需要找到你转换成.cer的文件.添加到你的xcode工程当中去;然后读取二进制数据对其赋值

    • 项目中的文件,攻击者很容易通过解包取出,所以我们一般,在代码中存放证书的二进制流数据

    1.3.3 AFN2.x 需要添加AFSecuriPolicy和setAFHTTPRequestOperationManager


    • 设置安全策略setSecurityPolicy
       dispatch_once(&onceToken, ^{
            _manager = [AFHTTPRequestOperationManager manager];//只初始化一次
    //        [_manager setSecurityPolicy:[HTTPRequestManager setupSecurityPolicy]];
            
        });
    
        btn.enabled = NO;
        
        //1. 设置安全策略
        [_manager setSecurityPolicy:[HTTPRequestManager setupSecurityPolicy]];
    
    • ssl证书检测设置:添加安全策略
    #pragma mark - ******** ssl证书检测设置
    
    + (AFSecurityPolicy*)setupSecurityPolicy
    {
        NSString *cerPath = [[NSBundle mainBundle] pathForResource:@"cxxxxweimpliuay"ofType:@"cer"];
        NSData *certData = [NSData dataWithContentsOfFile:cerPath];
    //    AFSecurityPolicy *securityPolicy = [[AFSecurityPolicy alloc] init];
        AFSecurityPolicy *securityPolicy = [AFSecurityPolicy policyWithPinningMode:AFSSLPinningModeCertificate];
        [securityPolicy setPinnedCertificates:@[certData]];
        securityPolicy.allowInvalidCertificates =NO;//定义了客户端是否信任非法证书
        securityPolicy.validatesDomainName =YES;//是指是否校验在证书中的domain这一个字段
        securityPolicy.validatesCertificateChain =NO;//指的是是否校验其证书链。
        return securityPolicy;
    }
    

    1.3.4 ssl证书安全策略的的属性分析

    securityPolicy.allowInvalidCertificates =NO;
    securityPolicy.validatesDomainName =YES;
    securityPolicy.validatesCertificateChain =NO;
    
    

    1.3.4.0 pinnedCertificates

    用来校验服务器返回证书的证书。通常都保存在mainBundle 下。

    通常默认情况下,AFNetworking会自动寻找在mainBundle的根目录下所有的.cer文件并保存在pinnedCertificates数组里,以校验服务器返回的证书。

    1.3.4.1 allowInvalidCertificates

    是否允许无效证书(也就是自建的证书),默认为NO;如果是需要验证自建证书,需要设置为YES

    定义了客户端是否信任非法证书。

    一般来说,每个版本的iOS设备中,都会包含一些既有的CA根证书。如果接收到的证书是iOS信任的CA根证书签名的,那么则为合法证书;否则则为“非法”证书。

    allowInvalidCertificates 就是用来确认是否信任这样的证书的。当然,我们也可以给iOS加入新的信任的CA证书。iOS已有的CA根证书,可以在这里了解到

    1.3.4.2 validatesDomainName 是否需要验证域名,默认为YES;假如证书的域名与你请求的域名不一致,需把该项设置为NO;

    如设成NO的话,即服务器使用其他可信任机构颁发的证书,也可以建立连接,这个非常危险,建议打开。
    设置为NO,主要用于这种情况:客户端请求的是子域名,而证书上的是另外一个域名。因为SSL证书上的域名是独立

    是指是否校验在证书中的domain这一个字段。每个证书都会包含一个DomainName, 它可以是一个IP地址,一个域名或者一端带有通配符的域名。
    如*.google.com, www.google.com 都可以成为这个证书的DomainName。设置validatesDomainName=YES将严格地保证其安全性

    1.3.4.3 validatesCertificateChain 是否验证整个证书链,默认为YES, 设置为YES,

    通常来讲,一个CA证书颁发机构有很多个子机构,用来签发不同用途的子证书,然后这些子证书又再用来签发相应的证书。只有证书链上的证书都正确,CertificateChain才算验证完成。

    以Google为例:

    在这里插入图片描述

    从上图可以看到,Google.com的证书的根CA证书是GeoTrust Global CA; 而CA并没有直接给google.com签证书,而是先签名了Google Internet Authority G2, 然后G2再签名了google.com。这时候就需要设备中保存有Google Internet Authority G2证书才能通过校验。

    一般来讲,推荐将validatesCertificateChain设置为NO,因为并不是太有必要做CertificateChain的校验。
    并且,在AFNetworking 2.6.0中,也正式将validatesCertificateChain拿掉了(https://github.com/AFNetworking/AFNetworking/blob/master/CHANGELOG.md), 其原因也同样为:There was no documented security advantage to pinning against an entire certificate chain。
      因此,在2.6.0之后,可以不管这个字段。而在此之前,从效率上来说,设定为NO会是个比较明智的选择。

    1.3.4.5 AFSSLPinningMode :如何去校验服务器端给予的证书

    typedef NS_ENUM(NSUInteger, AFSSLPinningMode) {
        AFSSLPinningModeNone,
        AFSSLPinningModePublicKey,
        AFSSLPinningModeCertificate,
    };
    
    
    • AFSSLPinningModeNone: 代表客户端无条件地信任服务器端返回的证书。

    这个模式不做本地证书验证(不做 SSL Pinning 操作)
    直接从客户端系统中的受信任颁发机构 CA 列表中去验证

    • AFSSLPinningModePublicKey: 代表客户端会将服务器端返回的证书与本地保存的证书中,PublicKey的部分进行校验;如果正确,才继续进行。

    客户端需要一份证书文件的拷贝
    验证时只验证证书里的公钥,不验证证书的有效期等信息
    即使伪造证书的公钥,也不能解密传输的数据,必须要私钥

    • AFSSLPinningModeCertificate: 代表客户端会将服务器端返回的证书和本地保存的证书中的所有内容,包括PublicKey和证书部分,全部进行校验;如果正确,才继续进行。

    客户端需要一份证书文件的拷贝
    第一步验证、先验证证书的域名/有效期等信息
    第二步验证、对比服务端返回的证书跟客户端存储的证书是否一致

    1.4 使用NSURLConnection证书认证

    • 当收到HTTPS服务端认证的challenge时的回调方法,在该方法中实现对服务端证书的认证。
    connection canAuthenticateAgainstProtectionSpace:(NSURLProtectionSpace *)protectionSpace;
    
    
    • 证书认证的具体实现,非协议方法,须自行实现。
    -(BOOL)shouldTrustProtectionSpace:(NSURLProtectionSpace *)protectionSpace;
    
    
    • 该方法为连接失败的回调,若证书验证失败,会触发该方法。
    connection didFailWithError:(NSError *)error;
    
    

    II、常见错误& 解决方案

    2.1 解决https 证书过期 app 报NSLocalizedDescription = cancelled code=-999

    #pragma mark - ******** 允许证书失效
    
    + (void)setupAFSecurityPolicy:(AFHTTPSessionManager*)manager{
        
        AFSecurityPolicy *securityPolicy = [AFSecurityPolicy policyWithPinningMode:AFSSLPinningModeNone];
        securityPolicy.allowInvalidCertificates = YES;
        securityPolicy.validatesDomainName = NO;
        //    securityPolicy. = YES;
        
        manager.securityPolicy = securityPolicy;
        
    }
    
    

    2.2 Create a certificate Return NULL

    • 问题现象:
      使用AFSSLPinningModeCertificate 方式验证的时候,获取 DER 表示的数据时,发生如下错误: Create a certificate Return NULL 。
      根据“@result Return NULL if the passed-in data is not a valid DER-encoded ”,从而推测cer证书 is not a valid DER-encoded。

    • 问题分析–to uncaught exception 'NSInvalidArgumentException', reason: '\ -[__NSArrayM insertObject:atIndex:]: object cannot be nil'

    问题定位–获取DER信息函数

    /*!
         
        @function SecCertificateCreateWithData
         
        @abstract Create a certificate given it's DER representation as a CFData.
         
        @param allocator CFAllocator to allocate the certificate with.
         
        @param certificate DER encoded X.509 certificate.
         
        @result Return NULL if the passed-in data is not a valid DER-encoded
         
        X.509 certificate, return a SecCertificateRef otherwise.
         
    */
         
    __nullable
         
    SecCertificateRef SecCertificateCreateWithData(CFAllocatorRef __nullable allocator,
         
        CFDataRef data) __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_2_0);
    
    
    • 报错信息
      Terminating app due to uncaught exception 'NSInvalidArgumentException', reason: '*** -[__NSArrayM insertObject:atIndex:]: object cannot be nil'
    
    
    • 报错代码
    [pinnedCertificates addObject:(__bridge_transfer id)SecCertificateCreateWithData(NULL, (__bridge CFDataRef)certificateData)];
    
    

    2.2.1 解决方案:转变格式为DER

    错误信息是编码不对,证书有BASE64和DER两种编码,提供的证书是常用的BASE64编码,der二进制编码可以使用openssl进行转换。

    • 转变格式为DER
    openssl x509 -outform der -in kncmpay.cer -out kncmpay.cer
    
    

    III、绕过证书校验

    https://github.com/zhangkn/ios-ssl-kill-switch

    pinning/disable.js: This hook attempts many ways to kill SSL pinning and certificate

    IV、 see also

    4.0 证书之间的转换(cer、pem、p12)

    • 转变格式为DER
    openssl x509 -outform der -in kncmpay.cer -out kncmpay.cer
    
    
    • pem证书生成

    将p12证书文件转换成pem证书文件。在终端里运行以下命令转换:

    openssl pkcs12 -in MyApnsCert.p12 -out MyApnsCert.pem -nodes
    
    
    openssl smime -sign -in Example.mobileconfig -out SignedVerifyExample.mobileconfig -signer InnovCertificates.pem -certfile root.crt.pem -outform der -nodetach
    
    
    • DER文件(.crt .cer .der)转为PEM格式文件

    转换DER文件(一般后缀名是.crt .cer .der的文件)到PEM文件

    openssl x509 -inform der -in certificate.cer -out certificate.pem 
    
    

    转换PEM文件到DER文件

    openssl x509 -outform der -in certificate.pem -out certificate.der
    
    

    p12 文件导出公钥私钥

    生成key文件
    openssl pkcs12 -in demo.p12 -nocerts -nodes -out demo.key
    导出私钥
    openssl rsa -in demo.key -out demo_pri.pem
    导出公钥
    openssl rsa -in demo.key -pubout -out demo_pub.pem

    • 格式说明

    1、PKCS 全称是 Public-Key Cryptography Standards ,是由 RSA 实验室与其它安全系统开发商为促进公钥密码的发展而制订的一系列标准,PKCS 目前共发布过 15 个标准。 常用的有:
    PKCS#7 Cryptographic Message Syntax Standard
    PKCS#10 Certification Request Standard
    PKCS#12 Personal Information Exchange Syntax Standard
    2、X.509是常见通用的证书格式。所有的证书都符合为Public Key Infrastructure (PKI) 制定的 ITU-T X509 国际标准。
    PKCS#7 常用的后缀是: .P7B .P7C .SPC
    PKCS#12 常用的后缀有: .P12 .PFX
    3、X.509 DER 编码(ASCII)的后缀是: .DER .CER .CRT
    X.509 PAM 编码(Base64)的后缀是: .PEM .CER .CRT
    4、.cer/.crt是用于存放证书,它是2进制形式存放的,不含私钥。
    5、.pem跟crt/cer的区别是它以Ascii来表示。
    6、pfx/p12用于存放个人证书/私钥,他通常包含保护密码,2进制方式
    7、p10是证书请求
    8、p7r是CA对证书请求的回复,只用于导入
    9、p7b以树状展示证书链(certificate chain),同时也支持单个证书,不含私钥。

    • 用openssl创建CA证书的RSA密钥(PEM格式):
    openssl genrsa -des3 -out ca.key 1024
    
    
    • 用openssl创建CA证书(PEM格式,假如有效期为一年):
    openssl req -new -x509 -days 365 -key ca.key -out ca.crt -config openssl.cnf
    
    
    • x509转换为pfx
    openssl pkcs12 -export -out server.pfx -inkey server.key -in server.crt
    
    
    • PEM格式的ca.key转换为Microsoft可以识别的pvk格式
    pvk -in ca.key -out ca.pvk -nocrypt -topvk
    
    
    • PKCS#12 到 PEM 的转换
    openssl pkcs12 -nocerts -nodes -in cert.p12 -out private.pem
     #验证 
     openssl pkcs12 -clcerts -nokeys -in cert.p12 -out cert.pem
    
    
    • 从 PFX 格式文件中提取私钥格式文件 (.key)
    openssl pkcs12 -in mycert.pfx -nocerts -nodes -out mycert.key
    
    
    • 转换 pem 到到 spc
    openssl crl2pkcs7 -nocrl -certfile venus.pem -outform DER -out venus.spc
    
    

    用 -outform -inform 指定 DER 还是 PAM 格式。例如:
    openssl x509 -in Cert.pem -inform PEM -out cert.der -outform DER

    • PEM 到 PKCS#12 的转换
    openssl pkcs12 -export -in Cert.pem -out Cert.p12 -inkey key.pem
    
    

    4.1 手动选择信任证书

    • iOS 信任证书
    iOS10.3.1 新安装的证书需要手动选择信任证书。
    
    解决方式:
    
    设置->通用->关于本机->证书信任设置
    
    • 应用场景:iOS10.3.1 新安装的证书需要手动选择信任证书。

    4.2 AFSecurity.m 源码注释

    
    // AFSecurity.m
    //
    // Copyright (c) 2013-2014 AFNetworking (http://afnetworking.com)
    //
    // Permission is hereby granted, free of charge, to any person obtaining a copy
    // of this software and associated documentation files (the "Software"), to deal
    // in the Software without restriction, including without limitation the rights
    // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    // copies of the Software, and to permit persons to whom the Software is
    // furnished to do so, subject to the following conditions:
    //
    // The above copyright notice and this permission notice shall be included in
    // all copies or substantial portions of the Software.
    //
    // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
    // THE SOFTWARE.
     
    #import "AFSecurityPolicy.h"
     
    // Equivalent of macro in , without causing compiler warning:
    // "'DebugAssert' is deprecated: first deprecated in OS X 10.8"
    //这两个宏方法用于方便地处理调用各种证书方法过程中出现的错误,出现错误后用goto语句直接跳转到结束语
    //关于为什么要用 __builtin_expect (x, 0) 而不直接用 x != 0,是为了CPU执行时的性能优化,见这里:
    //http://stackoverflow.com/questions/7346929/why-do-we-use-builtin-expect-when-a-straightforward-way-is-to-use-if-else
    #ifndef AF_Require
    #define AF_Require(assertion, exceptionLabel)                \
    do {                                                     \
    if (__builtin_expect(!(assertion), 0)) {             \
    goto exceptionLabel;                             \
    }                                                    \
    } while (0)
    #endif
     
    #ifndef AF_Require_noErr
    #define AF_Require_noErr(errorCode, exceptionLabel)          \
    do {                                                     \
    if (__builtin_expect(0 != (errorCode), 0)) {         \
    goto exceptionLabel;                             \
    }                                                    \
    } while (0)
    #endif
     
    #if !defined(__IPHONE_OS_VERSION_MIN_REQUIRED)
    static NSData * AFSecKeyGetData(SecKeyRef key) {
        CFDataRef data = NULL;
     
        AF_Require_noErr(SecItemExport(key, kSecFormatUnknown, kSecItemPemArmour, NULL, &data), _out);
     
        return (__bridge_transfer NSData *)data;
     
    _out:
        if (data) {
            CFRelease(data);
        }
     
        return nil;
    }
    #endif
     
    static BOOL AFSecKeyIsEqualToKey(SecKeyRef key1, SecKeyRef key2) {
    #if defined(__IPHONE_OS_VERSION_MIN_REQUIRED)
        return [(__bridge id)key1 isEqual:(__bridge id)key2];
    #else
        return [AFSecKeyGetData(key1) isEqual:AFSecKeyGetData(key2)];
    #endif
    }
     
    //从证书里取public key
    static id AFPublicKeyForCertificate(NSData *certificate) {
        id allowedPublicKey = nil;
        SecCertificateRef allowedCertificate;
        SecCertificateRef allowedCertificates[1];
        CFArrayRef tempCertificates = nil;
        SecPolicyRef policy = nil;
        SecTrustRef allowedTrust = nil;
        SecTrustResultType result;
     
        //取证书SecCertificateRef -> 生成证书数组 -> 生成SecTrustRef -> 从SecTrustRef取PublicKey
        allowedCertificate = SecCertificateCreateWithData(NULL, (__bridge CFDataRef)certificate);
        AF_Require(allowedCertificate != NULL, _out);
     
        allowedCertificates[0] = allowedCertificate;
        tempCertificates = CFArrayCreate(NULL, (const void **)allowedCertificates, 1, NULL);
     
        policy = SecPolicyCreateBasicX509();
        AF_Require_noErr(SecTrustCreateWithCertificates(tempCertificates, policy, &allowedTrust), _out);
        AF_Require_noErr(SecTrustEvaluate(allowedTrust, &result), _out);
     
        allowedPublicKey = (__bridge_transfer id)SecTrustCopyPublicKey(allowedTrust);
     
    _out:
        if (allowedTrust) {
            CFRelease(allowedTrust);
        }
     
        if (policy) {
            CFRelease(policy);
        }
     
        if (tempCertificates) {
            CFRelease(tempCertificates);
        }
     
        if (allowedCertificate) {
            CFRelease(allowedCertificate);
        }
     
        return allowedPublicKey;
    }
     
    static BOOL AFServerTrustIsValid(SecTrustRef serverTrust) {
        BOOL isValid = NO;
        SecTrustResultType result;
        AF_Require_noErr(SecTrustEvaluate(serverTrust, &result), _out);
     
        //kSecTrustResultUnspecified:证书通过验证,但用户没有设置这些证书是否被信任
        //kSecTrustResultProceed:证书通过验证,用户有操作设置了证书被信任,例如在弹出的是否信任的alert框中选择always trust
        isValid = (result == kSecTrustResultUnspecified || result == kSecTrustResultProceed);
     
    _out:
        return isValid;
    }
     
    //取出服务端返回的所有证书
    static NSArray * AFCertificateTrustChainForServerTrust(SecTrustRef serverTrust) {
        CFIndex certificateCount = SecTrustGetCertificateCount(serverTrust);
        NSMutableArray *trustChain = [NSMutableArray arrayWithCapacity:(NSUInteger)certificateCount];
     
        for (CFIndex i = 0; i < certificateCount; i++) {
            SecCertificateRef certificate = SecTrustGetCertificateAtIndex(serverTrust, i);
            [trustChain addObject:(__bridge_transfer NSData *)SecCertificateCopyData(certificate)];
        }
     
        return [NSArray arrayWithArray:trustChain];
    }
     
    //取出服务端返回证书里所有的public key
    static NSArray * AFPublicKeyTrustChainForServerTrust(SecTrustRef serverTrust) {
        SecPolicyRef policy = SecPolicyCreateBasicX509();
        CFIndex certificateCount = SecTrustGetCertificateCount(serverTrust);
        NSMutableArray *trustChain = [NSMutableArray arrayWithCapacity:(NSUInteger)certificateCount];
        for (CFIndex i = 0; i < certificateCount; i++) {                  //取证书SecCertificateRef -> 生成证书数组 -> 生成SecTrustRef -> 从SecTrustRef取PublicKey
            SecCertificateRef certificate = SecTrustGetCertificateAtIndex(serverTrust, i);
     
            SecCertificateRef someCertificates[] = {certificate};
            CFArrayRef certificates = CFArrayCreate(NULL, (const void **)someCertificates, 1, NULL);
     
            SecTrustRef trust;
            AF_Require_noErr(SecTrustCreateWithCertificates(certificates, policy, &trust), _out);
     
            SecTrustResultType result;
            AF_Require_noErr(SecTrustEvaluate(trust, &result), _out);
     
            [trustChain addObject:(__bridge_transfer id)SecTrustCopyPublicKey(trust)];
     
        _out:
            if (trust) {
                CFRelease(trust);
            }
     
            if (certificates) {
                CFRelease(certificates);
            }
     
            continue;
        }
        CFRelease(policy);
     
        return [NSArray arrayWithArray:trustChain];
    }
     
    #pragma mark -
     
    @interface AFSecurityPolicy()
    @property (readwrite, nonatomic, strong) NSArray *pinnedPublicKeys;
    @end
     
    @implementation AFSecurityPolicy
     
    + (NSArray *)defaultPinnedCertificates {
        //默认证书列表,遍历根目录下所有.cer文件
        static NSArray *_defaultPinnedCertificates = nil;
        static dispatch_once_t onceToken;
        dispatch_once(&onceToken, ^{
            NSBundle *bundle = [NSBundle bundleForClass:[self class]];
            NSArray *paths = [bundle pathsForResourcesOfType:@"cer" inDirectory:@"."];
     
            NSMutableArray *certificates = [NSMutableArray arrayWithCapacity:[paths count]];
            for (NSString *path in paths) {
                NSData *certificateData = [NSData dataWithContentsOfFile:path];
                [certificates addObject:certificateData];
            }
     
            _defaultPinnedCertificates = [[NSArray alloc] initWithArray:certificates];
        });
     
        return _defaultPinnedCertificates;
    }
     
    + (instancetype)defaultPolicy {
        AFSecurityPolicy *securityPolicy = [[self alloc] init];
        securityPolicy.SSLPinningMode = AFSSLPinningModeNone;
     
        return securityPolicy;
    }
     
    + (instancetype)policyWithPinningMode:(AFSSLPinningMode)pinningMode {
        AFSecurityPolicy *securityPolicy = [[self alloc] init];
        securityPolicy.SSLPinningMode = pinningMode;
        securityPolicy.validatesDomainName = YES;
        [securityPolicy setPinnedCertificates:[self defaultPinnedCertificates]];
     
        return securityPolicy;
    }
     
    - (id)init {
        self = [super init];
        if (!self) {
            return nil;
        }
     
        self.validatesCertificateChain = YES;
     
        return self;
    }
     
    #pragma mark -
     
    - (void)setPinnedCertificates:(NSArray *)pinnedCertificates {
        _pinnedCertificates = pinnedCertificates;
     
        if (self.pinnedCertificates) {
            //预先取出public key,用于AFSSLPinningModePublicKey方式的验证
            NSMutableArray *mutablePinnedPublicKeys = [NSMutableArray arrayWithCapacity:[self.pinnedCertificates count]];
            for (NSData *certificate in self.pinnedCertificates) {
                id publicKey = AFPublicKeyForCertificate(certificate);
                if (!publicKey) {
                    continue;
                }
                [mutablePinnedPublicKeys addObject:publicKey];
            }
            self.pinnedPublicKeys = [NSArray arrayWithArray:mutablePinnedPublicKeys];
        } else {
            self.pinnedPublicKeys = nil;
        }
    }
     
    #pragma mark -
     
    - (BOOL)evaluateServerTrust:(SecTrustRef)serverTrust {
        return [self evaluateServerTrust:serverTrust forDomain:nil];
    }
     
    - (BOOL)evaluateServerTrust:(SecTrustRef)serverTrust
                      forDomain:(NSString *)domain
    {
        NSMutableArray *policies = [NSMutableArray array];
        if (self.validatesDomainName) {
            [policies addObject:(__bridge_transfer id)SecPolicyCreateSSL(true, (__bridge CFStringRef)domain)];
        } else {
            [policies addObject:(__bridge_transfer id)SecPolicyCreateBasicX509()];
        }
     
        SecTrustSetPolicies(serverTrust, (__bridge CFArrayRef)policies);
     
        //向系统内置的根证书验证服务端返回的证书是否合法
        //若使用自签名证书,这里的验证是会不合法的,需要设allowInvalidCertificates = YES
        if (!AFServerTrustIsValid(serverTrust) && !self.allowInvalidCertificates) {
            return NO;
        }
     
        //取出服务端返回的证书
        NSArray *serverCertificates = AFCertificateTrustChainForServerTrust(serverTrust);
        switch (self.SSLPinningMode) {
            case AFSSLPinningModeNone:
                //两种情况走到这里,
                //一是通过系统证书验证,返回认证成功
                //二是没通过验证,但allowInvalidCertificates = YES,也就是说完全不认证直接返回认证成功
                return YES;
     
                //验证整个证书
            case AFSSLPinningModeCertificate: {
                NSMutableArray *pinnedCertificates = [NSMutableArray array];
                for (NSData *certificateData in self.pinnedCertificates) {
                    [pinnedCertificates addObject:(__bridge_transfer id)SecCertificateCreateWithData(NULL, (__bridge CFDataRef)certificateData)];
                }
                //在本地证书里验证服务端返回的证书的有效性
                SecTrustSetAnchorCertificates(serverTrust, (__bridge CFArrayRef)pinnedCertificates);
                if (!AFServerTrustIsValid(serverTrust)) {
                    return NO;
                }
     
                if (!self.validatesCertificateChain) {
                    return YES;
                }
     
                //整个证书链都跟本地的证书匹配才给过
                NSUInteger trustedCertificateCount = 0;
                for (NSData *trustChainCertificate in serverCertificates) {
                    if ([self.pinnedCertificates containsObject:trustChainCertificate]) {
                        trustedCertificateCount++;
                    }
                }
     
                return trustedCertificateCount == [serverCertificates count];
            }
     
                //只验证证书的public key
            case AFSSLPinningModePublicKey: {
                NSUInteger trustedPublicKeyCount = 0;
                NSArray *publicKeys = AFPublicKeyTrustChainForServerTrust(serverTrust);
     
                //如果不用验证整个证书链,取第一个也就是真正会使用的那个证书验证就行
                if (!self.validatesCertificateChain && [publicKeys count] > 0) {
                    publicKeys = @[[publicKeys firstObject]];
                }
     
                //在本地证书里搜索相等的public key,记录找到个数
                for (id trustChainPublicKey in publicKeys) {
                    for (id pinnedPublicKey in self.pinnedPublicKeys) {
                        if (AFSecKeyIsEqualToKey((__bridge SecKeyRef)trustChainPublicKey, (__bridge SecKeyRef)pinnedPublicKey)) {
                            trustedPublicKeyCount += 1;
                        }
                    }
                }
     
                //验证整个证书链的情况:每个public key都在本地找到算验证通过
                //验证单个证书的情况:找到一个算验证通过
                return trustedPublicKeyCount > 0 && ((self.validatesCertificateChain && trustedPublicKeyCount == [serverCertificates count]) || (!self.validatesCertificateChain && trustedPublicKeyCount >= 1));
            }
        }
     
        return NO;
    }
     
    #pragma mark - NSKeyValueObserving
     
    + (NSSet *)keyPathsForValuesAffectingPinnedPublicKeys {
        return [NSSet setWithObject:@"pinnedCertificates"];
    }
     
    @end
    
    
    展开全文
  • 项目中遇到一个特殊场景,只有证书链中的二级ca证书服务器校验时只能调用二级去校验HTTPS,对pyopenssl研究了下源码,提取了一部分,可以直接注射到urllib3中,试了下urllib也是可以使用的 做HTTPS双向认证时,会...
  • SSL证书如果直接部署到CDN,同样网站也可以实现HTTPS访问,但CDN获取源服务器资源的过程是HTTP协议,如果源IP泄漏,用户可袭以直接使用技术方式直接访问真实的IP,这样就绕过了SSL设置的安全技术,...
  • https网站服务器都是有证书的。 是由网站自己的服务器签发的,并不... 现在需要SSL绕过证书,下面直接贴出代码,调用时只需要在发送请求后 new HttpsBerBer(文件的字节码) ; 1 import javax.net.ssl.HostnameVe...
  • 使用Frida绕过Android App的SSL Pinning

    千次阅读 2020-03-15 14:57:58
    证书锁定(Certificate pinning)是远程服务器在应用程序本身中信任的硬编码证书,因此它将忽略设备证书存储,并将信任自己的硬编码证书,进一步的应用程序将使用该硬编码证书“安全地”与远程服务器通信。...
  • 绕过国内服务器备案访问网页 本来今天高高兴兴去阿里云平台备案,结果给我打回来了,原因是身份证离过期不够三个月了。 嘶–我一琢磨去补身份证最少要30-60天加备案15天,四舍五入就是三个月 三个月服务器放在那里...
  • 漏洞版本: PHP 5.3.27 ... ... ...PHP SSL模块不正确处理服务器SSL证书中"subjectAltNames"通用名中的空字节,允许攻击者利用漏洞进行中间人攻击,获取敏感信息 <* 参考 http://www.secuni...
  • 夏普TLS扫描 该应用程序扫描服务器以查看其支持的SSL和TLS版本以及哪些密码套件。 它与名为sslscan( )和sslscan-win( )的程序非常... 添加了NoSchannel参数,该参数绕过证书和SChannel内容,直接进入密码扫描。
  • weblogic绕过HTTPS认证

    2020-12-14 14:26:08
    我们的项目是通过weblogic服务器部署,在后来的N次迭代中,有了新的需求,对方的接口链接地址域名是HTTPS经过SSL证书加密的,我们这边weblogic服务器调取不到,由于没有加证书认证! 问题描述:跳证书认证环节,...
  • 它尝试从Web服务器文件系统读取数据库凭据,然后使用凭据直接绕过Web服务器从数据库请求信息。 2-尝试从网络服务器获取证书的单阶段攻击 该项目实际上与Websecurity项目相同,但是Web服务器使用ssl,并且包括其他...
  • 这两天刚配置ssl到我的服务器,根据阿里云的自带的教程: 然后下载证书后就是文章讲的,存到cert文件夹里面,然后 然后就会很坑的看到上面图中的话: #LoadModule ssl_module modules/mod_ssl.so (如果找不到请...
  • HTTPS绕过安全认证进行请求链接

    千次阅读 2018-04-11 18:58:01
    在开发项目中需要调用第三方接口,本地测试没问题,部署到公司服务器就出现安全证书问题,具体报错:javax.net.ssl.SSLHandshakeException: sun.security.validator.ValidatorException: PKIX path validation failed: ...
  • 计算机下SSL安全网络通信

    千次阅读 2020-12-14 08:16:51
    SSL安全网络通信SSL安全套接层通信过程SSL通讯建立后绕过浏览器校验SSL的工作原理中包含三个协议1、握手协议2、记录协议3、警报协议证书的工作流程服务器端代码实现客服端代码实现资源传送门「❤️ 感谢大家」 SSL...
  • SSL operation failed with code 1. OpenSSL Error messages:error:14090086:SSL routines:SSL3_GET_SERVER_CERTIFICATE:certificate verify failed解决方案1....请求的时候绕过httpscurl_setopt($ch, CURLOP...
  • JDK版本不同引发的https请求证书问题

    千次阅读 2018-10-24 13:25:49
    首先,服务器上跑着一个接口工程,环境是jdk8,为https请求(证书认证,但这里绕过证书);客户端通过https调用接口,环境是jdk7,请求时报如下错: javax.net.ssl.SSLHandshakeException: Received fatal alert:...
  • 客户端向服务器发送https请求时,会验证服务端的证书状态,可以设置信任所有证书绕过这一步。 查看HttpClient官方文档,示例如下: 使用SSLContextBuilder来创建SSLContext实例,该类的方法如下: //参数...
  • 1:本文介绍了两个知识模块,一个是Tomcat配置SSL另外一个是客户端绕过证书验证实现https 2:本文参考的是https://blog.csdn.net/xiaoxian8023/article/details/49865335这个博客。而原博客中tomcat配置ssl是一篇...
  • APP之抓包

    2021-03-12 18:41:38
    burp抓不到APP数据包的两个情况: 1,SSL Pinning(又叫“ssl证书绑定“),客户端在收到服务器的证书后,...使用Xposed + JustTruestMe绕过SSL pinning 1,下载逍遥模拟器,配置低版本的安卓模拟器 2,下载xposed
  • http升级https改造方案

    2019-04-04 13:35:00
    在自己写的JAVA HttpClient程序,想手动验证证书,可以在客户端绕过验证服务器证书的步骤,即则需要实现空的X509TrustManager接口。 类中的验证方法返回void或者null,是为了绕过验证。正常的方法体如果检验出证书...
  • 反爬虫策略

    2018-10-17 14:33:48
    四 配置ssl,采用绕过证书验证实现https   一 通过请求头来控制访问 无论是浏览器还是爬虫程序,在向服务器发起网络请求的时候,都会发过去一个头文件:headers. 请求头报文如下图所示 这里面大部分的字段都是...
  • Easy_MultipleDomains - Magento 模块 1.4+ 这是什么 ? 这是一个模块,可帮助在单个安装中处理多个域名,... 并且您厌倦了每次必须验证某些事情是否是由于缓存情况或您想要专门解决您的一台服务器时都必须绕过清漆。
  • 1)子域名查询2)国外地址请求3)邮件服务4)遗留文件5)DNS历史记录6)SSL证书查询7)DDos攻击 一、简介 CDN的全称是Content Delivery Network,即内容分发网络。CDN是构建在现有网络基础之上的智能虚拟网络,...
  • 确保您拥有SSL证书(或绕过它们,请参见下文) 剧本 npm run dev :启动开发服务器 npm run build :打包应用程序(将出现在dist ) npm run deploy :使用自动部署到Github Pages。 JS vs TS 该项目主要是...

空空如也

空空如也

1 2
收藏数 35
精华内容 14
关键字:

服务器绕过ssl证书