PHP uses RSA segment encryption and decryption method

File source code ：

<?php


/**
 * RSA Signature class 
 *  Be careful ： Public and private keys must be one line strings , And remove the generated head and tail 
 *  belt “----” Two lines of , And take care to remove the newline from the last line 
 */
class Rsa
{

    public $publicKey = '';
    public $privateKey = '';
    private $_privKey;
    private  $encryptBlockSize = 117;// Encrypted cutting length 
    private  $decryptBlockSize = 128;// Decryption cut length 
    /**
     * * private key
     */
    private $_pubKey;

    /**
     * * public key
     */
    private $_keyPath;

    /**
     * * the keys saving path
     */

    /**
     * * the construtor,the param $path is the keys saving path
     */
    function __construct($publicKey = null, $privateKey = null)
    {
        $this->setKey($publicKey, $privateKey);
    }

    /**
     *  Set public and private keys 
     * @param string $publicKey  Public key 
     * @param string $privateKey  Private key 
     */
    public function setKey($publicKey = null, $privateKey = null)
    {
        if (!is_null($publicKey))
            $this->publicKey = $publicKey;
        if (!is_null($privateKey))
            $this->privateKey = $privateKey;
    }

    /**
     * * setup the private key
     */
    private function setupPrivKey()
    {
        if (is_resource($this->_privKey))
        {
            return true;
        }
        $pem = chunk_split($this->privateKey, 64, "\n");
        $pem = "-----BEGIN PRIVATE KEY-----\n" . $pem . "-----END PRIVATE KEY-----\n";
        $this->_privKey = openssl_pkey_get_private($pem);
        return true;
    }

    /**
     * * setup the public key
     */
    private function setupPubKey()
    {
        if (is_resource($this->_pubKey))
        {
            return true;
        }
        $pem = chunk_split($this->publicKey, 64, "\n");
        $pem = "-----BEGIN PUBLIC KEY-----\n" . $pem . "-----END PUBLIC KEY-----\n";
        $this->_pubKey = openssl_pkey_get_public($pem);
        return true;
    }

    /**
     * * encrypt with the private key
     */
    public function privEncrypt($data)
    {
        if (!is_string($data))
        {
            return null;
        }
        $this->setupPrivKey();

        // Private key segment encryption 
        $result='';
        $data = str_split($data, $this->encryptBlockSize);
        foreach ($data as $block) {
            openssl_private_encrypt($block, $encrypted, $this->_privKey);
            $result .= $encrypted;
        }
        return $result ? base64_encode($result) : null;

        /*$r = openssl_private_encrypt($data, $encrypted, $this->_privKey);
        if ($r)
        {
            return base64_encode($encrypted);
        }
        return null;*/
    }

    /**
     * * decrypt with the private key
     */
    public function privDecrypt($encrypted)
    {
        if (!is_string($encrypted))
        {
            return null;
        }
        $this->setupPrivKey();
        $encrypted = base64_decode($encrypted);

        // Segment decryption 
        $result = '';
        $data = str_split($encrypted, $this->decryptBlockSize);
        foreach ($data as $block) {
            openssl_private_decrypt($block, $decrypted, $this->_privKey);
            $result .= $decrypted;
        }
        return $result ? $result : null;

       /* $r = openssl_private_decrypt($encrypted, $decrypted, $this->_privKey);
        if ($r)
        {
            return $decrypted;
        }
        return null;*/
    }

    /**
     * * encrypt with public key
     */
    public function pubEncrypt($data)
    {
        if (!is_string($data))
        {
            return null;
        }
        $this->setupPubKey();

        // Block encryption 
        $result='';
        $data = str_split($data, $this->encryptBlockSize);
        foreach ($data as $block) {
            openssl_public_encrypt($block, $encrypted, $this->_pubKey);
            $result .= $encrypted;
        }
        return  $result ? base64_encode($result) : null;

        /*$r = openssl_public_encrypt($data, $encrypted, $this->_pubKey);
        if ($r)
        {
            return base64_encode($encrypted);
        }
        return null;*/
    }

    /**
     * * decrypt with the public key
     */
    public function pubDecrypt($crypted)
    {
        if (!is_string($crypted))
        {
            return null;
        }
        $this->setupPubKey();
        $crypted = base64_decode($crypted);

        $result = '';
        $data = str_split($crypted, $this->decryptBlockSize);
        foreach ($data as $block) {
            openssl_public_decrypt($block, $decrypted, $this->_pubKey);
            $result .= $decrypted;
        }
        return $result ? $result : null;

       /* $r = openssl_public_decrypt($crypted, $decrypted, $this->_pubKey);
        if ($r)
        {
            return $decrypted;
        }
        return null;*/
    }

    /**
     *  Construct signature 
     * @param string $dataString  Signed data 
     * @return string
     */
    public function sign($dataString)
    {
        $this->setupPrivKey();
        $signature = false;
        openssl_sign($dataString, $signature, $this->_privKey);
        return base64_encode($signature);
    }

    /**
     *  Verify the signature 
     * @param string $dataString  Signed data 
     * @param string $signString  Signed string 
     * @return number 1 The signature is correct  0 Signature error 
     */
    public function verify($dataString, $signString)
    {
        $this->setupPubKey();
        $signature = base64_decode($signString);
        $flg = openssl_verify($dataString, $signature, $this->_pubKey);
        return $flg;
    }

    public function __destruct()
    {
        is_resource($this->_privKey) && @openssl_free_key($this->_privKey);
        is_resource($this->_pubKey) && @openssl_free_key($this->_pubKey);
    }

}

Usage method ：

        
       
        $rsa =new Rsa($public_key,$private_key);
        // Private key decryption 
        $arginfo = " Public key encryption string ";
        $y = $rsa->privDecrypt($arginfo);
        $params = json_decode($y,true);
        print_r($params);

        // Private key encryption 
        $rsa =new Rsa($public_key,$private_key);
        $string = $rsa->privEncrypt(" Encrypted string ");
        echo $string;