支付平台架构技术实现之终端安全

转载自：支付平台架构技术实现之终端安全

首先讲解在本地加密存储的方法，加密方法有两种：对称加解密和非对称加解密。

实用场景：支付系统中有部分配置文件的内容需要加密存储在本地，例如：跳转服务器的地址或支付 SDK 的运行参数在使用过程中需要先解密再使用。对于这种场景，比较适合采用对称加密算法。

当然，也可以使用非对称加密。但由于非对称加密适用于安全级别较高、运算速度较慢及私钥一般不在终端存储等场景中，所以在技术选型上面不宜使用。

说到对称加密算法，可以选择使用以下几种方案。这里的终端安全示例代码以 Android 操作系统为例，并且使用 Java 来实现安全加密、访问授权和传输安全。

1、中低安全级别的数据（DES）

数据加密标准 DES

数据加密标准 DES（Data Encryption Standard）是使用对称密钥加密的一种块加密算法，处理数据的速度较快，性能较好，通常适用于对大块数据加解密的场景中。该算法的明显缺点是密钥较短，这意味着可以通过暴力破解来解密，降低了加密的安全性，但仍然适用于对支付系统配置文件的安全加密等场景中。

以下是基于 Android 系统的 DES 加密的代码实现：

/**
 * 采用 DES 加密字符串数据，使用 UTF-8 编码
 * @param plain 原字符串
 * @param encryKey 密钥
 * @return 密文
 * @throws Exception
 */
 public static String encryptByDES(String plain, String encryKey)
 throws Exception {
 // 获取密码实例对象，参数格式为"算法 / 模式 / 填充"
 Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
 // 使用 Key 作为 DES 密钥的密钥内容，创建一个 DESKeySpec 对象
 DESKeySpec desKeySpec = new DESKeySpec(encryKey.getBytes("UTF-8"));
 // 返回 DES 算法的 SecretKeyFactory 对象
 SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
 // 生成 SecretKey 对象
 SecretKey secretKey = keyFactory.generateSecret(desKeySpec);
 // 使用密钥构造一个 IvParameterSpec 对象。
 IvParameterSpec iv = new IvParameterSpec(encryKey.getBytes());
 // 用密钥和一组算法参数初始化密码实例对象
 cipher.init(Cipher.ENCRYPT_MODE, secretKey, iv);
 // 加密，使用 Base64 密码
 return new String(Base64.encode(cipher.doFinal(plain
 .getBytes("UTF-8"))));
 }

对应的解密函数如下：

 /**
 * 使用密码和密钥解密数据
 * @param encryString 密文
 * @param decodeKey 密钥
 * @return 明文
 * @throws Exception
 */
 public static String decryptByDES(String encryString, String decodeKey) throws Exception {
 // 使用密钥构造 IV 对象
 IvParameterSpec iv = new IvParameterSpec(decodeKey.getBytes());
 // 根据密钥和 DES 算法构造一个 SecretKeySpec
 SecretKeySpec skeySpec = new SecretKeySpec(decodeKey.getBytes(), "DES");
 // 返回实现了指定转换的 Cipher 对象
 Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
 // 解密初始化
 cipher.init(Cipher.DECRYPT_MODE, skeySpec, iv);
 // 解码返回
 byte[] byteMi = Base64.decode(decodeString.toCharArray());
 byte decryptedData[] = cipher.doFinal(byteMi);
 return new String(decryptedData);
 }

这样就实现了加解密函数，只需在加密时调用 encryptByDES 函数，将明文数据和 8 位 Key 传入就可以得到密文数据，然后在使用时以相同的 Key 值和密文调用 decryptByDES 函数完成密文解密得到明文信息。在以上代码中还使用了 Base64 编码方式，可以将二进制数据编码成可见的 ASCII 码字符串数据。在 Android 系统中 Base64（完整类名为 android.util.Base64）已经是一种内置的工具类的编码转换算法，很多人都把 Base64 当成一个加解密算法，但从严格意义上来说，它不能算是一种加解密算法，只能算是一种编码格式的转换算法。

2、DES 算法演进之 3DES

在 DES 基础之上进化了三重数据加密算法（3DES），该算法使用了 K1、K2、K3 对同一组明文进行多重加密，其基本原理是对每个数据块都使用三次 DES 加密，如果密钥小于 64 位，则其加密强度与 DES 一致，一般建议采用的密钥超过 64 位。3DES 的加密函数示例如下：

