×

Android客户端与PHP服务端RES公钥私钥互加解密

admin admin 发表于2016-10-13 22:19:01 浏览1744 评论0

抢沙发发表评论

本来并非全部原创，可以归纳为原理整理，所以如果看到不是原创的也不要见怪，回正题。

运行环境：

服务端：

CentOS 5.6 i386

PHP：5.3.3

OpenSSL: OpenSSL 0.9.8e-fips-rhel5 01 Jul 2008


客户端：

Android Studio Beta 0.8.0


第一步：在服务端生成RSA的公钥和私钥


[plain] view plain copy

  1. openssl genrsa -out rsa_private_key.pem 1024  

  2.    

  3. openssl pkcs8 -topk8 -inform PEM -in rsa_private_key.pem -outform PEM -nocrypt -out private_key.pem  

  4.    

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


第一条命令生成原始的RSA私钥文件  rsa_private_key.pem ， 第二条将原始的RSA私钥转换为PKCS8格式，第三条生成RSA公钥rsa_public_key.pem ，从上面可以看出私钥可以生成对应的公钥。私钥我们用的客户端 ，公钥可以发给Android或IOS。本文这里只测试　Android。


第二步：PHP服务端的函数使用OpenSSL


[php] view plain copy

  1. class Rsa{  

  2.     private static $PRIVATE_KEY='-----BEGIN PRIVATE KEY-----  

  3. 在这里写上你的私钥，注意格式要保留段落  

  4. -----END PRIVATE KEY-----';  

  5.   

  6.     private static $PUBLIC_KEY = '-----BEGIN PUBLIC KEY-----  

  7. 这里是你的公钥，注意格式，要保留段落  

  8. -----END PUBLIC KEY-----  

  9.     ';    

  10.     public $clientPublicKey = '';  

  11.       

  12.     /** 

  13.     * 设置客户端的公钥 

  14.     */  

  15.     public function setClientPublicKey($cPubKey){  

  16.         $this->clientPublicKey = $cPubKey;         

  17.     }  

  18.   

  19.     /** 

  20.     *获取服务端私钥 

  21.     */  

  22.     private static function getPrivateKey()  

  23.     {  

  24.         $privKey = self::$PRIVATE_KEY;  

  25.         $passphrase = '';  

  26.         return openssl_pkey_get_private($privKey,$passphrase);  

  27.     }  

  28.       

  29.     /** 

  30.      * 服务端公钥加密数据 

  31.      * @param unknown $data 

  32.      */  

  33.     public static function publEncrypt($data){  

  34.         $publKey = self::$PUBLIC_KEY;  

  35.         $publickey = openssl_pkey_get_public($publKey);  

  36.         //使用公钥进行加密  

  37.         $encryptData = '';  

  38.         openssl_public_encrypt($data, $encryptData, $publickey);  

  39.         return base64_encode($encryptData);  

  40.     }  

  41.       

  42.     /** 

  43.     * 服务端私钥加密 

  44.     */  

  45.     public static function privEncrypt($data){  

  46.         if(!is_string($data))  

  47.         {  

  48.             return null;  

  49.         }  

  50.         return openssl_private_encrypt($data,$encrypted,self::getPrivateKey())? base64_encode($encrypted) : null;  

  51.     }  

  52.       

  53.     /**  

  54.      * 服务端私钥解密  

  55.      */    

  56.     public static function privDecrypt($encrypted)    

  57.     {  

  58.         if(!is_string($encrypted)){  

  59.                 return null;    

  60.         }  

  61.         $privatekey = self::getPrivateKey();  

  62.         $sensitivData = '';        

  63.         //return (openssl_private_decrypt(base64_decode($encrypted), $decrypted, self::getPrivateKey()))? $decrypted : null;  

  64.         openssl_private_decrypt(base64_decode($encrypted), $sensitivData, $privatekey);  

  65.         //var_dump($sensitivData);  

  66.         return $sensitivData;     

  67.     }   

  68.       

  69.     /** 

  70.      * 客户端的公钥解密数据 

  71.      * @param unknown $publicKey 

  72.      * @param unknown $encryptString 

  73.      */  

  74.     public function clientPublicDecrypt($encryptString){  

  75.         if(!is_string($encryptString)) return null;  

  76.         $encodeKey = $this->clientPublicKey;       

  77.         $publicKey = openssl_pkey_get_public($encodeKey);  

  78.         if(!$publicKey) {  

  79.             exit("\nClient Publickey Can not used");  

  80.         }  

  81.         $sensitivData = '';       

  82.         openssl_public_decrypt(base64_decode($encryptString), $sensitivData, $publicKey);  

  83.         return $sensitivData;  

  84.     }  

  85.       

  86.     /** 

  87.      * 客户端公钥加密数据 

  88.      * @param string $string 需要加密的字符串 

  89.      * @return string Base64编码的密文 

  90.      */  

  91.     public function clientPublicEncrypt($string){  

  92.         $publKey = $this->clientPublicKey;  

  93.         $publicKey = openssl_pkey_get_public($publKey);  

  94.         if(!$publicKey) {  

  95.             exit("\nClient Publickey Can not used");  

  96.         }  

  97.         //使用公钥进行加密  

  98.         $encryptData = '';  

  99.         openssl_public_encrypt($string, $encryptData, $publicKey);  

  100.         return base64_encode($encryptData);  

  101.     }  

  102.       

  103.     public function formatKey($key, $type = 'public'){  

  104.         if($type == 'public'){  

  105.             $begin = "-----BEGIN PUBLIC KEY-----\n";  

  106.             $end = "-----END PUBLIC KEY-----";  

  107.         }else{  

  108.             $begin = "-----BEGIN PRIVATE KEY-----\n";  

  109.             $end = "-----END PRIVATE KEY-----";  

  110.         }  

  111.         //$key = ereg_replace("\s", "", $key);  

  112.         $key= preg_replace('/\s/','',$key);  

  113.         $str = $begin;  

  114.         $str .= substr($key, 0,64);  

  115.         $str .= "\n" . substr($key, 64,64);  

  116.         $str .= "\n" . substr($key, 128,64);  

  117.         $str .= "\n" . substr($key,192,24);  

  118.         $str .= "\n" . $end;          

  119.         return $str;  

  120.     }  

  121.       

  122. }  


