2. 程式人生 > >Android Https請求詳解

Android Https請求詳解

阿新 • • 發佈：2019-01-04

轉至：http://itindex.net/detail/51666-android-https-demo

   Android Https詳細請求全方案實現，包括HttpUrlConnection及HttpClient方式實現指定證書及信任所有的實現，不多說了，以下程式碼都經過詳細測試，可以直接使用。

package com.example.httpstest;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.Certificate;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.TrustManager;
import javax.net.ssl.TrustManagerFactory;
import javax.net.ssl.X509TrustManager;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.scheme.PlainSocketFactory;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;

/**
 * HTTPS測試 測試地址：https://certs.cac.washington.edu/CAtest/
 * 測試證書：https://www.washington.edu/itconnect/security/ca/load-der.crt
 * 
 * 
 * @author guojing09
 * 
 */
public class MainActivity extends Activity {

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		new Thread(new Runnable() {

			@Override
			public void run() {
				try {
					initSSLWithHttpClinet();
				} catch (Exception e) {
					Log.e("HTTPS TEST", e.getMessage());
				}
			}
		}).start();
	}

	/**
	 * HttpUrlConnection 方式，支援指定load-der.crt證書驗證，此種方式Android官方建議
	 * 
	 * @throws CertificateException
	 * @throws IOException
	 * @throws KeyStoreException
	 * @throws NoSuchAlgorithmException
	 * @throws KeyManagementException
	 */
	public void initSSL() throws CertificateException, IOException, KeyStoreException,
			NoSuchAlgorithmException, KeyManagementException {
		CertificateFactory cf = CertificateFactory.getInstance("X.509");
		InputStream in = getAssets().open("load-der.crt");
		Certificate ca = cf.generateCertificate(in);

		KeyStore keystore = KeyStore.getInstance(KeyStore.getDefaultType());
		keystore.load(null, null);
		keystore.setCertificateEntry("ca", ca);

		String tmfAlgorithm = TrustManagerFactory.getDefaultAlgorithm();
		TrustManagerFactory tmf = TrustManagerFactory.getInstance(tmfAlgorithm);
		tmf.init(keystore);

		// Create an SSLContext that uses our TrustManager
		SSLContext context = SSLContext.getInstance("TLS");
		context.init(null, tmf.getTrustManagers(), null);
		URL url = new URL("https://certs.cac.washington.edu/CAtest/");
		HttpsURLConnection urlConnection = (HttpsURLConnection) url.openConnection();
		urlConnection.setSSLSocketFactory(context.getSocketFactory());
		InputStream input = urlConnection.getInputStream();

		BufferedReader reader = new BufferedReader(new InputStreamReader(input, "UTF-8"));
		StringBuffer result = new StringBuffer();
		String line = "";
		while ((line = reader.readLine()) != null) {
			result.append(line);
		}
		Log.e("TTTT", result.toString());
	}

	/**
	 * HttpUrlConnection支援所有Https免驗證，不建議使用
	 * 
	 * @throws KeyManagementException
	 * @throws NoSuchAlgorithmException
	 * @throws IOException
	 */
	public void initSSLALL() throws KeyManagementException, NoSuchAlgorithmException, IOException {
		URL url = new URL("https://certs.cac.washington.edu/CAtest/");
		SSLContext context = SSLContext.getInstance("TLS");
		context.init(null, new TrustManager[] { new TrustAllManager() }, null);
		HttpsURLConnection.setDefaultSSLSocketFactory(context.getSocketFactory());
		HttpsURLConnection.setDefaultHostnameVerifier(new HostnameVerifier() {

			@Override
			public boolean verify(String arg0, SSLSession arg1) {
				return true;
			}
		});
		HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
		connection.setDoInput(true);
		connection.setDoOutput(false);
		connection.setRequestMethod("GET");
		connection.connect();
		InputStream in = connection.getInputStream();
		BufferedReader reader = new BufferedReader(new InputStreamReader(in));
		String line = "";
		StringBuffer result = new StringBuffer();
		while ((line = reader.readLine()) != null) {
			result.append(line);
		}
		Log.e("TTTT", result.toString());
	}
	
	/**
	 * HttpClient方式實現，支援所有Https免驗證方式連結
	 * 
	 * @throws ClientProtocolException
	 * @throws IOException
	 */
	public void initSSLAllWithHttpClient() throws ClientProtocolException, IOException {
		int timeOut = 30 * 1000;
		HttpParams param = new BasicHttpParams();
		HttpConnectionParams.setConnectionTimeout(param, timeOut);
		HttpConnectionParams.setSoTimeout(param, timeOut);
		HttpConnectionParams.setTcpNoDelay(param, true);

		SchemeRegistry registry = new SchemeRegistry();
		registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
		registry.register(new Scheme("https", TrustAllSSLSocketFactory.getDefault(), 443));
		ClientConnectionManager manager = new ThreadSafeClientConnManager(param, registry);
		DefaultHttpClient client = new DefaultHttpClient(manager, param);

		HttpGet request = new HttpGet("https://certs.cac.washington.edu/CAtest/");
		// HttpGet request = new HttpGet("https://www.alipay.com/");
		HttpResponse response = client.execute(request);
		HttpEntity entity = response.getEntity();
		BufferedReader reader = new BufferedReader(new InputStreamReader(entity.getContent()));
		StringBuilder result = new StringBuilder();
		String line = "";
		while ((line = reader.readLine()) != null) {
			result.append(line);
		}
		Log.e("HTTPS TEST", result.toString());
	}

	/**
	 * HttpClient方式實現，支援驗證指定證書
	 * 
	 * @throws ClientProtocolException
	 * @throws IOException
	 */
	public void initSSLCertainWithHttpClient() throws ClientProtocolException, IOException {
		int timeOut = 30 * 1000;
		HttpParams param = new BasicHttpParams();
		HttpConnectionParams.setConnectionTimeout(param, timeOut);
		HttpConnectionParams.setSoTimeout(param, timeOut);
		HttpConnectionParams.setTcpNoDelay(param, true);

		SchemeRegistry registry = new SchemeRegistry();
		registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
		registry.register(new Scheme("https", TrustCertainHostNameFactory.getDefault(this), 443));
		ClientConnectionManager manager = new ThreadSafeClientConnManager(param, registry);
		DefaultHttpClient client = new DefaultHttpClient(manager, param);

		// HttpGet request = new
		// HttpGet("https://certs.cac.washington.edu/CAtest/");
		HttpGet request = new HttpGet("https://www.alipay.com/");
		HttpResponse response = client.execute(request);
		HttpEntity entity = response.getEntity();
		BufferedReader reader = new BufferedReader(new InputStreamReader(entity.getContent()));
		StringBuilder result = new StringBuilder();
		String line = "";
		while ((line = reader.readLine()) != null) {
			result.append(line);
		}
		Log.e("HTTPS TEST", result.toString());
	}

	public class TrustAllManager implements X509TrustManager {

		@Override
		public void checkClientTrusted(X509Certificate[] arg0, String arg1)
				throws CertificateException {
			// TODO Auto-generated method stub

		}

		@Override
		public void checkServerTrusted(X509Certificate[] arg0, String arg1)
				throws CertificateException {
			// TODO Auto-generated method stub

		}

		@Override
		public X509Certificate[] getAcceptedIssuers() {
			// TODO Auto-generated method stub
			return null;
		}
	}

}

