数据保密之常见加密应用介绍

1       常见加密应用介绍

1.1    数字签名

数字签名就是在信息的后面再加上一段内容，可以证明信息没有被修改过，怎么样可以达到这个效果呢？一般是对信息做一个hash计算得到一个hash值，注意，这个过程是不可逆的，也就是说无法通过hash值得出原来的信息内容。在把信息发送出去时，把这个hash值加密后做为一个签名和信息一起发出去。 接收方在收到信息后，会重新计算信息的hash值，并和信息所附带的hash值(解密后)进行对比，如果一致，就说明信息的内容没有被修改过，因为这里hash计算可以保证不同的内容一定会得到不同的hash值，所以只要内容一被修改，根据信息内容计算的hash值就会变化。当然，不怀好意的人也可以修改信息内容的同时也修改hash值，从而让它们可以相匹配，为了防止这种情况，hash值一般都会加密后(也就是签名)再和信息一起发送，以保证这个hash值不被修改。

    以下是用SHA1withRSA算法，PKCS#7加密消息标准进行数字签名的部分代码：

    /**

     * 取得签名工具

     * 加载证书库, 取得签名证书链和私钥

     * @param keyStorePath 证书库路径

     * @param keyStorePassword 证书库口令

     * @throws GeneralSecurityException

     * @throws IOException

     */

    publicstatic PKCS7Tool getSigner(String keyStorePath, String keyStorePassword, String keyPassword)

           throws GeneralSecurityException, IOException {

       //加载证书库

       KeyStore keyStore = null;

       keyStore = KeyStore.getInstance("PKCS12");

       FileInputStream fis = null;

       try {

           fis = new FileInputStream(keyStorePath);

           keyStore.load(fis, keyStorePassword.toCharArray());

       } finally {

           if (fis != null)

              fis.close();

       }

       //在证书库中找到签名私钥

       Enumeration aliases = keyStore.aliases();

       String keyAlias = null;

       if (aliases != null) {

           while (aliases.hasMoreElements()) {

              keyAlias = (String) aliases.nextElement();

              Certificate[] certs = keyStore.getCertificateChain(keyAlias);

              if (certs == null || certs.length == 0)

                  continue;

              X509Certificate cert = (X509Certificate)certs[0];

           }

       }

       //没有找到可用签名私钥

       if (keyAlias == null)

           thrownew GeneralSecurityException("None certificate for sign in this keystore");

       X509Certificate[] certificates = null;

       if (keyStore.isKeyEntry(keyAlias)) {

           //检查证书链

           Certificate[] certs = keyStore.getCertificateChain(keyAlias);

           for (int i = 0; i < certs.length; i ++) {

              if (!(certs[i] instanceof X509Certificate))

                  thrownew GeneralSecurityException("Certificate[" + i + "] in chain '" + keyAlias + "' is not a X509Certificate.");

           }

           //转换证书链

           certificates = new X509Certificate[certs.length];

           for (int i = 0; i < certs.length; i ++)

              certificates[i] = (X509Certificate) certs[i];

       } elseif (keyStore.isCertificateEntry(keyAlias)) {

           //只有单张证书

           Certificate cert = keyStore.getCertificate(keyAlias);

           if (cert instanceof X509Certificate) {

              certificates = new X509Certificate[] {(X509Certificate) cert};

           }

       } else {

           thrownew GeneralSecurityException(keyAlias + " is unknown to this keystore");

       }

       PrivateKey privateKey = (PrivateKey) keyStore.getKey(keyAlias, keyPassword.toCharArray());

       //没有私钥抛异常

       if (privateKey == null) {

           thrownew GeneralSecurityException(keyAlias + " could not be accessed");

       }

       PKCS7Tool tool = new PKCS7Tool(SIGNER);

       tool.certificates = certificates;

       tool.privateKey = privateKey;

       return tool;

    }

 

    /**

     * 签名

     * @param data 数据

     * @return signature 签名结果

     * @throws GeneralSecurityException

     * @throws IOException

     * @throws IllegalArgumentException

     */

    public String sign(byte[] data) throws Exception {

       Signature signer = Signature.getInstance(signingAlgorithm);

       signer.initSign(privateKey);

       signer.update(data, 0, data.length);

       byte[] signedAttributes = signer.sign();

       ContentInfo contentInfo = null;

       Field data_oidField = ContentInfo.class.getField("DATA_OID");

       Object data_oid = data_oidField.get(null);

       Constructor contentInfoConstructor = ContentInfo.class.getConstructor(new Class[]{data_oid.getClass(), derValue});

       contentInfo = (ContentInfo) contentInfoConstructor.newInstance(new Object[]{data_oid, null});

       //根证书

       X509Certificate x509 = certificates[certificates.length - 1];

       java.math.BigInteger serial = x509.getSerialNumber();

       //X500Name

       Constructor x500NameConstructor = x500Name.getConstructor(new Class[]{String.class});

       Object x500NameObject = x500NameConstructor.newInstance(new Object[]{x509.getIssuerDN().getName()});

       //AlgorithmId

       Method algorithmIdGet = algorithmId.getMethod("get", new Class[]{String.class});

       Object digestAlgorithmId = algorithmIdGet.invoke(null, new Object[]{digestAlgorithm});

       Field algorithmIdfield = algorithmId.getField("RSAEncryption_oid");

       Object rsaOid = algorithmIdfield.get(null);

       Constructor algorithmConstructor = algorithmId.getConstructor(new Class[]{objectIdentifier});

       Object algorithmRsaOid = algorithmConstructor.newInstance(new Object[]{rsaOid});

       //SignerInfo

       Constructor signerInfoConstructor = SignerInfo.class.getConstructor(

           new Class[]{

              x500Name,

              BigInteger.class,

              algorithmId,

              PKCS9Attributes.class,

              algorithmId,

              byte[].class,

              PKCS9Attributes.class

           }

       );

       //签名信息

       SignerInfo si = (SignerInfo) signerInfoConstructor.newInstance(

           new Object[]{

              x500NameObject,serial,digestAlgorithmId,null, algorithmRsaOid,signedAttributes, null}

       );

       SignerInfo[] signerInfos = { si };

       // 构造PKCS7数据

       Object digestAlgorithmIds = Array.newInstance(algorithmId, 1);

       Array.set(digestAlgorithmIds, 0, digestAlgorithmId);

       //PKCS7

       Constructor pkcs7Constructor = PKCS7.class.getConstructor(new Class[]{

              digestAlgorithmIds.getClass(), ContentInfo.class, X509Certificate[].class, signerInfos.getClass()});

       PKCS7 p7 = (PKCS7) pkcs7Constructor.newInstance(new Object[]{

              digestAlgorithmIds, contentInfo, certificates, signerInfos});

       ByteArrayOutputStream baout = new ByteArrayOutputStream();

       p7.encodeSignedData(baout);

       //Base64编码

       return Base64.encode(baout.toByteArray());

}