/**
 * 采用 3DES 加密字符串
 *
 * @param plain
 * 普通文本
 * @return
 * @throws Exception
 */
 public static String encryptBy3DES(String plain, String secretKey) throws Exception {
 Key deskey = null ;
 DESedeKeySpec spec = new DESedeKeySpec(secretKey.getBytes());
 // 根据 3DES 构造一个 SecretKeyFactory
 SecretKeyFactory keyfactory = SecretKeyFactory.getInstance( "desede");
 deskey = keyfactory.generateSecret(spec);
 // 获取密码实例对象，参数格式为"算法 / 模式 / 填充"
 Cipher cipher = Cipher.getInstance("desede/CBC/PKCS5Padding");
 IvParameterSpec ips = new IvParameterSpec(iv.getBytes());
 cipher.init(Cipher. ENCRYPT_MODE , deskey, ips);
 byte [] encryptData = cipher.doFinal(plain.getBytes("UTF-8"));
 return Base64.encodeToString(encryptData,Base64.DEFAULT);
 }

其中涉及的加密编码方式和填充方式包括 3DES-ECB、3DES-CBC、3DES-CTR、3DES-OFB 和 3DES-CFB。解密函数示例如下：

/**
 * 3DES 解密
 * @param encryString 密文
 * @return 明文
 * @throws Exception
 */
 public static String decryptBy3DES(String encryString, String secretKey) throws Exception {
 Key deskey = null ;
 DESedeKeySpec spec = new DESedeKeySpec( secretKey.getBytes());
 SecretKeyFactory keyfactory = SecretKeyFactory.getInstance( "desede" );

其中三重数据加密算法的密钥长度是 128 位。除了 3DES 算法，还有人演算出 N-DES（N 重数据加密算法）。

3、高安全级别的数据（AES）

由于密钥长度过短、弱密钥等缺点的存在，DES 容易被暴力破解。随着计算机性能不断提升，DES 被暴力破解的频率越来越高。所以，美国国家标准与技术研究院（NIST）在 1997 年放弃了对 DES 的官方支持，研发出 DES 的替代者 AES（Advanced Encryption Standard，高级加密标准）。

在 Android 系统上使用 AES 与使用 DES 的实现难度、代码量和写法相差无几，比 DES 速度更快、性能更高，在实际的开发过程中建议采用 AES 算法对数据进行加解密，其加密代码如下：

/**
* AES 加密
* @param plain 明文
* @return 密文
* @throws Exception
*/
public static String encryptByAES(String plain, String secretKey){
byte[] crypted = null;
try{
SecretKeySpec spec = new SecretKeySpec(secretKey.getBytes("UTF-8"), "AES");
Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE, spec);
crypted = cipher.doFinal(plain.getBytes());
}catch(Exception e){
return "";
}
return new String(Base64.encode(crypted, Base64.NO_WRAP));
}

解密代码如下：

/**
 * AES 解密
 * @param encryString 密文
 * @return 明文
 * @throws Exception
 */
 public static String decryptByAES(String encryString, String secretKey){
 byte[] output = null;
 try{
 SecretKeySpec spec = new SecretKeySpec(secretKey.getBytes("UTF-8"), "AES");
 Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
 cipher.init(Cipher.DECRYPT_MODE, spec);
 output = cipher.doFinal(Base64.decode(encryString, Base64.NO_WRAP));
 } catch(Exception e){
 return "";
 }
 return new String(output);
 }

针对对称加解密算法都有一个密钥需要存储的问题，目前有三种实现方案。生成密钥之后，可以将其保存在存储设备中，例如密钥文件或 Android 系统的 SharedPreferences 中，在使用时将其读取到内存中。生成密钥之后，依据固定的设备特性（例如 DeviceId、OSID 等）将密钥信息上送到服务器端，在应用启动时将密钥信息获取到本地使用，由于移动网络通信存在不确定性，所以不推荐采用这种方案。将密钥放在 NDK 代码中，然后采用数据位移或拆分等方案，再拼装为真正的密钥数据。这种算法的破解难度较高，也较安全，推荐采用这种存储方案。

4、非对称加密（RSA）

RSA 是一种非对称加密算法，由三位数学家 Rivest、Shamir 和 Adleman 设计，其核心思想为将密钥分成以下两把密钥，简称密钥对。

在密钥对中有一个公钥，还有一个私钥。

• 公钥（Public Key）：是密钥对中完全公开的部分，任何人都可以得到它，适用于客户端 - 服务端模型。
• 私钥（Private Key）：是密钥对中保密的一部分，一般在服务端安全存储，不允许在客户端存储。

可以使用 OpenSSL 工具的命令生成公私钥，也可以使用开发语言生成公私钥。

（1）生成 RSA 算法的私钥时，使用以下命令：

openssl genrsa -out rsa_private_key.pem 2048 

（2）使用以下命令将 X509 编码文件转换成 PKCS8 编码格式：

openssl pkcs8 -in rsa_private_key.pem -out rsa_private_key_pkcs8.pem -nocrypt -topk8

（3）导出私钥对应的 X509 编码公钥文件：