需要说明这么两 点：1、 PHP端 的公钥和私钥都是有头和尾的注释的，而Android是没有的，所以在PHP在使用Android的公钥时要加上-----BEGIN PUBLIC KEY----- ，反之Android要去掉。2、PHP端还是要段落的、所以要用的formatKey这个方法，要注意Android客户端的KEY也是有段落的


使用方法：


[php] view plain copy

  1. $client_public_key = "这里写上你的客户端的公钥";  

  2. $rsa = new Rsa();  

  3. $clientPublicKey = $rsa->formatKey($client_public_key);  

  4. $rsa->setClientPublicKey($clientPublicKey);  

  5.   

  6. echo $rsa->clientPublicDecrypt("这里是客户端私钥加密的密文");  


如何使用服务端私钥加密这里就不再写了，看上面方法的注释就可以看到。


第三步：Android的公钥私钥以及如何加密和解密

先上Android的主函数



[java] view plain copy

  1. /** 

  2.  * Created by dyb on 2014/7/8. 

  3.  */  

  4. public class RSACodeHelper {  

  5.     private static final String TAG = "RSACodeHelper";  

  6.     private static final String RSATYPE = "RSA/ECB/PKCS1Padding"; //Cipher必须用这种类型  

  7.     public PublicKey mPublicKey; //这里要注意一下，原来用的类型是RSAPublicKey 但死活就是解不了服务端私钥加密的密文改成PublicKey就可以了  

  8.     public PrivateKey mPrivateKey; //同上  

  9.   

  10.     public void init(){  

  11.         KeyPairGenerator keyPairGen = null;  

  12.         try {  

  13.             //设置使用哪种加密算法  

  14.             keyPairGen = KeyPairGenerator.getInstance("RSA");  

  15.             //密钥位数  

  16.             keyPairGen.initialize(1024); //一定要和服务端的长度保持一致  

  17.             //密钥对  

  18.             KeyPair keyPair = keyPairGen.generateKeyPair();  

  19.             //公钥  

  20.             mPublicKey = keyPair.getPublic();  

  21.             //私钥  

  22.             mPrivateKey = keyPair.getPrivate();  

  23.             MyLog.i(TAG,"RSA 构造函数完成");  

  24.         }catch (NoSuchAlgorithmException e){  

  25.             e.printStackTrace();  

  26.         }  

  27.     }  

  28.   

  29.     /** 

  30.      * 取得公钥 

  31.      * @param key 公钥字符串 

  32.      * @return 返回公钥 

  33.      * @throws Exception 

  34.      */  

  35.     public static PublicKey getPublicKey(String key) throws Exception{  

  36.         byte[] keyBytes = base64Dec(key);  

  37.         X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);  

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

  39.         PublicKey publicKey = keyFactory.generatePublic(keySpec);  

  40.         MyLog.d(TAG,"Cipher.getInstance:"+keyFactory.getAlgorithm());  

  41.         return publicKey;  

  42.     }  

  43.   

  44.     /** 

  45.      * 取得私钥 

  46.      * @param key 

  47.      * @return 

  48.      * @throws Exception 

  49.      */  

  50.     public static PrivateKey getPrivateKey(String key) throws Exception{  

  51.         byte[] keyBytes = base64Dec(key);  

  52.   

  53.         PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);  

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

  55.         PrivateKey privateKey = keyFactory.generatePrivate(keySpec);  

  56.         return privateKey;  

  57.   

  58.     }  

  59.   

  60.     /** 

  61.      * 使用客户端公钥加密字符串 

  62.      * @param str 需要加密的字符串 

  63.      * @return 密文 

  64.      */  

  65.     public String cPubEncrypt(String str){  

  66.         String strEncrypt = null;  

  67.   

  68.             //实例化加解密类  

  69.         try {  

  70.             Cipher cipher = Cipher.getInstance(RSATYPE);  

  71.             //明文  

  72.             byte[] plainText = str.getBytes();  

  73.             //加密  

  74.             cipher.init(Cipher.ENCRYPT_MODE,mPublicKey);  

  75.             //将明文转化为根据公钥加密的密文，为byte数组格式  

  76.             byte[] enBytes = cipher.doFinal(plainText);  

  77.             strEncrypt = base64Enc(enBytes);  

  78.         } catch (NoSuchAlgorithmException e) {  

  79.             e.printStackTrace();  

  80.         } catch (NoSuchPaddingException e) {  

  81.             e.printStackTrace();  

  82.         }catch (InvalidKeyException e) {  

  83.             e.printStackTrace();  

  84.         } catch (BadPaddingException e) {  

  85.             e.printStackTrace();  

  86.         } catch (IllegalBlockSizeException e) {  

  87.             e.printStackTrace();  

  88.         }finally {  

  89.             return strEncrypt;  

  90.         }  

  91.     }  

  92.   

  93.     /** 

  94.      * 使用服务端的公钥加密 

  95.      * @param str 

  96.      * @return 

  97.      */  

  98.     public String sPubEncrypt(String str){  

  99.         String strEncrypt = null;  

  100.         try {  

  101.             //转换服务端的公钥  

  102.             PublicKey publicKey = getPublicKey("这个参数是你服务端的公钥，可以使用自己的方式来保存公钥");  

  103.             //实例化加密类  

  104.              Cipher cipher = Cipher.getInstance(RSATYPE);  

  105.             //取得明文的二进制  

  106.             byte[] plainText = str.getBytes();  

  107.             //加密  

  108.             cipher.init(Cipher.ENCRYPT_MODE,publicKey);  

  109.             byte[] enBytes = cipher.doFinal(plainText);  

  110.             strEncrypt = base64Enc(enBytes);  

  111.         } catch (NoSuchAlgorithmException e) {  

  112.             e.printStackTrace();  

  113.         } catch (NoSuchPaddingException e) {  

  114.             e.printStackTrace();  

  115.         } catch (Exception e) {  

  116.             e.printStackTrace();  

  117.         }finally {  

  118.             return strEncrypt;  

  119.         }  

  120.     }  

  121.   

  122.     /** 

  123.      * 使用客户端公钥解密 

  124.      * @param encString 

  125.      * @return 

  126.      */  

  127.     public String cPubDecrypt(String encString){  

  128.         Cipher cipher = null;  

  129.         String strDecrypt = null;  

  130.         try {  

  131.             cipher = Cipher.getInstance(RSATYPE);  

  132.             cipher.init(Cipher.DECRYPT_MODE,mPublicKey);  

  133.             //先将转为Base64编码的加密后数据转化为Byte数组  

  134.             byte[] enBytes = base64Dec(encString);  

  135.             //解密为byte数组，应该为字符串数组，最后转化为字符串  

  136.             byte[] deBytes = cipher.doFinal(enBytes);  

  137.             //strDecrypt = base64Enc(deBytes);  

  138.             strDecrypt = new String(deBytes);  

  139.         } catch (NoSuchAlgorithmException e) {  

  140.             e.printStackTrace();  

  141.         } catch (NoSuchPaddingException e) {  

  142.             e.printStackTrace();  

  143.         } catch (InvalidKeyException e) {  

  144.             e.printStackTrace();  

  145.         } catch (BadPaddingException e) {  

  146.             e.printStackTrace();  

  147.         } catch (IllegalBlockSizeException e) {  

  148.             e.printStackTrace();  

  149.         }finally {  

  150.             return strDecrypt;  

  151.         }  

  152.     }  

  153.     /** 

  154.      * 使用客户端私钥解密 

  155.      * @param encString 

  156.      * @return 

  157.      */  

  158.     public String cPriDecrypt(String encString){  

  159.         Cipher cipher = null;  

  160.         String strDecrypt = null;  

  161.         try {  

  162.             cipher = Cipher.getInstance(RSATYPE);  

  163.             cipher.init(Cipher.DECRYPT_MODE,mPrivateKey);  

  164.             //先将转为Base64编码的加密后数据转化为Byte数组  

  165.             MyLog.i(TAG,"string Lenght:" +encString+":"+ encString.length());  

  166.             byte[] enBytes = base64Dec(encString);  

  167.             //解密为byte数组，应该为字符串数组，最后转化为字符串  

  168.             byte[] deBytes = cipher.doFinal(enBytes);  

  169.             strDecrypt = new String(deBytes);  

  170.         } catch (NoSuchAlgorithmException e) {  

  171.             e.printStackTrace();  

  172.         } catch (NoSuchPaddingException e) {  

  173.             e.printStackTrace();  

  174.         } catch (InvalidKeyException e) {  

  175.             e.printStackTrace();  

  176.         } catch (BadPaddingException e) {  

  177.             e.printStackTrace();  

  178.         } catch (IllegalBlockSizeException e) {  

  179.             e.printStackTrace();  

  180.         }finally {  

  181.             return strDecrypt;  

  182.         }  

  183.     }  

  184.   

  185.     /** 

  186.      * 使用客户端私钥加密 

  187.      * @param deString 

  188.      * @return 

  189.      */  

  190.     public String cPriEncrypt(String deString){  

  191.         String strEncrypt = null;  

  192.   

  193.         //实例化加解密类  

  194.         try {  

  195.             Cipher cipher = Cipher.getInstance(RSATYPE);  

  196.             //明文  

  197.             byte[] plainText = deString.getBytes();  

  198.             //加密  

  199.             cipher.init(Cipher.ENCRYPT_MODE,mPrivateKey);  

  200.             //将明文转化为根据公钥加密的密文，为byte数组格式  

  201.             byte[] enBytes = cipher.doFinal(plainText);  

  202.             strEncrypt = base64Enc(enBytes);  

  203.         } catch (NoSuchAlgorithmException e) {  

  204.             e.printStackTrace();  

  205.         } catch (NoSuchPaddingException e) {  

  206.             e.printStackTrace();  

  207.         }catch (InvalidKeyException e) {  

  208.             e.printStackTrace();  

  209.         } catch (BadPaddingException e) {  

  210.             e.printStackTrace();  

  211.         } catch (IllegalBlockSizeException e) {  

  212.             e.printStackTrace();  

  213.         }finally {  

  214.             return strEncrypt;  

  215.         }  

  216.     }  

  217.     /** 

  218.      * base64编码 

  219.      * @param enBytes 

  220.      * @return 

  221.      */  

  222.     public static String base64Enc(byte[] enBytes){  

  223.         return Base64.encodeToString(enBytes,Base64.DEFAULT);  

  224.     }  

  225.   

  226.     /** 

  227.      * base64解码 

  228.      * @param str 

  229.      * @return 

  230.      */  

  231.     public static byte[] base64Dec(String str){  

  232.         return Base64.decode(str,Base64.DEFAULT);  

  233.     }  

  234.   

  235. }  