1.2              验证签名

使用公钥来验证签名，而公钥一般是从数字证书中取到的。

获取数字证书有两种方式：一种是：签名采用P7封装，则P7包中就包含数字证书。第二种是：同步把数字证书发送过来，或根据用户DN/证书序列号等到指定位置检索出数字证书。

如下是通过bouncycastle的CMSSignedData实现pkcs#7格式签名数据的验证:

publicboolean SignedData_Verify(byte[] signedData)  {

        boolean verifyRet = true;

        try {

               // 新建PKCS#7签名数据处理对象

               CMSSignedData sign = new CMSSignedData(signedData);

               // 添加BouncyCastle作为安全提供

               Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());

               // 获得证书信息

               CertStore certs = sign.getCertificatesAndCRLs("Collection", "BC");

               // 获得签名者信息

               SignerInformationStore signers = sign.getSignerInfos();

               Collection c = signers.getSigners();

               Iterator it = c.iterator();

               // 当有多个签名者信息时需要全部验证

               while (it.hasNext()) {

                      SignerInformation signer = (SignerInformation) it.next();

                      // 证书链

                      Collection certCollection = certs.getCertificates(signer.getSID());

                      Iterator certIt = certCollection.iterator();

                      X509Certificate cert = (X509Certificate) certIt.next();

                      // 验证数字签名

                      if  (signer.verify(cert.getPublicKey(), "BC"))  {

                             verifyRet = true;

                      }  else  {

                             verifyRet = false;

                      }

               }

        }

        catch (Exception e) {

               verifyRet = false;

               System.out.println("验证数字签名失败");

        }

        return verifyRet;

 }

1.3              数字证书

数字证书是一个经证书授权中心数字签名的包含公开密钥拥有者信息以及公开密钥的文件。最简单的证书包含一个公开密钥、名称以及证书授权中心的数字签名。

1.3.1      颁发过程

数字证书颁发过程一般为：用户首先产生自己的密钥对，并将公共密钥及部分个人身份信息传送给认证中心。认证中心在核实身份后，将执行一些必要的步骤，以确信请求确实由用户发送而来，然后，认证中心将发给用户一个数字证书，该证书内包含用户的个人信息和他的公钥信息，同时还附有认证中心的签名信息。用户就可以使用自己的数字证书进行相关的各种活动。数字证书由独立的证书发行机构发布。数字证书各不相同，每种证书可提供不同级别的可信度。可以从证书发行机构获得您自己的数字证书。