openssl rsa -in rsa_private_key.pem -out rsa_public_key.pem -pubout

注意：可以使用 Java 代码从 rsa_private_key_pkcs8.pem 文件中读取私钥信息并生成数字签名，再使用 rsa_public_key.pem 公钥文件验证数字签名的正确性。

Java 虚拟机也提供了内置的方法来生成公私钥，代码如下：

/**
 * 生成非对称密钥对
 * @throws NoSuchAlgorithmException
 */
 public static void genKeyPair() throws NoSuchAlgorithmException {
 //KeyPairGenerator 类，基于 RSA 算法生成对象
 KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
 // 初始化密钥对生成器
 keyPairGen.initialize(1024,new SecureRandom());
 // 生成一个密钥对，保存在 keyPair 对象中
 KeyPair keyPair = keyPairGen.generateKeyPair();
 // 得到私钥对象
 RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
 // 得到公钥对象
 RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
 // 公钥字符串
 String publicKeyString = new String(Base64.encodeBase64(publicKey.getEncoded()));
 // 私钥字符串
 String privateKeyString = new String(Base64.encodeBase64((privateKey.getEncoded())));
 } 

有了公私钥数据之后，就可以对数据进行加解密处理和数据加签、验签了。

其中，加密数据的一方使用公开获得的公钥（一般推荐使用 1024 位密钥，密钥越长越安全，也意味着加密性能越差），对明文数据进行加密得到密文：

/**
 * 使用公钥进行加密
 * @param plain 明文数据
 * @param publicKey 公钥数据
 * @return 密文
 * @throws Exception
 */
 public static byte[] encryptByPubKey(byte[] plain, byte[] publicKey) throws Exception {
 // 从公钥数据中得到 KeySpec 对象
 X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKey);
 // 根据 RSA 算法构造一个 KeyFactory
 KeyFactory keyFactory = KeyFactory.getInstance("RSA");
 PublicKey pubKey = keyFactory.generatePublic(keySpec);
 // 获取密码实例对象 参数格式为"算法 / 模式 / 填充"
 Cipher cp = Cipher.getInstance("RSA/None/PKCS1Padding");
 cp.init(Cipher.ENCRYPT_MODE, pubKey);
 return cp.doFinal(plain);
 } 

解密的一方具有私钥，拿到密文时，使用对应的私钥进行解密：

/**
 * 使用私钥解密
 * @param encrypted
 * @param privateKey
 * @return
 * @throws Exception
 */
 public static byte[] decryptByPrivKey(byte[] encrypted, byte[] privateKey) throws Exception {
 // 从私钥数据中得到 KeySpec 对象
 PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKey);
 KeyFactory kf = KeyFactory.getInstance("RSA");
 PrivateKey keyPrivate = kf.generatePrivate(keySpec);
 // 获取密码实例对象，参数格式为"算法 / 模式 / 填充"
 Cipher cp = Cipher.getInstance("RSA/None/PKCS1Padding");
 cp.init(Cipher.DECRYPT_MODE, keyPrivate);
 byte[] arr = cp.doFinal(encrypted);
 return arr;
 }

如果解密失败，则代表公钥或私钥不匹配（不是一个密钥对），这也说明如果没有对应的私钥，则解不出密文中的内容。RSA 一般只适用于小数据块的加解密场景中（例如加密动态密钥、短的关键数据），加解密速度较 AES 和 DES 慢。

5、传输安全

数据的传输安全需要满足以下条件。

• 防窥探：数据明文受到保护，不应该被黑客和恶意用户识别、利用。保护数据不被窥探是一项重要的指标，发送者和接收者双方都需要实现加密技术，保证数据无法被第三方破解和解密。
• 防篡改：保护数据在传输过程中的完整性，必须确认不会在数据传输过程中被截获和篡改。
• 防伪造：能识别数据发送方是否具有合法性，并且能确认发送方的真实性。下面讲解相应的技术实现方案。

1、防窥探

数据一般通过计算机网络进行传输，除了有从一个发送方（发送节点）发送到接收方（接收节点）的简单场景，还有复杂的场景（经过 N 个网络节点传输才能到达最终目的地）。随着节点的增多，在这个传输过程中被截获、监听的风险越来越高（例如：现在常用的网络数据抓包软件就有 Fiddler、Wireshark 等，可以监听到网络层都采用了什么协议、调用了哪些 API，以及发送参数、返回的响应数据分别是什么）。

在客户端一般采用公开的通道加密方案保证通道数据无法被窥探。

TLS（Transport Layer Security）又叫作安全传输层协议，主要用于在两个通信应用程序之间提供保密性和数据完整性。

Android 系统对应的实现如下。

首先，读取自己的证书并初始化 TLS 的工厂类：

