实际上，在一些金融，银行，电子支付方面的应用程序中，JavaSecurity使用的地方非常多。

注意，Java Security包含的内容非常多，而本文将重点关注Java SecurityAPI与其使用方法方面的知识。对Java Security其他细节感兴趣的同学可在阅读完本文后，再阅读参考文献[1]。

注意，可互操作性是指Provider A实现的MD5值，能被Provider B识别。显然，这个要求是合理的。

BTW，个人感觉Java类定义非常多，而且有些类和它们所在包的关系似乎有些混乱。

static {

   boolean loaded = false;

   try {

       //从资源文件里搜索是否有security.properties定义，Android平台是没有这个文件的

      InputStreamconfigStream =

         Security.class.getResourceAsStream("security.properties");

       InputStream input = newBufferedInputStream(configStream);

       secprops.load(input);

       loaded = true;

       configStream.close();

        }......

     if (!loaded) {//注册默认的Provider

        registerDefaultProviders();

     }

      ......

    }

   private static void registerDefaultProviders() {

     /*

    JCE对Provider的管理非常简单，就是将Provider类名和对应的优先级存在属性列表里

    比如下面的：OpenSSLProvider，它对应的优先级是1.

     优先级是什么意思呢？前面说过，不同的Provider可以实现同一个功能集合，比如都实现

     MessageDigestSpi。那么用户在创建MessageDigest的实例时，如果没有指明Provider名，

     JCE默认从第一个（按照优先级，由1到n）Provider开始搜索，直到找到第一个实现了

     MessageDigestSpi的Provider（比如Provider X）为止。然后，MessageDigest的实例

      就会由Provider X创建。图2展示了一个例子

    */

     secprops.put("security.provider.1",

           "com.android.org.conscrypt.OpenSSLProvider");

     secprops.put("security.provider.2",

            "org.apache.harmony.security.provider.cert.DRLCertFactory");

    secprops.put("security.provider.3",

       "com.android.org.bouncycastle.jce.provider.BouncyCastleProvider");

    secprops.put("security.provider.4",

        "org.apache.harmony.security.provider.crypto.CryptoProvider");

      //和JSSE有关

      secprops.put("security.provider.5",

        "com.android.org.conscrypt.JSSEProvider");

 }

注意，图2中的SHA-1/256和MD5都是MessageDigest的一种算法，本文后面会介绍它们。

public static void main(String[] args) {

   ......

  Security.addProvider(new AndroidKeyStoreProvider());

  ......

}

public class AndroidKeyStoreProvider extends Provider {

  public static final StringPROVIDER_NAME = "AndroidKeyStore";

  publicAndroidKeyStoreProvider() {

    super(PROVIDER_NAME, 1.0,"Android KeyStore security provider");

    put("KeyStore." + AndroidKeyStore.NAME,

          AndroidKeyStore.class.getName());

    put("KeyPairGenerator.RSA",AndroidKeyPairGenerator.class.getName());

  }

}

