csapi/application/common/service/OpensslService.php

<?php
namespace app\common\service;

class OpensslService
{
    
    /**
     * openssl加密
     * @param type $companyCode
     * @param type $data
     * @return type
     */
    public static function encryptByPrivateKey($companyCode,$data) {
        //这个函数可用来判断私钥是否是可用的，可用返回资源id Resource id
        $priKey = file_get_contents("COMPANY_LIST/$companyCode/jd/my_rsa_private_pkcs8_key.pem");
        $privateKey = wordwrap($priKey, 64, "\n", true);
        $privateKeyStr = "-----BEGIN RSA PRIVATE KEY-----\n"
                . "$privateKey"
                . "\n-----END RSA PRIVATE KEY-----";
        
        $opensslPriKey =  openssl_pkey_get_private($privateKeyStr);
        $encrypted="";
        openssl_private_encrypt($data,$encrypted,$opensslPriKey,OPENSSL_PKCS1_PADDING);//私钥加密
        $encrypted = base64_encode($encrypted);//加密后的内容通常含有特殊字符，需要编码转换下，在网络间通过url传输时要注意base64编码是否是url安全的
        return $encrypted;
    }
	
    /**
     * openssl解密
     * @param type $companyCode
     * @param type $data
     * @return string
     */
    public static function decryptByPublicKey($companyCode,$data) {
        //这个函数可用来判断公钥是否是可用的，可用返回资源id Resource id
        $pubKey = file_get_contents("COMPANY_LIST/$companyCode/jd/wy_rsa_public_key.pem");
        $publicKey = wordwrap($pubKey, 64, "\n", true);
        $publicKeyStr = "-----BEGIN PUBLIC KEY-----\n"
                . "$publicKey"
                . "\n-----END PUBLIC KEY-----";
        
        $decrypted = "";
        $data = base64_decode($data);
        $opensslPubKey = openssl_pkey_get_public($publicKeyStr);
        
        openssl_public_decrypt($data,$decrypted,$opensslPubKey,OPENSSL_PKCS1_PADDING);//公钥解密

        return $decrypted;
    }
    
    /**
    * 转换一个String字符串为byte数组
    * @param $str 需要转换的字符串
    * @param $bytes 目标byte数组
    */
   private static function getBytes($string) {
           $bytes = array ();
           for($i = 0; $i < strlen ( $string); $i ++) {
                   $bytes [] = ord($string[$i]);
           }
           return $bytes;
   }
   
   /**
    * 转换一个int为byte数组
    * @param $byt 目标byte数组
    * @param $val 需要转换的字符串
    */
   private static function integerToBytes($val) {
           $byt = array ();
           $byt [0] = ($val >> 24 & 0xff);
           $byt [1] = ($val >> 16 & 0xff);
           $byt [2] = ($val >> 8 & 0xff);
           $byt [3] = ($val & 0xff);
           return $byt;
   }
    
   /**
    * 将元数据进行补位后进行3DES加密
    * <p/>
    * 补位后 byte[] = 描述有效数据长度(int)的byte[]+原始数据byte[]+补位byte[]
    *
    * @param
    *        	sourceData 元数据字符串
    * @return 返回3DES加密后的16进制表示的字符串
    */
   public static function encrypt2HexStr($keys, $sourceData) {

           $source = [];
           // 元数据
           $source = self::getBytes($sourceData);
           // 1.原数据byte长度
           $merchantData = count($source);
           // 2.计算补位
           $x = ($merchantData + 4) % 8;
           $y = ($x == 0) ? 0 : (8 - $x);
           // echo ("需要补位 :" . $y . "<br/>");
           // 3.将有效数据长度byte[]添加到原始byte数组的头部
           $sizeByte = self::integerToBytes($merchantData);
           $resultByte = array ();

           for($i = 0; $i < 4; $i ++) {
                   $resultByte [$i] = $sizeByte [$i];
           }
           //var_dump($sizeByte);
           // 4.填充补位数据
           for($j = 0; $j < $merchantData; $j ++) {
                   $resultByte [4 + $j] = $source [$j];
           }
           //var_dump($resultByte);
           for($k = 0; $k < $y; $k ++) {
                   $resultByte [$merchantData + 4 + $k] = 0x00;
           }

           $desdata = self::encrypt (self::toStr($resultByte), $keys);
           
           return self::strToHex($desdata);
   }
   
    /**
     * 转换一个16进制hexString字符串为十进制byte数组
     *
     * @param $hexString 需要转换的十六进制字符串        	
     * @return 一个byte数组
     *
     */
    private static function hexStrToBytes($hexString) {
        
        $bytes = array ();
        for($i = 0; $i < strlen ( $hexString ) - 1; $i += 2) {
                $bytes [$i / 2] = hexdec ( $hexString [$i] . $hexString [$i + 1] ) & 0xff;
        }
        return $bytes;
    }
   
   public static function decrypt4HexStr($keys, $data) {
       
        $hexSourceData = [];

        $hexSourceData = self::hexStrToBytes($data);

        // 解密
        $unDesResult = self::decrypt(self::toStr($hexSourceData),$keys);
        //echo $unDesResult;
        $unDesResultByte = self::getBytes($unDesResult);
        //var_dump($unDesResultByte);
        $dataSizeByte = array ();
        for($i = 0; $i < 4; $i ++) {
                $dataSizeByte [$i] = $unDesResultByte [$i];
        }
        // 有效数据长度
        $dsb = self::byteArrayToInt($dataSizeByte, 0);
        $tempData = array ();
        for($j = 0; $j < $dsb; $j++) {
                $tempData [$j] = $unDesResultByte [4 + $j];
        }

        return self::hexTobin(self::bytesToHex($tempData));

    }
    