服务端公钥在Android端的存在形式,这是我个人的方法：


[java] view plain copy

  1. public static final String RSA_PUBLIC = "第一行" +"\r"+  

  2.             "第二行" + "\r"+  

  3.             "第三行" +"\r"+  

  4.             "第四行";  


然后在RSACodeHelper.java 中使用服务端公钥解密的时候，把这里的参数传进去就可以了。




具体使用方法：


[java] view plain copy

  1. RSACodeHelper rsaCodeHelper = new RSACodeHelper();  

  2.         rsaCodeHelper.init();  

  3.         String str = "123456";  

  4.         String strPublicKey = rsaCodeHelper.base64Enc(rsaCodeHelper.mPublicKey.getEncoded());  

  5.         MyLog.d(TAG,"客户端公钥"+ strPublicKey);  

  6.         //String sPubEnString = rsaCodeHelper.sPubEncrypt("123456");  

  7.         //MyLog.d(TAG,"服务端公钥加密后："+sPubEnString);  

  8.   

  9.         String strClientPubEncrypt = rsaCodeHelper.cPubEncrypt(str);  

  10.         //MyLog.i(TAG,"客户端公钥加密密文："+ strClientPubEncrypt);  

  11.         //MyLog.i(TAG,"客户端私钥解为明文1：" + rsaCodeHelper.cPriDecrypt(strClientPubEncrypt));  

  12.   

  13.   

  14.         //客户端私钥加密，公钥解密  

  15.         String clientPrivateEncrypt = rsaCodeHelper.cPriEncrypt(str);  

  16.         MyLog.i(TAG,"客户端私钥加密密文："+ clientPrivateEncrypt);  

  17.         MyLog.i(TAG,"客户端公钥解密：" + rsaCodeHelper.cPubDecrypt(clientPrivateEncrypt));  