void testProvider(){

   e(TAG, "***Begin TestProviders***");

   //获取系统所有注册的Provider

   Provider[] providers = Security.getProviders();

   for(Providerprovider:providers){

      //输出Provider名

      e(TAG,"Provider:" + provider+" info:");

      //前面说了，provider其实就是包含了一组key/value值。下面将打印每个Provider的

      //这些信息

      Set<Entry<Object,Object>>allKeyAndValues = provider.entrySet();

     Iterator<Entry<Object, Object>> iterator =allKeyAndValues.iterator();

      while(iterator.hasNext()){

        Entry<Object,Object> oneKeyAndValue =iterator.next();

        Object key = oneKeyAndValue.getKey();

        Object value =oneKeyAndValue.getValue();

        //打印Key的类型和值

       e(TAG,"===>" + "Keytype="+key.getClass().getSimpleName()+"

                           Key="+key.toString());

        //打印Value的类型和值

      e(TAG,"===>" + "Valuetype="+value.getClass().getSimpleName()+"

                           Value="+value.toString());

        }

     }

     e(TAG, "***End TestProviders***\n\n");

 }

{//对称key即SecretKey创建和导入

     //假设双方约定使用DES算法来生成对称密钥

     e(TAG,"==>secret key: generated it using DES");

     KeyGeneratorkeyGenerator = KeyGenerator.getInstance("DES");

     //设置密钥长度。注意，每种算法所支持的密钥长度都是不一样的。DES只支持64位长度密钥

     //（也许是算法本身的限制，或者是不同Provider的限制，或者是政府管制的限制）

     keyGenerator.init(64);

     //生成SecretKey对象，即创建一个对称密钥

     SecretKey secretKey = keyGenerator.generateKey();

     //获取二进制的书面表达

     byte[] keyData =secretKey.getEncoded();

     //日常使用时，一般会把上面的二进制数组通过Base64编码转换成字符串，然后发给使用者

     String keyInBase64 =Base64.encodeToString(keyData,Base64.DEFAULT);

     e(TAG,"==>secret key: encrpted data ="+ bytesToHexString(keyData));

     e(TAG,"==>secrety key:base64code=" + keyInBase64);

     e(TAG,"==>secrety key:alg=" + secretKey.getAlgorithm());

    //假设对方收到了base64编码后的密钥，首先要得到其二进制表达式

   byte[] receivedKeyData =Base64.decode(keyInBase64,Base64.DEFAULT);

   //用二进制数组构造KeySpec对象。对称key使用SecretKeySpec类

   SecretKeySpec keySpec =new SecretKeySpec(receivedKeyData,”DES”);

   //创建对称Key导入用的SecretKeyFactory

   SecretKeyFactorysecretKeyFactory = SecretKeyFactory.getInstance(”DES”);

   //根据KeySpec还原Key对象，即把key的书面表达式转换成了Key对象

   SecretKey receivedKeyObject = secretKeyFactory.generateSecret(keySpec);

   byte[]encodedReceivedKeyData = receivedKeyObject.getEncoded();

   e(TAG,"==>secret key: received key encoded data ="

                                +bytesToHexString(encodedReceivedKeyData));

注意，本文会讨论太多算法相关的内容。

{//public/private key test

  e(TAG, "==>keypair: generated it using RSA");

  //使用RSA算法创建KeyPair

  KeyPairGeneratorkeyPairGenerator = KeyPairGenerator.getInstance("RSA");

  //设置密钥长度

  keyPairGenerator.initialize(1024);

  //创建非对称密钥对，即KeyPair对象

  KeyPair keyPair =keyPairGenerator.generateKeyPair();

  //获取密钥对中的公钥和私钥对象

  PublicKey publicKey =keyPair.getPublic();

  PrivateKey privateKey =keyPair.getPrivate();

  //打印base64编码后的公钥和私钥值

  e(TAG,"==>publickey:"+bytesToHexString(publicKey.getEncoded()));

  e(TAG, "==>privatekey:"+bytesToHexString(privateKey.getEncoded()));

  /*

   现在要考虑如何把公钥传递给使用者。虽然可以和对称密钥一样，把二进制数组取出来，但是

   对于非对称密钥来说，JCE不支持直接通过二进制数组来还原KeySpec（可能是算法不支持）。

   那该怎么办呢？前面曾说了，除了直接还原二进制数组外，还可以通过具体算法的参数来还原

   RSA非对称密钥就得使用这种方法：

   1 首先我们要获取RSA公钥的KeySpec。

  */

  //获取RSAPublicKeySpec的class对象

  Class spec = Class.forName("java.security.spec.RSAPublicKeySpec");

   //创建KeyFactory，并获取RSAPublicKeySpec

  KeyFactory keyFactory = KeyFactory.getInstance("RSA");

  RSAPublicKeySpecrsaPublicKeySpec =

            (RSAPublicKeySpec)keyFactory.getKeySpec(publicKey, spec);

  //对RSA算法来说，只要获取modulus和exponent这两个RSA算法特定的参数就可以了

  BigInteger modulus =rsaPublicKeySpec.getModulus();

  BigInteger exponent =rsaPublicKeySpec.getPublicExponent();

  //把这两个参数转换成Base64编码，然后发送给对方

  e(TAG,"==>rsa pubkey spec:modulus="+

             bytesToHexString(modulus.toByteArray()));

  e(TAG,"==>rsa pubkey spec:exponent="+

             bytesToHexString(exponent.toByteArray()));

  //假设接收方收到了代表modulus和exponent的base64字符串并得到了它们的二进制表达式

  byte[] modulusByteArry =modulus.toByteArray();

  byte[] exponentByteArry =exponent.toByteArray();

  //由接收到的参数构造RSAPublicKeySpec对象

  RSAPublicKeySpecreceivedKeySpec = new RSAPublicKeySpec(

                    newBigInteger(modulusByteArry),

                    new BigInteger(exponentByteArry));

  //根据RSAPublicKeySpec对象获取公钥对象

  KeyFactoryreceivedKeyFactory = keyFactory.getInstance("RSA");

  PublicKey receivedPublicKey =

                 receivedKeyFactory.generatePublic(receivedKeySpec);

  e(TAG, "==>received pubkey:"+

                   bytesToHexString(receivedPublicKey.getEncoded()));

}

不理解上述内容的同学，请把实例代码再仔细看看！

-----BEGIN CERTIFICATE-----

MIID5TCCAs2gAwIBAgIEOeSXnjANBgkqhkiG9w0BAQUFADCBgjELMAkGA1UEBhMC

VVMxFDASBgNVBAoTC1dlbGxzIEZhcmdvMSwwKgYDVQQLEyNXZWxscyBGYXJnbyBD

ZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTEvMC0GA1UEAxMmV2VsbHMgRmFyZ28gUm9v

dCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkwHhcNMDAxMDExMTY0MTI4WhcNMjEwMTE0

MTY0MTI4WjCBgjELMAkGA1UEBhMCVVMxFDASBgNVBAoTC1dlbGxzIEZhcmdvMSww

KgYDVQQLEyNXZWxscyBGYXJnbyBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTEvMC0G

A1UEAxMmV2VsbHMgRmFyZ28gUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkwggEi

MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDVqDM7Jvk0/82bfuUER84A4n13

5zHCLielTWi5MbqNQ1mXx3Oqfz1cQJ4F5aHiidlMuD+b+Qy0yGIZLEWukR5zcUHE

SxP9cMIlrCL1dQu3U+SlK93OvRw6esP3E48mVJwWa2uv+9iWsWCaSOAlIiR5NM4O

JgALTqv9i86C1y8IcGjBqAr5dE8Hq6T54oN+J3N0Prj5OEL8pahbSCOz6+MlsoCu

ltQKnMJ4msZoGK43YjdeUXWoWGPAUe5AeH6orxqg4bB4nVCMe+ez/I4jsNtlAHCE

AQgAFG5Uhpq6zPk3EPbg3oQtnaSFN9OH4xXQwReQfhkhahKpdv0SAulPIV4XAgMB

AAGjYTBfMA8GA1UdEwEB/wQFMAMBAf8wTAYDVR0gBEUwQzBBBgtghkgBhvt7hwcB

CzAyMDAGCCsGAQUFBwIBFiRodHRwOi8vd3d3LndlbGxzZmFyZ28uY29tL2NlcnRw

b2xpY3kwDQYJKoZIhvcNAQEFBQADggEBANIn3ZwKdyu7IvICtUpKkfnRLb7kuxpo

7w6kAOnu5+/u9vnldKTC2FJYxHT7zmu1Oyl5GFrvm+0fazbuSCUlFLZWohDo7qd/

0D+j0MNdJu4HzMPBJCGHHt8qElNvQRbn7a6U+oxy+hNH8Dx+rn0ROhPs7fpvcmR7

nX1/Jv16+yWt6j4pf0zjAFcysLPp7VMX2YuyFA4w6OXVE8Zkr8QA1dhYJPz1j+zx

x32l2w8n0cbyQIjmH/ZhqPRCyLk306m+LFZ4wnKbWV01QIroTmMatukgalHizqSQ

33ZwmVxwQ023tqcZZE6St8WRPH9IFmV7Fv3L/PvZ1dZPIWU7Sn9Ho/s=

-----END CERTIFICATE-----

Certificate:  #下面是证书的明文内容

    Data:

        Version: 3 (0x2)

        Serial Number:971282334 (0x39e4979e)

    Signature Algorithm: sha1WithRSAEncryption

        Issuer: C=US, O=Wells Fargo, OU=Wells Fargo CertificationAuthority, CN=Wells Fargo Root Certificate Authority

        Validity

            Not Before: Oct11 16:41:28 2000 GMT

            Not After : Jan14 16:41:28 2021 GMT

        Subject: C=US, O=Wells Fargo, OU=Wells Fargo CertificationAuthority, CN=Wells Fargo Root Certificate Authority

        Subject Public Key Info:#Public Key的KeySpec表达式

            Public Key Algorithm: rsaEncryption  #PublicKey的算法

                Public-Key: (2048 bit)

                Modulus:

                   00:d5:a8:33:3b:26:f9:34:ff:cd:9b:7e:e5:04:47:

                   ce:00:e2:7d:77:e7:31:c2:2e:27:a5:4d:68:b9:31:

                   ba:8d:43:59:97:c7:73:aa:7f:3d:5c:40:9e:05:e5:

                    a1:e2:89:d9:4c:b8:3f:9b:f9:0c:b4:c8:62:19:2c:

                   45:ae:91:1e:73:71:41:c4:4b:13:fd:70:c2:25:ac:

                   22:f5:75:0b:b7:53:e4:a5:2b:dd:ce:bd:1c:3a:7a:

                   c3:f7:13:8f:26:54:9c:16:6b:6b:af:fb:d8:96:b1:

                    60:9a:48:e0:25:22:24:79:34:ce:0e:26:00:0b:4e:

                   ab:fd:8b:ce:82:d7:2f:08:70:68:c1:a8:0a:f9:74:

                   4f:07:ab:a4:f9:e2:83:7e:27:73:74:3e:b8:f9:38:

                   42:fc:a5:a8:5b:48:23:b3:eb:e3:25:b2:80:ae:96:

                    d4:0a:9c:c2:78:9a:c6:68:18:ae:37:62:37:5e:51:

                   75:a8:58:63:c0:51:ee:40:78:7e:a8:af:1a:a0:e1:

                   b0:78:9d:50:8c:7b:e7:b3:fc:8e:23:b0:db:65:00:

                   70:84:01:08:00:14:6e:54:86:9a:ba:cc:f9:37:10:

                   f6:e0:de:84:2d:9d:a4:85:37:d3:87:e3:15:d0:c1:

                   17:90:7e:19:21:6a:12:a9:76:fd:12:02:e9:4f:21:

                    5e:17

                Exponent: 65537 (0x10001)

        X509v3 extensions:

            X509v3 BasicConstraints: critical

                CA:TRUE

            X509v3Certificate Policies:

                Policy:2.16.840.1.114171.903.1.11

                  CPS:http://www.wellsfargo.com/certpolicy

    Signature Algorithm: sha1WithRSAEncryption  #数字签名，以后再讲

        d2:27:dd:9c:0a:77:2b:bb:22:f2:02:b5:4a:4a:91:f9:d1:2d:

        be:e4:bb:1a:68:ef:0e:a4:00:e9:ee:e7:ef:ee:f6:f9:e5:74:

        a4:c2:d8:52:58:c4:74:fb:ce:6b:b5:3b:29:79:18:5a:ef:9b:

        ed:1f:6b:36:ee:48:25:25:14:b6:56:a2:10:e8:ee:a7:7f:d0:

        3f:a3:d0:c3:5d:26:ee:07:cc:c3:c1:24:21:87:1e:df:2a:12:

        53:6f:41:16:e7:ed:ae:94:fa:8c:72:fa:13:47:f0:3c:7e:ae:

        7d:11:3a:13:ec:ed:fa:6f:72:64:7b:9d:7d:7f:26:fd:7a:fb:

        25:ad:ea:3e:29:7f:4c:e3:00:57:32:b0:b3:e9:ed:53:17:d9:

        8b:b2:14:0e:30:e8:e5:d5:13:c6:64:af:c4:00:d5:d8:58:24:

        fc:f5:8f:ec:f1:c7:7d:a5:db:0f:27:d1:c6:f2:40:88:e6:1f:

        f6:61:a8:f4:42:c8:b9:37:d3:a9:be:2c:56:78:c2:72:9b:59:

        5d:35:40:8a:e8:4e:63:1a:b6:e9:20:6a:51:e2:ce:a4:90:df:

        76:70:99:5c:70:43:4d:b7:b6:a7:19:64:4e:92:b7:c5:91:3c:

        7f:48:16:65:7b:16:fd:cb:fc:fb:d9:d5:d6:4f:21:65:3b:4a:

         7f:47:a3:fb

SHA1 Fingerprint=93:E6:AB:22:03:03:B5:23:28:DC:DA:56:9E:BA:E4:D1:D1:CC:FB:65

特别注意：

1  证书文件相关的规范特别多，读者感兴趣的话可阅读参考文献[2][3][4][5]。

2  X509证书规范本身是不包含私钥信息的。但是某些证书文件却可以，而且某些证书文件能包含一条证书链上所有证书的信息。

注意：后面介绍KeyStore的时候，我们还会继续讨论证书文件的问题。

void testCertificate() {

    e(TAG, "***Begintest Certificates***");

    try {

      //在res/assets目录下放了一个名为“my-root-cert.pem”的证书文件

      AssetManagerassetManager = this.getAssets();

      InputStream inputStream= assetManager.open("my-root-cert.pem");

      //导入证书得需要使用CertificateFactory，

      CertificateFactorycertificateFactory =

                      CertificateFactory.getInstance("X.509");

      /*

      从my-root-cert.pem中提取X509证书信息，并保存在X509Certificate对象中

      注意，如果一个证书文件包含多个证书（证书链的情况），generateCertificate将只返回

      第一个证书

      调用generateCertificates函数可以返回一个证书数组，

      */

      X509CertificatemyX509Cer =

          (X509Certificate)certificateFactory

              .generateCertificate(inputStream);

     //打印X509证书的一些信息。DN是Distinguished Name。DN通过设定很多项（类似于地址

     //一样，比如包括国家、省份、街道等信息）来唯一标示一个持有东西（比如发布此证书的机构等）

      e(TAG, "==>SubjecteDN:" + myX509Cer.getSubjectDN().getName());

      e(TAG,"==>Issuer DN:" + myX509Cer.getIssuerDN().getName());

      e(TAG,"==>Public Key:"

          +bytesToHexString(myX509Cer.getPublicKey().getEncoded()));

      inputStream.close();

    } ......

    }

    e(TAG, "***End testCertificates***");

  }

 void testKeyStore() {

    e(TAG, "***Begintest KeyStore***");

    try {

      AssetManagerassetManager = this.getAssets();

      //assets目录下放了一个pkcs12的证书文件

      InputStream inputStream= assetManager.open("test-keychain.p12");

     //创建KeyStore实例

      KeyStore myKeyStore = KeyStore.getInstance("PKCS12");

     /*

      KeyStore实例默认是不关联任何文件的，所以需要用keystore文件来初始化它

      load函数：第一个参数代表keystore文件的InputStream

      第二个参数是keystore文件的密码。和保险箱类似，KeyStore文件本身是用密码保护的

      一些KeyStore文件的默认密码叫“changeit”。

      如果不传密码的话，KeyStore初始化后，只能取出公开的证书信息。注意，不同KeyStore

      实现方法对此处理情况不完全相同。

     */

      myKeyStore.load(inputStream,"changeit".toCharArray());

      //就本例而言，KeyStore对象所代表KeyStore实际上就是test-keychain.p12文件

      //获取KeyStore中定义的别名

     Enumeration<String> aliasEnum = myKeyStore.aliases();

      while(aliasEnum.hasMoreElements()) {

        String alias =aliasEnum.nextElement();

        //判断别名对应的项是CE还是KE。注意,CE对应的是可信任CA的根证书。

        boolean bCE =myKeyStore.isCertificateEntry(alias);

        boolean bKE =myKeyStore.isKeyEntry(alias);

       //本例中，存储的是KE信息

       e(TAG,"==>Alias:"+alias + " is CE:"+bCE + "is KE:"+bKE);

        //从KeyStore中取出别名对应的证书链

        Certificate[]certificates = myKeyStore.getCertificateChain(alias);

       //打印证书链的信息

        for (Certificate cert: certificates) {

          X509CertificatemyCert = (X509Certificate) cert;

          e(TAG,"==>I am a certificate:"  );

          e(TAG,"==>Subjecte DN:" + myCert.getSubjectDN().getName());

          e(TAG,"==>Issuer DN:" + myCert.getIssuerDN().getName());

          e(TAG,"==>Public Key:"+ bytesToHexString(myCert.getPublicKey()

                 .getEncoded()));

        }

        //取出别名对应的Key信息，一般取出的是私钥或者SecretKey。

       // 注意，不同的别名可能对应不同的Entry。本例中，KE和CE都使用一样的别名

        Key myKey =myKeyStore.getKey(alias,"changit".toCharArray());

        if(myKey instanceof PrivateKey){

          e(TAG,"==>I am a private key:" +

                             bytesToHexString(myKey.getEncoded()));

        } else if(myKeyinstanceof SecretKey){

          if(myKey instanceofPrivateKey){

            e(TAG,"==>I am a secret key:" +

                             bytesToHexString(myKey.getEncoded()));

          }

        }

      }

    } ......

e(TAG, "***Endtest KeyStore***");

注意，关于AndroidKeyStore的使用方法，请阅读参考资料[8].

  void testMessageDigest(){

    e(TAG, "***Begintest MessageDigest***");

    try {

      //创建一个MD计算器，类型是MessageDigest，计算方法有MD5，SHA等。

      MessageDigest messageDigest = MessageDigest.getInstance("MD5");

      //消息数据

      String  data = "This is a message:)";

      e(TAG,"==>Message is:" + data);

      //计算MD值时，只要不断调用MessageDigest的update函数即可，其参数是待计算的数据

      messageDigest.update(data.getBytes());

      //获取摘要信息，也是用二进制数组表达

      byte[] mdValue =messageDigest.digest();

      e(TAG,"==>MDValue is:"+bytesToHexString(mdValue));

      //重置MessageDigest对象，这样就能重复使用它

      messageDigest.reset();

      AssetManagerassetManager = this.getAssets();

      InputStream inputStream= assetManager.open("test-keychain.p12");

      //这次我们要计算一个文件的MD值

      e(TAG,"==>Message is a file:" + "test-keychain.p12");

      //创建一个DigestInputStream对象，需要将它和一个MD对象绑定

      DigestInputStreamdigestInputStream = new DigestInputStream(inputStream,

                         messageDigest);

      byte[] buffer = newbyte[1024];

      //读取文件的数据，DigestInputStream内部会调用MD对象计算MD值

     while(digestInputStream.read(buffer)> 0){

      }

      //文件读完了，MD也计算出来了

      mdValue =messageDigest.digest();

      e(TAG,"==>MDValue is:"+bytesToHexString(mdValue));

     digestInputStream.close();

      inputStream.close();

      /*

      MD值其实并不能真正解决数据被篡改的问题。因为作假者可以搞一个假网站，然后提供

      假数据和根据假数据得到的MD值。这样，下载者下载到假数据，计算的MD值和假网站提供的

      MD数据确实一样，但是这份数据是被篡改过了的。

      解决这个问题的一种方法是：计算MD的时候，输入除了消息数据外，还有一个密钥。

      由于作假者没有密钥信息，所以它在假网站上上提供的MD肯定会和数据下载者根据密钥+假

      数据得到的MD值不一样。

      这种方法得到的MD叫Message Authentication Code，简称MAC

     */

      e(TAG,"==>Calcualte MAC");

      //创建MAC计算对象，其常用算法有“HmacSHA1”和“HmacMD5”。其中SHA1和MD5是

      //计算消息摘要的算法，Hmac是生成MAC码的算法

      Mac myMac = Mac.getInstance("HmacSHA1");

      //计算my-root-cert.pem的MAC值

      inputStream =assetManager.open("my-root-cert.pem");

      //创建一个SecretKey对象

      KeyGeneratorkeyGenerator = KeyGenerator.getInstance("DES");

      keyGenerator.init(64);

      SecretKey key =keyGenerator.generateKey();

      //用密钥初始化MAC对象

      myMac.init(key);

      buffer = newbyte[1024];

      int nread = 0;

      //计算文件的MAC

      while ((nread =inputStream.read(buffer)) > 0) {

        myMac.update(buffer, 0, nread);

      }

      //得到最后的MAC值

      byte[] macValue =myMac.doFinal();

      e(TAG, "==>MACValue is:" + bytesToHexString(macValue));

      inputStream.close();

    } ......

    e(TAG, "***End testMessageDigest***");

  }

特别注意：

1  从理论上说，签名不一定是针对摘要的，也可以对原始数据计算签名。但是由于签名所涉及的计算量比较大，所以往往我们只对数据摘要进行签名。在JCE中，签名都针对MD而言。

2  为了防止证书被篡改，我们在证书里边往往也会包含签名信息。证书A的签名信息其实是上一级的CA（假设为B）利用B的私钥对证书A进行签名操作，然后把这个签名值放到证书A里边。如果要验证证书A是否被篡改的话，我们需要CA B的证书B，因为证书B会提供CA B的公钥。明白了吧？，所以证书校验会是一个链式的情况。当最后校验到根CA的时候，由于根CA是利用自己的私钥对自己的证书进行签名，然后把自己的公钥，签名放到根证书里边。所以这个链最后就会终止在根证书这了....

   void testSignature(){

    e(TAG, "***Begintest Signature***");

    try {

      AssetManagerassetManager = this.getAssets();

       //本例中，私钥和公钥信息都放在test-keychain.p12文件中，我们先从里边提取它们

      InputStream inputStream= assetManager.open("test-keychain.p12");

      KeyStore myKeyStore =KeyStore.getInstance("PKCS12");

     myKeyStore.load(inputStream, "changeit".toCharArray());

      String alias = "MyKey Chain";

      Certificate cert =myKeyStore.getCertificate(alias);

      PublicKey publicKey =cert.getPublicKey();

      PrivateKey privateKey =(PrivateKey)myKeyStore.getKey(alias,

                              "changit".toCharArray());

      inputStream.close();

      //对my-root-cert.pem进行签名

      e(TAG, "==>start sign of file : my-root-cert.pem");

       //MD5表示MD的计算方法，RSA表示加密的计算方法。常用的签名算法还有“SHA1withRSA”

       //“SHA256withRSA”

      Signature signature =Signature.getInstance("MD5withRSA");

      //计算签名时，需要调用initSign，并传入一个私钥

      signature.initSign(privateKey);

      byte[] data = newbyte[1024];

      int nread = 0;

      InputStreaminputStreamToBeSigned = assetManager.open(

                             "my-root-cert.pem");

      while((nread =inputStreamToBeSigned.read(data))>0){

        signature.update(data, 0, nread);//读取文件并计算签名

      }

      //得到签名值

      byte[] sig = signature.sign();

      e(TAG, "==>Signed Signautre:" + bytesToHexStaring(sig));

      signature = null;

     inputStreamToBeSigned.close();

       //校验签名

      e(TAG, "==>start verfiy of file : my-root-cert.pem");

      inputStreamToBeSigned =assetManager.open("my-root-cert.pem");

      signature = Signature.getInstance("MD5withRSA");

      //校验时候需要调用initVerify，并传入公钥对象

      signature.initVerify(publicKey);

      data = new byte[1024];

      nread = 0;

      while((nread =inputStreamToBeSigned.read(data))>0){

        signature.update(data, 0, nread);//读取文件并计算校验值

      }

      //比较签名和内部计算得到的检验结果，如果一致，则返回true

      boolean isSigCorrect =signature.verify(sig);

      e(TAG, "==>IsSignature Correct :" + isSigCorrect);

     inputStreamToBeSigned.close();

    } catch (Exception e) {

      e(TAG," " +e.getMessage());

    }

    e(TAG, "***End testSignature***");

  }

具体这些算法、模式是干什么的，我个人觉得反倒不必要关注这么细，这毕竟是数学家的事情，不是么？

  void testCipher(){

try {

      //加解密要用到Key，本例使用SecretKey进行对称加解密运算

      KeyGenerator  keyGenerator = KeyGenerator.getInstance("DES");

      SecretKey key =keyGenerator.generateKey();

      //待加密的数据是一个字符串

      String data ="This is our data";

      e(TAG, "==>RawData : " + data);

      e(TAG, "==>RawData in hex: " + bytesToHexString(data.getBytes()));

     //创建一个Cipher对象，注意这里用的算法需要和Key的算法匹配

      Cipher encryptor = Cipher.getInstance("DES/CBC/PKCS5Padding");

      //设置Cipher对象为加密模式，同时把Key传进去

      encryptor.init(Cipher.ENCRYPT_MODE, key);

      //开始加密，注意update的返回值为输入buffer加密后得到的数据，需要保存起来

      byte[] encryptedData =encryptor.update(data.getBytes());

      //调用doFinal以表示加密结束。doFinal有可能也返回一串数据，也有可能返回null。因为

      byte[] encryptedData1 =encryptor.doFinal();

     //finalencrpytedData为最终加密后得到的数据，它是update和doFinal的返回数据的

     //集合

      byte[]finalEncrpytedData =

             concateTwoBuffers(encryptedData,encryptedData1);

      e(TAG, "==>EncryptedData : " + bytesToHexString(finalEncrpytedData));

      //获取本次加密时使用的初始向量。初始向量属于加密算法使用的一组参数。使用不同的加密算法

     //时，需要保存的参数不完全相同。Cipher会提供相应的API

      byte[] iv = encryptor.getIV();

      e(TAG,"==>Initial Vector of Encryptor: " + bytesToHexString(iv));

      /*

         解密：解密时，需要把加密后的数据，密钥和初始向量发给解密方。

         再次强调，不同算法加解密时，可能需要加密对象当初加密时使用的其他算法参数

*/

      Cipher decryptor =Cipher.getInstance("DES/CBC/PKCS5Padding");

      IvParameterSpecivParameterSpec = new IvParameterSpec(iv);

      //设置Cipher为解密工作模式，需要把Key和算法参数传进去

      decryptor.init(Cipher.DECRYPT_MODE, key,ivParameterSpec);

      //解密数据，也是调用update和doFinal

      byte[] decryptedData =decryptor.update(finalEncrpytedData);

      byte[] decryptedData1 =decryptor.doFinal();

      //将数据组合到一起，得到最终的数据

      byte[]finaldecrpytedData =

               concateTwoBuffers(decryptedData,decryptedData1);

      e(TAG,"==>Decrypted Data  in hex:" +

                  bytesToHexString(finaldecrpytedData));

      e(TAG,"==>Decrypted Data  : " + newString(finaldecrpytedData));

    } ......

    e(TAG, "***End testCipher***");

  }

注意：

为什么不是所有场景都要求服务器验证客户端呢（即客户端把自己的证书发给服务器）呢？这是因为在C/S架构下，一个服务器要服务很多客户。每个客户都提供证书给服务器，服务器得存着啊。而且，假如客户端更新了证书，那服务器怎么处理呢？反正有很多现实问题不好处理，所有就没有强制要求客户端发证书给服务器了。

  private void startServer(){

    //Server单独跑在一个线程里

    Thread serverThread = newThread(new Runnable() {

      @Override

      public void run() {

        try {

          e(TAG,"==>prepare keystore for server:");

          ServerSocketFactoryserverSocketFactory = null;

         //下面这段代码在testKeyStore的时候介绍过。本例中，私钥，证书文件其实都存在

         //test-keychain.p12文件里

          AssetManager assetManager= DemoActivity.this.getAssets();

          InputStreamkeyInputStream = assetManager.open("test-keychain.p12");

          KeyStoreserverKeyStore = KeyStore.getInstance("PKCS12");

          //初始化KeyStore

          serverKeyStore.load(keyInputStream,"changeit".toCharArray());

         keyInputStream.close();

          //我们要用这个keystore来初始化一个SSLContext对象。SSLContext使得我们

          //能够控制SSLSocket和KeyStore，TrustStore相关的部分，而不是使用系统默认值

          SSLContextsslContext = SSLContext.getInstance("TLS");

          KeyManagerFactorykeyManagerFactory = KeyManagerFactory

              .getInstance(KeyManagerFactory.getDefaultAlgorithm());

         //先用KeyStore对象初始化KeyManagerFactory

          keyManagerFactory.init(serverKeyStore,"changeit".toCharArray());

          /*

           然后初始化SSLContext，init函数有三个参数，第一个是KeyManager数组，

           第二个是TrustManager数组，第三个是SecureRandom，用来创建随机数的

            显然，第一个参数用来创建服务端Socket的，而第二个参数用于创建客户端Socket

          */

          sslContext.init(keyManagerFactory.getKeyManagers(), null,null);

          e(TAG,"==>start server:");

          //得到服务端socket创建工厂对象

          serverSocketFactory= sslContext.getServerSocketFactory();

          //在localhost:1500端口号监听

          InetAddresslistenAddr = Inet4Address.getLocalHost();

          ServerSocketserverSocket = serverSocketFactory

              .createServerSocket(1500, 5,listenAddr);

          //启动客户端，待会再分析这个函数

          startClient();

          //接收数据并打印，然后关闭服务端

          Socket clientSock =serverSocket.accept();

          InputStreaminputStream = clientSock.getInputStream();

          byte[] readBuffer =new byte[1024];

          int nread =inputStream.read(readBuffer);

          e(TAG,"==>echo from Client:" + new String(readBuffer, 0, nread));

          clientSock.close();

         serverSocket.close();

        } ......

        e(TAG,"==>server quit");

      }

    });

    serverThread.start();

  }

注意：即使我们创建一个AndroidKeyStore类型的KeyStore传到SSLContext里，我们也无法使用。为什么？因为Android平台有自己的一套Key管理。我们后续分析代码的时候会见到。

  private void startClient(){

    Thread clientThread = newThread(new Runnable() {

      @Override

      public void run() {

        try {

          e(TAG,"==>prepare client truststore");

          SocketFactorysocketFactory = null;

          //注意，如果我们把证书文件导入到Android系统后，就可以利用默认的设置来创建

          //客户端Socket工厂了，否则还得和服务端一样，自己绑定TrustStore！

          if (isOurKeyChainAvailabe()) {

            e(TAG, "wehave installed key in the system");

            socketFactory =SSLSocketFactory.getDefault();

          } else {

            e(TAG,"prepare truststore manually");

            AssetManagerassetManager = DemoActivity.this.getAssets();

            InputStreamkeyInputStream = assetManager

               .open("test-keychain.p12");

           //客户端Socket工厂用TrustManagerFactory来构造

           TrustManagerFactory tmf = TrustManagerFactory

                .getInstance(TrustManagerFactory.getDefaultAlgorithm());

            KeyStore keyStore= KeyStore.getInstance("PKCS12");

           keyStore.load(keyInputStream, "changeit".toCharArray());

           keyInputStream.close();

            //用KeyStore来初始化TrustManagerFactory

            tmf.init(keyStore);

            //同样是创建一个SSLContext对象

            SSLContextsslContext = SSLContext.getInstance("TLS");

            //初始化SSLContext，这个时候只要传递第二个参数就可以了

            sslContext.init(null,tmf.getTrustManagers(), null);

            socketFactory =sslContext.getSocketFactory();

          }

          e(TAG,"==>start client:");

          //连接到服务端

          InetAddressserverAddr = Inet4Address.getLocalHost();

          Socket mySocket =socketFactory.createSocket(serverAddr,1500);

          OutputStreamoutputStream = mySocket.getOutputStream();

          //发送数据并退出

          String data ="I am client";

          e(TAG,"==>Client sent:" + data);

         outputStream.write(data.getBytes());

          mySocket.close();

        } ......

        e(TAG,"==>client quit");

      }

    });

    clientThread.start();

  }