// 用 keytool 将.keystore 中的证书写入文件中，然后从该文件中读取证书信息
CertificateFactory cf = CertificateFactory.getInstance("X.509");
InputStream caInput = new BufferedInputStream(new ByteArrayInputStream(caPath.getBytes()));
Certificate ca;
try {
 ca = cf.generateCertificate(caInput);
} finally {
 caInput.close();
}
// 创建一个包含认证证书的 KeyStore
String keyStoreType = KeyStore.getDefaultType();
KeyStore keyStore = KeyStore.getInstance(keyStoreType);
keyStore.load(null, null);
keyStore.setCertificateEntry("ca", ca);
// 创建一个基于 KeyStore 算法的 TrustManager 对象
String tmfAlgorithm = TrustManagerFactory.getDefaultAlgorithm();
TrustManagerFactory tmf = TrustManagerFactory.getInstance(tmfAlgorithm);
tmf.init(keyStore);
// 初始化 TLS
SSLContext context = SSLContext.getInstance("TLS");
context.init(null, tmf.getTrustManagers(), null); 

然后，获取 Socket 工厂类，创建 Socket 连接，开始 TLS 握手：

// 远程服务器的地址
SocketAddress sockaddr = new InetSocketAddress("localhost", 80);
// 创建 Socket 对象实例
Socket socket = context.getSocketFactory().createSocket();
// 开始连接
socket.connect(sockaddr, 60 * 1000);
// 开始 TLS 握手
socket.startHandshake(); 

2、防篡改

在某支付场景中，客户端与服务端的请求被黑客截获并将支付订单的金额修改为 0.1 元（原订单金额 10 元），由于未在这个过程中对订单数据进行防篡改校验，导致了商户的商品被便宜卖掉，造成了商户的经济损失。

数据防篡改的主要手段是针对数据进行客户端加签，在服务端接收数据时验证加签数据是否与签名一致。加签的过程实质上是发送端针对待发送的原始数据进行一定的处理（例如字符串去空格、字段排序、数据加密）后针对数据加签生成签名摘要数据，这部分摘要数据一般不会参与加密。接收端在收到数据之后，先将签名摘要数据和加密数据取出来，然后解密已加密的数据块得到原始数据，最后像发送端一样进行处理，生成签名摘要数据。如果生成的摘要数据与发送端传送过来的一致，则表示数据没被篡改过，否则表示数据在传输过程中被篡改。

下面讲解对防篡改的数据进行签名和验签的过程。

（1）对原始数据去空格，进行参数字段排序（升序或降序）和拼接。

（2）将原始数据（待签名内容）根据参数字段名称进行排序，可以保证加签、验签的双方待验证参数内容的一致性。例如：排序升序规则按照第一个字符的 ASCII 码值递增排序，如果遇到相同的字符，则依据第 2 个字符排递增序，以此类推。将排序后的参数拼接成“参数 = 参数值”的格式，并且把这些参数使用“&”字符连接起来。

/**
 * 对参数字段进行排序
 * @param params 参数数据
 * @return
 */
 public String orderByParameters(Map<String, String> params) {
 StringBuilder sb = new StringBuilder();
 // 以参数名称的字典进行升序排列
 Map<String, String> sortParams = new TreeMap<String, String>(params);
 // 拼接成"key=value"格式
 for (Map.Entry<String, String> entry : sortParams.entrySet()) {
 String key = entry.getKey();
 // 字符串去空格
 String value = entry.getValue().trim();
 key = key.trim();
 if (TextUtils.isEmpty(value))
 sb.append("&").append(key).append("=").append(value);
 }
 return sb.toString();
 } 

（3）生成摘要数据，常用的摘要算法有 MD5、SHA-1 等。下面使用 MD5 生成摘要数据：

// 替换第 1 个间隔符号
String param = param.replaceFirst("&","");
// 生成摘要数据
String signValue = Md5Utils.md5(param);
// 拼接摘要数据
String param = param + "&sign=" + signValue;

（4）使用非对称加密算法 RSA，利用客户端的公钥对摘要值进行加密，将数据通过网络发送给接收方进行验证。

接收方在接收到数据之后进行验签，与加签的过程基本一致。

• 参数排序。将收到的参数内容（key=value 字典）根据参数名称进行排序，其排序规则与签名方保持一致，对参数字符串去空格和拼接，其拼接方式与签名方保持一致，生成待生成摘要的原参数字符串。
• 生成摘要数据。使用相同的摘要算法（MD5）计算得到验签方的摘要值。
• 进行非对称解密。使用 RSA 非对称加密算法，对收到的加密摘要数据使用私钥进行解密，并得到签名方的原始摘要值。
• 摘要数据对比。如果签名方的摘要数值等于验签方计算出来的摘要值，则表示验签成功，否则验签失败。