package com.example.httpstest;

import java.io.IOException;
import java.lang.reflect.Field;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLException;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocket;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import org.apache.http.conn.scheme.SocketFactory;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.conn.ssl.X509HostnameVerifier;

import android.os.Build;

public class TrustAllSSLSocketFactory extends SSLSocketFactory {
	private javax.net.ssl.SSLSocketFactory factory;
	private static TrustAllSSLSocketFactory instance;

	private TrustAllSSLSocketFactory() throws KeyManagementException, UnrecoverableKeyException,
			NoSuchAlgorithmException, KeyStoreException {
		super(null);

		SSLContext context = SSLContext.getInstance("TLS");
		context.init(null, new TrustManager[] { new TrustAllManager() }, null);
		factory = context.getSocketFactory();
		setHostnameVerifier(new X509HostnameVerifier() {

			@Override
			public void verify(String host, String[] cns, String[] subjectAlts) throws SSLException {
				// TODO Auto-generated method stub

			}

			@Override
			public void verify(String host, X509Certificate cert) throws SSLException {
				// TODO Auto-generated method stub

			}

			@Override
			public void verify(String host, SSLSocket ssl) throws IOException {
				// TODO Auto-generated method stub

			}

			@Override
			public boolean verify(String host, SSLSession session) {
				// TODO Auto-generated method stub
				return true;
			}
		});
	}

