PHP RSA encryption

<?php

class Rsa
{
    private $privateKeyFilePath = 'rsa_private_key.pem';

    private $publicKeyFilePath = 'rsa_public_key.pem';



//  Encrypted data 

    private $encryptData = '';

    private function test()
    {
        extension_loaded('openssl') or die('php need openssl Extended support ');

        (file_exists($this->privateKeyFilePath) && file_exists($this->privateKeyFilePath)) or die(' Incorrect file path ');

        $privateKey = openssl_pkey_get_private(file_get_contents($this->privateKeyFilePath));

        $publicKey = openssl_pkey_get_public(file_get_contents($this->publicKeyFilePath));

        ($privateKey && $publicKey) or die(' The key or public key is not available ');
    }


    /**RSA Signature function 
     * $data For the data to be signed , such as URL
     *  The signature uses the game party's confidential private key , It must be without pkcs8 The conversion . The result needs to be base64 Code for URL Transmission of 
     * return Sign  Signature 
     */
    public static function sign($data)
    {

        $priKey = file_get_contents('rsa_private_key.pem');

        // Convert to openssl secret key , It must be without pkcs8 Converted private key 

        $res = openssl_get_privatekey($priKey);

        // call openssl Built in signature method , Generate signature $sign

        openssl_sign($data, $sign, $res);

        openssl_free_key($res);


        $sign = base64_encode($sign);

        return $sign;

    }

    /**RSA Verify the signature 
     * $data For the data string to be verified 
     * $sign Is the signature data that needs to be verified , It's directly from URL Taken in $_POST["sign"] Type parameter , There will be... In the function base64_decode Of .
     * return  Whether the signature is passed , by BOOL value 
     */

    public static function verify($data, $sign)
    {

        // Read public key file , That is, the public key disclosed by the signer , To verify this data Whether it is really sent by the signatory 

        $pubKey = file_get_contents('key/rsa_public_key.pem');


        $res = openssl_get_publickey($pubKey);

        // call openssl Built in method signature verification , return bool value 

        $result = (bool)openssl_verify($data, base64_decode($sign), $res);


        openssl_free_key($res);

        return $result;

    }

    public function encrypt($originalData)
    {


        $encryptData = '';


//        echo ' The original data is :', $originalData, PHP_EOL;
        /// Encrypt with private key 

        if (openssl_private_encrypt($originalData, $encryptData, openssl_pkey_get_private(file_get_contents($this->privateKeyFilePath)))) {
            //  After encryption   Sure base64_encode After that, it is convenient to transmit in the website 

//            echo ' Encryption succeeded , Encrypted data (base64_encode after ) by :', base64_encode($encryptData), PHP_EOL;
            return ($encryptData);

        } else {
//            exit(' Encryption failed ');

            return false;
        }
    }

    public function decrypt($encryptData)
    {
        // Decryption with public key 
        // Decrypted data 

        $decryptData = '';

        if (openssl_public_decrypt($encryptData, $decryptData, openssl_pkey_get_public(file_get_contents($this->publicKeyFilePath)))) {

            return ($decryptData);

        } else {
            return false;

        }
    }

    /**
     *  Encrypt with a private key 
     */

    public function private_encrypt($input)
    {

        openssl_private_encrypt($input, $output, file_get_contents($this->privateKeyFilePath));

        return base64_encode($output);

    }

    /**
     *  Decrypt   The ciphertext encrypted by private key 
     */

    public function public_decrypt($input)
    {

        openssl_public_decrypt(base64_decode($input), $output, file_get_contents($this->publicKeyFilePath));

        return $output;

    }

    /**
     *  Encrypt with a public key 
     */

    public function public_encrypt($input)
    {

        openssl_public_encrypt($input, $output, $this->public_key_resource);

        return base64_encode($output);

    }

    /**
     *  Decrypt   Ciphertext encrypted by public key 
     */

    public function private_decrypt($input)
    {

        openssl_private_decrypt(base64_decode($input), $output, $this->private_key_resource);

        return $output;

    }
}

//$Rsa = new Rsa;
//$encrypt =$Rsa->encrypt($Rsa->originalData);
//$decrypt = $Rsa->decrypt($encrypt);
//var_dump( base64_encode($encrypt), $decrypt);
//die;