1.3.2      工作原理

数字证书采用公钥体制，即利用一对互相匹配的密钥进行加密、解密。每个用户自己设定一把特定的仅为本人所知的私有密钥（私钥），用它进行解密和签名；同时设定一把公共密钥（公钥）并由本人公开，为一组用户所共享，用于加密和验证签名。当发送一份保密文件时，发送方使用接收方的公钥对数据加密，而接收方则使用自己的私钥解密，这样信息就可以安全无误地到达目的地了。通过数字的手段保证加密过程是一个不可逆过程，即只有用私有密钥才能解密。

1.4              数字信封

数字信封是公钥密码体制在实际中的一个应用，是用加密技术来保证只有规定的特定收信人才能阅读通信的内容。

在数字信封中，信息发送方采用对称密钥来加密信息内容，然后将此对称密钥用接收方的公开密钥来加密（这部分称数字信封）之后，将它和加密后的信息一起发送给接收方，接收方先用相应的私有密钥打开数字信封，得到对称密钥，然后使用对称密钥解开加密信息。这种技术的安全性相当高。数字信封主要包括数字信封打包和数字信封拆解，数字信封打包是使用对方的公钥将加密密钥进行加密的过程，只有对方的私钥才能将加密后的数据(通信密钥)还原；数字信封拆解是使用私钥将加密过的数据解密的过程。发送与接收流程如下：

数字信封的功能类似于普通信封，普通信封在法律的约束下保证只有收信人才能阅读信的内容；数字信封则采用密码技术保证了只有规定的接收人才能阅读信息的内容。数字信封中采用了对称密码体制和公钥密码体制。信息发送者首先利用随机产生的对称密码加密信息，再利用接收方的公钥加密对称密码，被公钥加密后的对称密码被称之为数字信封。在传递信息时，信息接收方若要解密信息，必须先用自己的私钥解密数字信封，得到对称密码，才能利用对称密码解密所得到的信息。这样就保证了数据传输的真实性和完整性。

在一些重要的电子商务交易中密钥必须经常更换，为了解决每次更换密钥的问题，结合对称加密技术和公开密钥技术的优点，它克服了私有密钥加密中私有密钥分发困难和公开密钥加密中加密时间长的问题，使用两个层次的加密来获得公开密钥技术的灵活性和私有密钥技术高效性。信息发送方使用密码对信息进行加密，从而保证只有规定的收信人才能阅读信的内容。采用数字信封技术后，即使加密文件被他人非法截获，因为截获者无法得到发送方的通信密钥，故不可能对文件进行解密。

1.1.1      简要过程

1. 当发信方需要发送信息时，首先生成一个对称密钥，用该对称密钥加密要发送的报文；

2. 发信方用收信方的公钥加密上述对称密钥；

3. 发信方将第一步和第二步的结果传给收信方；

4. 收信方使用自己的私钥解密被加密的对称密钥；

5. 收信方用得到的对称密钥解密被发信方加密的报文，得到真正的报文。

1.1.2      详细过程

A.        发方A 将原文信息进行哈希运算，得一哈希值即数字摘要MD；

B.        发方A 用自己的私钥PVA，采用非对称RSA算法，对数字摘要MD进行加密，即得数字签名DS；

C.        发方A 用对称算法DES的对称密钥SK 对原文信息、数字签名SD及发方A 证书的公钥PBA 采用对称算法加密，得加密信息E；

D.       发方用收方B 的公钥PBB，采用RSA算法对对称密钥SK加密，形成数字信封DE， 就好像将对称密钥SK装到了一个用收方公钥加密的信封里；

E.        发方A 将加密信息E和数字信封DE一起发送给收方B；

F.         收方B接受到数字信封DE后，首先用自己的私钥PVB解密数据信封，取出对称密钥SK；

G.       收方B 用对称密钥SK通过DES算法解密加密信息E，还原出原文信息、数字签名SD及发方A证书的公钥PVA；

H.       收方B验收数字签名，先用发方A 的公钥解密数字签名得数字摘要MD；

I.          收方B同时将原文信息用同样的哈希运算，求得一个新的数字摘要MD`；

J.          将两个数字摘要MD和MD`进行比较，验证原文是否被修改。如果二者相等，说明数据没有被篡改，是保密传输的，签名是真实的；否则拒绝该签名。

这样就做到了敏感信息在数字签名的传输中不被篡改，未经认证和授权的人，看不见原数据，起到了在数字签名传输中对敏感数据的保密作用。