	public static SocketFactory getDefault() {
		if (instance == null) {
			try {
				instance = new TrustAllSSLSocketFactory();
			} catch (KeyManagementException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (UnrecoverableKeyException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (NoSuchAlgorithmException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (KeyStoreException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		return instance;
	}

	@Override
	public Socket createSocket() throws IOException {
		return factory.createSocket();
	}

	@Override
	public Socket createSocket(Socket socket, String host, int port, boolean autoClose)
			throws IOException, UnknownHostException {
		if (Build.VERSION.SDK_INT < 11) { // 3.0
			injectHostname(socket, host);
		}

		return factory.createSocket(socket, host, port, autoClose);
	}

	private void injectHostname(Socket socket, String host) {
		try {
			Field field = InetAddress.class.getDeclaredField("hostName");
			field.setAccessible(true);
			field.set(socket.getInetAddress(), host);
		} catch (Exception ignored) {
		}
	}

	public class TrustAllManager implements X509TrustManager {

		@Override
		public void checkClientTrusted(X509Certificate[] arg0, String arg1)
				throws CertificateException {
			// TODO Auto-generated method stub

		}

		@Override
		public void checkServerTrusted(X509Certificate[] arg0, String arg1)
				throws CertificateException {
			// TODO Auto-generated method stub

		}

		@Override
		public X509Certificate[] getAcceptedIssuers() {
			// TODO Auto-generated method stub
			return null;
		}
	}

}

package com.example.httpstest;

import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.Certificate;
import java.security.cert.CertificateFactory;

import org.apache.http.conn.ssl.SSLSocketFactory;

import android.content.Context;

public class TrustCertainHostNameFactory extends SSLSocketFactory {

	private static TrustCertainHostNameFactory mInstance;

	public TrustCertainHostNameFactory(KeyStore truststore) throws NoSuchAlgorithmException,
			KeyManagementException, KeyStoreException, UnrecoverableKeyException {
		super(truststore);
	}

	public static TrustCertainHostNameFactory getDefault(Context context) {
		KeyStore keystore = null;
		try {
			CertificateFactory cf = CertificateFactory.getInstance("X.509");
			InputStream in;
			in = context.getAssets().open("load-der.crt");
			Certificate ca = cf.generateCertificate(in);

			keystore = KeyStore.getInstance(KeyStore.getDefaultType());
			keystore.load(null, null);
			keystore.setCertificateEntry("ca", ca);

			if (null == mInstance) {
				mInstance = new TrustCertainHostNameFactory(keystore);
			}
		} catch (Exception e) {

		}
		return mInstance;
	}

	@Override
	public Socket createSocket() throws IOException {
		return super.createSocket();
	}

	@Override
	public Socket createSocket(Socket socket, String host, int port, boolean autoClose)
			throws IOException, UnknownHostException {
		return super.createSocket(socket, host, port, autoClose);
	}

}

https相關知識補充：

轉至：http://edison0663.iteye.com/blog/996526

為了便於更好的認識和理解 SSL 協議，這裡著重介紹 SSL 協議的握手協議。SSL 協議既用到了公鑰加密技術又用到了對稱加密技術，對稱加密技術雖然比公鑰加密技術的速度快，可是公鑰加密技術提供了更好的身份認證技術。SSL 的握手協議非常有效的讓客戶和伺服器之間完成相互之間的身份認證，其主要過程如下：
　　① 客戶端的瀏覽器向伺服器傳送客戶端 SSL 協議的版本號，加密演算法的種類，產生的隨機數，以及其他伺服器和客戶端之間通訊所需要的各種資訊。
　　② 伺服器向客戶端傳送 SSL 協議的版本號，加密演算法的種類，隨機數以及其他相關資訊，同時伺服器還將向客戶端傳送自己的證書。
　　③ 客戶利用伺服器傳過來的資訊驗證伺服器的合法性，伺服器的合法性包括：證書是否過期，發行伺服器證書的 CA 是否可靠，發行者證書的公鑰能否正確解開伺服器證書的“發行者的數字簽名”，伺服器證書上的域名是否和伺服器的實際域名相匹配。如果合法性驗證沒有通過，通訊將斷開；如果合法性驗證通過，將繼續進行第四步。
　　④ 使用者端隨機產生一個用於後面通訊的“對稱密碼”，然後用伺服器的公鑰（伺服器的公鑰從步驟②中的伺服器的證書中獲得）對其加密，然後將加密後的“預主密碼”傳給伺服器。
　　⑤ 如果伺服器要求客戶的身份認證（在握手過程中為可選），使用者可以建立一個隨機數然後對其進行資料簽名，將這個含有簽名的隨機數和客戶自己的證書以及加密過的“預主密碼”一起傳給伺服器。
　　⑥ 如果伺服器要求客戶的身份認證，伺服器必須檢驗客戶證書和簽名隨機數的合法性，具體的合法性驗證過程包括：客戶的證書使用日期是否有效，為客戶提供證書的 CA 是否可靠，發行 CA 的公鑰能否正確解開客戶證書的發行 CA 的數字簽名，檢查客戶的證書是否在證書廢止列表（CRL）中。檢驗如果沒有通過，通訊立刻中斷；如果驗證通過，伺服器將用自己的私鑰解開加密的“預主密碼”，然後執行一系列步驟來產生主通訊密碼（客戶端也將通過同樣的方法產生相同的主通訊密碼）。
　　⑦ 伺服器和客戶端用相同的主密碼即“通話密碼”，一個對稱金鑰用於 SSL 協議的安全資料通訊的加解密通訊。同時在 SSL 通訊過程中還要完成資料通訊的完整性，防止資料通訊中的任何變化。
　　⑧ 客戶端向伺服器端發出資訊，指明後面的資料通訊將使用的步驟⑦中的主密碼為對稱金鑰，同時通知伺服器客戶端的握手過程結束。
　　⑨ 伺服器向客戶端發出資訊，指明後面的資料通訊將使用的步驟⑦中的主密碼為對稱金鑰，同時通知客戶端伺服器端的握手過程結束。
　　⑩ SSL 的握手部分結束，SSL 安全通道的資料通訊開始，客戶和伺服器開始使用相同的對稱金鑰進行資料通訊，同時進行通訊完整性的檢驗。


　　雙向認證 SSL 協議的具體過程
　　① 瀏覽器傳送一個連線請求給安全伺服器。
　　② 伺服器將自己的證書，以及同證書相關的資訊傳送給客戶瀏覽器。
　　③ 客戶瀏覽器檢查伺服器送過來的證書是否是由自己信賴的 CA 中心所簽發的。如果是，就繼續執行協議；如果不是，客戶瀏覽器就給客戶一個警告訊息：警告客戶這個證書不是可以信賴的，詢問客戶是否需要繼續。
　　④ 接著客戶瀏覽器比較證書裡的訊息，例如域名和公鑰，與伺服器剛剛傳送的相關訊息是否一致，如果是一致的，客戶瀏覽器認可這個伺服器的合法身份。
　　⑤ 伺服器要求客戶傳送客戶自己的證書。收到後，伺服器驗證客戶的證書，如果沒有通過驗證，拒絕連線；如果通過驗證，伺服器獲得使用者的公鑰。
　　⑥ 客戶瀏覽器告訴伺服器自己所能夠支援的通訊對稱密碼方案。
　　⑦ 伺服器從客戶傳送過來的密碼方案中，選擇一種加密程度最高的密碼方案，用客戶的公鑰加過密後通知瀏覽器。
　　⑧ 瀏覽器針對這個密碼方案，選擇一個通話金鑰，接著用伺服器的公鑰加過密後傳送給伺服器。
　　⑨ 伺服器接收到瀏覽器送過來的訊息，用自己的私鑰解密，獲得通話金鑰。
　　⑩ 伺服器、瀏覽器接下來的通訊都是用對稱密碼方案，對稱金鑰是加過密的。
　　上面所述的是雙向認證 SSL 協議的具體通訊過程，這種情況要求伺服器和使用者雙方都有證書。單向認證 SSL 協議不需要客戶擁有 CA 證書，具體的過程相對於上面的步驟，只需將伺服器端驗證客戶證書的過程去掉，以及在協商對稱密碼方案，對稱通話金鑰時，伺服器傳送給客戶的是沒有加過密的（這並不影響 SSL 過程的安全性）密碼方案。 這樣，雙方具體的通訊內容，就是加過密的資料，如果有第三方攻擊，獲得的只是加密的資料，第三方要獲得有用的資訊，就需要對加密的資料進行解密，這時候的安全就依賴於密碼方案的安全。而幸運的是，目前所用的密碼方案，只要通訊金鑰長度足夠的長，就足夠的安全。這也是我們強調要求使用 128 位加密通訊的原因。

     一般web應用都是採用單向認證的，原因很簡單，使用者數目廣泛，且無需做在通訊層做使用者身份驗證，一般都在應用邏輯層來保證使用者的合法登入。

     但如果是企業應用對接，情況就不一樣，可能會要求對client（相對而言）做身份驗證。這時需要做雙向認證。

     用java簡單試了一下如何搭建一個https站點， tomcat 6 https 單向認證，網上google一下，例子很多，這裡就不貼出來了，然後瀏覽器測試。

    

     繼續瀏覽此網站，可以正式訪問。 伺服器搭建，應該是沒問題了。 但是這個警告是怎麼回事？ 還是應該再瞭解一下的。

     這個證書是自己做的，用jdk的工具keytool 很容易可以搞出一個(不懂請google)， 瀏覽器很明顯不信任這個伺服器發過來的證書(公鑰)。 這裡還需要了解一下，瀏覽器是如何信任一個證書的。

     1 瀏覽器 https: 訪問一個網站

     2 網站伺服器會發給瀏覽器 一個證書

     3 瀏覽器驗證證書有效性：

        3.1 證書與訪問域名是否匹配，證書是否還在已經有效期內。

        3.2 證書的路徑。

              如圖：

             
             
              證書是否由 瀏覽器(客戶端) 所信任的機構認證。 如果在，則通過，否則給使用者自己選擇。

              自己折騰的證書沒給第三方認證，肯定彈warn， 於是乎出現了第一個圖。

             
             

    有了以上的基礎知識，網上再找一下，自己寫一個簡單的java程式，要實現，https順利訪問（無warn）

    easy， 把這個證書設定為自己信任的就ok.

    通過jdk的keytool 產生對應證書，並匯入到truststore，生成一個檔案(該檔案儲存了信任的證書)。在java程式中指定truststore對應的檔案。

Java程式碼  收藏程式碼
  1. publicstaticvoid main(String[] args) throws Exception {  
  2.         System.setProperty("javax.net.ssl.trustStore", "C:/Java/Tomcat/conf/client.truststore" );  
  3.         new testhttpspostdata().testIt();  
  4.     }  
  5.     privatevoid testIt() {  
  6.         String postdata="data=testpostdata";  
  7.         String https_url = "https://localhost:8443/examples/jsp/getpost.jsp";  
  8.         URL url;  
  9.         try {  
  10.             url = new URL(https_url);  
  11.             HttpsURLConnection con = (HttpsURLConnection) url.openConnection();  
  12.             System.out.println("ready post data");  
  13.             con.setDoOutput(true);  
  14.             con.setRequestMethod("POST");  
  15.             con.getOutputStream().write(postdata.getBytes());  
  16.             con.getOutputStream().flush();  
  17.             con.getOutputStream().close();  
  18.             // dumpl all cert info
  19.             print_https_cert(con);  
  20.             //
  21.             //System.out.println( con.getLocalPrincipal().toString() );
  22.             System.out.println( con.getPeerPrincipal().toString() );  
  23.             // dump all the content
  24.             print_content(con);                   
  25.             // dump all the content
  26.             print_content(con);  
  27.         } catch (MalformedURLException e) {  
  28.             e.printStackTrace();  
  29.         } catch (IOException e) {  
  30.             e.printStackTrace();  
  31.         }  
  32.     }  

    一個週末，學了一些東西，值得mark一下。

    ps: 有一篇好文章，有助於深入理解。

    http://www.williamlong.info/archives/2058.html


相關推薦

Android Https請求詳解

轉至：http://itindex.net/detail/51666-android-https-demo    Android Https詳細請求全方案實現，包括HttpUrlConnection及HttpClient方式實現指定證書及信任所有的實現，不多說了，以下程

iOS 開發 HTTPS請求詳解

HTTPS HTTPS : Hyper Text Transfer Protocol over Secure Socket Layer,是以安全為目標的HTTP通道,簡單講是HTTP的安全版.即HTTP下加入SSL層,HTTPS的安全基礎是SSL. SSL

Android 網路請求登入後更新頁面實現 Handler+HTTP請求詳解

為了實現登入功能，我們需要一下幾步：1、獲取UI資料，並向伺服器傳送請求2、等待返回資料，解析3、將返回資料更新到UI執行緒中為了完成以上幾步，我根據每步的功能提出自己的解決方法，順便整理出對應的知識供大家參考。Handler眾所周知，Android程式執行會開啟一個UI執行

aNDROID之MEDIapLaYER詳解

iap music media 詳解 list oid aid 5% layer %E8%BD%AC%E8%BD%BD%E4%B8%80%E4%B8%AA%E5%9B%BE%E7%89%87%E5%A4%84%E7%90%86%E5%B7%A5%E5%85%B7%E7%B1

跨越請求詳解

ref 擁有 href 屬於 通過 內部 什麽 json數據 內容 .addd td>div { margin-left: 0 !important } 什麽是跨域？ 協議 域名 端口號有一個不一樣就是跨域 跨域：跨域訪問，簡單來說就是 A 網站的 javas

Android RxJava操作符詳解系列： 變換操作符

urn 原因 轉換 需要 生產 依賴 reat 入門 所有 Rxjava，由於其基於事件流的鏈式調用、邏輯簡潔 & 使用簡單的特點，深受各大 Android開發者的歡迎。Github截圖 如果還不了解 RxJava，請看文章：Android：這是一篇 清晰 &

HTTPS協議詳解(二)：TLS/SSL工作原理

-c 基本 公鑰加密 工作方式 通信 使用 sha2 公開 原理 HTTPS協議的主要功能基本都依賴於TLS/SSL協議，本節分析TLS/SSL協議工作原理。 TLS/SSL的功能實現主要依賴於三類基本算法：散列函數 Hash、對稱加密和非對稱加密，其利用非對稱加密實

HTTPS協議詳解(四)：TLS/SSL握手過程

其它 對數 hello 減少 受保護 改版 text gin 組裝 1、握手與密鑰協商過程 基於RSA握手和密鑰交換的客戶端驗證服務器為示例詳解TLS/SSL握手過程 再看一張手繪時序圖 (1).client_hello 客戶端發起請求，以明文傳輸請求信息，包

HTTPS協議詳解(三)：PKI 體系

客戶 判斷 節點 無法 三方 證書無效 進行 證書 roo 1、RSA身份驗證的隱患 身份驗證和密鑰協商是TLS的基礎功能，要求的前提是合法的服務器掌握著對應的私鑰。但RSA算法無法確保服務器身份的合法性，因為公鑰並不包含服務器的信息，存在安全隱患: 客戶端C和

android:exported 屬性詳解

itl fas 默認 之前 綁定 四大 nbsp ring ins http://blog.csdn.net/watermusicyes/article/details/46460347 昨天在用360掃描應用漏洞時，掃描結果，出來一個android:exported屬性，

jQuery jsonp跨域請求詳解

路徑 下使用 utf 顯示 我們 ole show height json 跨域的安全限制都是對瀏覽器端來說的，服務器端是不存在跨域安全限制的。 瀏覽器的同源策略限制從一個源加載的文檔或腳本與來自另一個源的資源進行交互。 如果協議，端口和主機對於兩個頁面是相同的，則兩個頁面

Charles抓取http請求詳解

linu 代理ip 端口號 容易 execute gpo 情況 HA nts 使用過Charles進行抓包，但一直也沒有總結過，今天講講Charles如何進行抓包，修改請求，修改返回值。 一、Charles介紹 Charles是一款跨平臺的抓包工具，windows，ma

爬蟲學習筆記（二）http請求詳解

not found 上傳 取數 found 語法錯誤 爬蟲學習 訪問 request 永久 上篇博客裏面寫了，爬蟲就是發http請求（瀏覽器裏面打開發送的都是http請求），然後獲取到response，咱們再從response裏面找到想要的數據，存儲到本地。 咱們本章就來說

HTTP與HTTPS要點詳解

http qa OSI（Open System Interconnect）開放式系統互聯模型 OSI參考模型：應用層、表示層、會話層、傳輸層、網絡層、數據鏈路層、物理層 應用層：應用層為應用程序提供訪問網絡服務的接口，為用戶直接提供各種網絡服務。常見應用層的網絡服務協議有：HTTP，HTTPS，FT

Android SDK Manager詳解

eba 調試 測試工具 使用說明 服務 能力 bar 部分 以及 Android基礎知識——Android SDK Manager詳解 做Android開發時，免不了使用Android SDK Manager，安裝需要的sdk版本、buildTool

跨域發送HTTP請求詳解

ext open author read stat 請求 buffere keyset post ------------吾亦無他,唯手熟爾，謙卑若愚，好學若饑------------- 本篇博客講述幾種跨域發HTTP請求的幾種方

IOS和Android系統區別詳解

清理 span back 一個 style 沙盒 安裝 最大值 完全 IOS系統（非開源，不可擴展） iphone沙盒機制解釋：應用程序位於文件系統的嚴格限制部分，程序不能直接訪問其他應用程序。 1、iOS的編程語言Objective-C 2、IOS采用的是沙盒運行

Android Volley框架詳解

注：文章出自http://blog.csdn.net/guolin_blog/article/details/17482095，有興趣可以先去閱讀。 Volley簡介 對於Android系統網路通訊，我們知道目前用的最普遍的就是HttpClient和HttpURLConnection，但是H

Android快取機制詳解之硬碟快取DiskLruCache

簡介 防止多圖OOM的核心解決思路就是使用LruCache技術。但LruCache只是管理了記憶體中圖片的儲存與釋放，如果圖片從記憶體中被移除的話，那麼又需要從網路上重新載入一次圖片，這顯然非常耗時。對此，Google又提供了一套硬碟快取的解決方案：DiskLruCache(非Google官方編

Android pm 命令詳解

一、pm命令介紹與包名資訊查詢 1.pm命令介紹 pm工具為包管理（package manager）的簡稱 可以使用pm工具來執行應用的安裝和查詢應用的資訊、系統許可權、控制應用 pm工具是Android開發與測試過程中必不可少的工具，shell命令格式如下： pm <