    // 字符串转16进制
    private static function bytesToHex($bytes) {
            $str = self::toStr( $bytes );
            return self::strToHex ( $str );
    }
    
    /**
    * @param unknown $hexstr
    * @return Ambigous <string, unknown>
    */
   private static function hexTobin($hexstr)
   {
        $n = strlen($hexstr);
        $sbin="";
        $i=0;
        while($i<$n)
        {
             $a =substr($hexstr,$i,2);
             $c = pack("H*",$a);
             if ($i==0){$sbin=$c;}
             else {$sbin.=$c;}
             $i+=2;
        }
        return $sbin;
   }
    
    
    /**
    * 将byte数组 转换为int
    * @param b
    * @param offset 位游方式
    * @return
    */
   private static function byteArrayToInt($b, $offset) {
           $value = 0;
           for($i = 0; $i < 4; $i ++) {
                   $shift = (4 - 1 - $i) * 8;
                   $value = $value + ($b [$i + $offset] & 0x000000FF) << $shift; // 往高位游
           }
           return $value;
   }
   
    /**
     * 将十进制字符串转换为十六进制字符串
     *
     * @param $string 需要转换字符串        	
     * @return 一个十六进制字符串
     */
    private static function strToHex($string) {
        $hex = "";
        for($i = 0; $i < strlen ( $string ); $i ++) {
                $tmp = dechex ( ord ( $string [$i] ) );
                if (strlen ( $tmp ) == 1) {
                        $hex .= "0";
                }
                $hex .= $tmp;
        }
        $hex = strtolower ( $hex );
        return $hex;
    }
   
   /**
    * 将字节数组转化为String类型的数据
    * @param $bytes 字节数组
    * @param $str 目标字符串        	
    *
    * @return 一个String类型的数据
    */
   private static function toStr($bytes) {
            $str = '';
            foreach ( $bytes as $ch ) {
                    $str .= chr ( $ch );
            }

            return $str;
    }

   // 加密算法
   private static function encrypt($input, $key) {
       
        $size = mcrypt_get_block_size ('des', 'ecb');
        $td = mcrypt_module_open ( MCRYPT_3DES, '', 'ecb', '');
        $iv = @mcrypt_create_iv ( mcrypt_enc_get_iv_size ( $td ), MCRYPT_RAND );
        // 使用MCRYPT_3DES算法,cbc模式
        @mcrypt_generic_init ( $td, $key, $iv );
        // 初始处理
        $data = mcrypt_generic ( $td, $input );
        // 加密
        mcrypt_generic_deinit ( $td );
        // 结束
        mcrypt_module_close ( $td );
        
        return $data;
    }
    
    private static function decrypt($encrypted, $key) {
        //$encrypted = base64_decode($encrypted);
        $td = mcrypt_module_open ( MCRYPT_3DES, '', 'ecb', '' ); // 使用MCRYPT_DES算法,cbc模式
        $iv = @mcrypt_create_iv ( mcrypt_enc_get_iv_size ( $td ), MCRYPT_RAND );
        $ks = mcrypt_enc_get_key_size ( $td );
        @mcrypt_generic_init ( $td, $key, $iv ); // 初始处理
        $decrypted = mdecrypt_generic ( $td, $encrypted ); // 解密
        mcrypt_generic_deinit ( $td ); // 结束
        mcrypt_module_close ( $td );
        
        return $decrypted;
    }
    
    /**
     * 京东的证书请求
     * @param type $cacert 证书目录
     * @param type $url 请求地址
     * @param type $dataString
     * @return type
     */
    public static function httpPostData($cacert,$url,$dataString) {
        //$cacert = '';	//CA根证书  (目前暂不提供)
        $CA = false ; 	//HTTPS时是否进行严格认证
        $TIMEOUT = 30;	//超时时间(秒)
        $SSL = substr($url, 0, 8) == "https://" ? true : false;

        $ch = curl_init ();
        if ($SSL && $CA) {  
                curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, true);//只信任CA颁布的证书  
                curl_setopt($ch, CURLOPT_CAINFO, $cacert); //CA根证书（用来验证的网站证书是否是CA颁布）  
                curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 2); //检查证书中是否设置域名，并且是否与提供的主机名匹配  
        } else if ($SSL && !$CA) {  
                curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false); //信任任何证书  
                curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0); //检查证书中是否设置域名  
        }  

        curl_setopt ( $ch, CURLOPT_TIMEOUT, $TIMEOUT);  
        curl_setopt ( $ch, CURLOPT_CONNECTTIMEOUT, $TIMEOUT-2);  
        curl_setopt ( $ch, CURLOPT_POST, 1 );
        curl_setopt ( $ch, CURLOPT_URL, $url );
        curl_setopt ( $ch, CURLOPT_POSTFIELDS, $dataString);
        curl_setopt ( $ch, CURLOPT_HTTPHEADER, [
            'Content-Type:application/xml;charset=utf-8',
            'Content-Length:' . strlen($dataString)
        ]);

        ob_start();
        curl_exec($ch);
        $return_content = ob_get_contents();
        ob_end_clean();

        $return_code = curl_getinfo ($ch, CURLINFO_HTTP_CODE);
        return array (
            $return_code,
            $return_content 
        );
    }
}