需要说明一点，用这种方法取得的公钥，每次都不一样，所以最好把公钥和私钥都保存起来，然后把公钥发给服务端。这样服务端才可以正在解密。

原来没有注意，害我好苦，什么原因都找了一天也没有找到为什么服务端解密不了客户端用私钥加密的密文。后来才发现客户端每次生成的都是不一样的，用不同的公钥去解密文肯定是解不开的。

所以我们要把客户端的公钥和私钥都存起来，使用的时候可以调用：PublicKey publicKey = getPublicKey(”这里写上从存储中读来的公钥“);

当然私钥就是：PrivateKey privateKey = getPrivateKey("传入从服务端读来的私钥");

因此，这个函数还是需要改进的，就是在初始化init()的时候，要传入我们存储的公钥和私钥，以保证客户端和服务端的统一。


在PHP中如果解密失败返回的是空

openssl_public_decrypt(base64_decode($encryptString), $sensitivData, $publicKey);  失败会返回空值。

同样在Android中 

byte[] deBytes = cipher.doFinal(enBytes); 该方法如果解密失败也会返回 Null 


该方法为本来的一次测试实现如下功能：

PHP 私钥加密后 Android可以使用PHP的公钥来解密。

PHP 拿Android 的公钥来加密，Android可以用自己的私钥来解密

Android 使用私钥加密后 PHP可以使用Android 的公钥来解密

ANdroid 用PHP的公钥加密 PHP可以用自己的私钥来解密。

总之：私钥都是自己留着，公钥可以发给对方。用自己的私钥加密，对方有自己手里的公钥可以解密。 拿对方的公钥来加密，对方肯定有他自己的私钥自己来解严就是了。

在查询资料的时候有人遇到过这样的问题，因为Base64在传送的时候有URL中的一些限制,所以要进行UrlEncode编码，但IOS好像会自动进行编码。


分享到：

群贤毕至

访客