Zend_Filter_Encrypt_Openssl Class Reference

Inheritance diagram for Zend_Filter_Encrypt_Openssl:

Public Member Functions
	__construct ($options=array())
	getPublicKey ()
	setPublicKey ($key)
	getPrivateKey ()
	setPrivateKey ($key, $passphrase=null)
	getEnvelopeKey ()
	setEnvelopeKey ($key)
	getPassphrase ()
	setPassphrase ($passphrase)
	getCompression ()
	setCompression ($compression)
	getPackage ()
	setPackage ($package)
	encrypt ($value)
	decrypt ($value)
	toString ()

Protected Member Functions
	_setKeys ($keys)

Protected Attributes
	$_keys
	$_passphrase
	$_compression
	$_package = false

Detailed Description

Definition at line 35 of file Openssl.php.

Constructor & Destructor Documentation

__construct()

__construct

(

$options = array()

)

Class constructor Available options 'public' => public key 'private' => private key 'envelope' => envelope key 'passphrase' => passphrase 'compression' => compress value with this compression adapter 'package' => pack envelope keys into encrypted string, simplifies decryption

Parameters

string | array

$options

Options for this adapter

Definition at line 84 of file Openssl.php.

    {
        if (!extension_loaded('openssl')) {
            #require_once 'Zend/Filter/Exception.php';
            throw new Zend_Filter_Exception('This filter needs the openssl extension');
        }

        if ($options instanceof Zend_Config) {
            $options = $options->toArray();
        }

        if (!is_array($options)) {
            $options = array('public' => $options);
        }

        if (array_key_exists('passphrase', $options)) {
            $this->setPassphrase($options['passphrase']);
            unset($options['passphrase']);
        }

        if (array_key_exists('compression', $options)) {
            $this->setCompression($options['compression']);
            unset($options['compress']);
        }

        if (array_key_exists('package', $options)) {
            $this->setPackage($options['package']);
            unset($options['package']);
        }

        $this->_setKeys($options);
    }

Member Function Documentation

_setKeys()

_setKeys (   $keys )

protected

Sets the encryption keys

Parameters

string | array

$keys

Key with type association

Returns

Zend_Filter_Encrypt_Openssl

Definition at line 123 of file Openssl.php.

    {
        if (!is_array($keys)) {
            #require_once 'Zend/Filter/Exception.php';
            throw new Zend_Filter_Exception('Invalid options argument provided to filter');
        }

        foreach ($keys as $type => $key) {
            if (ctype_print($key) && is_file(realpath($key)) && is_readable($key)) {
                $file = fopen($key, 'r');
                $cert = fread($file, 8192);
                fclose($file);
            } else {
                $cert = $key;
                $key  = count($this->_keys[$type]);
            }

            switch ($type) {
                case 'public':
                    $test = openssl_pkey_get_public($cert);
                    if ($test === false) {
                        #require_once 'Zend/Filter/Exception.php';
                        throw new Zend_Filter_Exception("Public key '{$cert}' not valid");
                    }

                    openssl_free_key($test);
                    $this->_keys['public'][$key] = $cert;
                    break;
                case 'private':
                    $test = openssl_pkey_get_private($cert, $this->_passphrase);
                    if ($test === false) {
                        #require_once 'Zend/Filter/Exception.php';
                        throw new Zend_Filter_Exception("Private key '{$cert}' not valid");
                    }

                    openssl_free_key($test);
                    $this->_keys['private'][$key] = $cert;
                    break;
                case 'envelope':
                    $this->_keys['envelope'][$key] = $cert;
                    break;
                default:
                    break;
            }
        }

        return $this;
    }

decrypt()

decrypt

(

$value

)

Defined by Zend_Filter_Interface

Decrypts $value with the defined settings

Parameters

string

$value

Content to decrypt

Returns

string The decrypted content

Exceptions

Zend_Filter_Exception

Implements Zend_Filter_Encrypt_Interface.

Definition at line 421 of file Openssl.php.

    {
        $decrypted = "";
        $envelope  = current($this->getEnvelopeKey());

        if (count($this->_keys['private']) !== 1) {
            #require_once 'Zend/Filter/Exception.php';
            throw new Zend_Filter_Exception('Please give a private key for decryption with Openssl');
        }

        if (!$this->_package && empty($envelope)) {
            #require_once 'Zend/Filter/Exception.php';
            throw new Zend_Filter_Exception('Please give a envelope key for decryption with Openssl');
        }

        foreach($this->_keys['private'] as $key => $cert) {
            $keys = openssl_pkey_get_private($cert, $this->getPassphrase());
        }

        if ($this->_package) {
            $details = openssl_pkey_get_details($keys);
            if ($details !== false) {
                $fingerprint = md5($details['key']);
            } else {
                $fingerprint = md5("ZendFramework");
            }

            $count = unpack('ncount', $value);
            $count = $count['count'];
            $length  = 2;
            for($i = $count; $i > 0; --$i) {
                $header = unpack('H32print/nsize', substr($value, $length, 18));
                $length  += 18;
                if ($header['print'] == $fingerprint) {
                    $envelope = substr($value, $length, $header['size']);
                }

                $length += $header['size'];
            }

            // remainder of string is the value to decrypt
            $value = substr($value, $length);
        }

        $crypt  = openssl_open($value, $decrypted, $envelope, $keys);
        openssl_free_key($keys);

        if ($crypt === false) {
            #require_once 'Zend/Filter/Exception.php';
            throw new Zend_Filter_Exception('Openssl was not able to decrypt you content with the given options');
        }

        // decompress after decryption
        if (!empty($this->_compression)) {
            #require_once 'Zend/Filter/Decompress.php';
            $decompress = new Zend_Filter_Decompress($this->_compression);
            $decrypted  = $decompress->filter($decrypted);
        }

        return $decrypted;
    }

encrypt()

encrypt

(

$value

)

Encrypts $value with the defined settings Note that you also need the "encrypted" keys to be able to decrypt

Parameters

string

$value

Content to encrypt

Returns

string The encrypted content

Exceptions

Zend_Filter_Exception

Implements Zend_Filter_Encrypt_Interface.

Definition at line 354 of file Openssl.php.

    {
        $encrypted     = array();
        $encryptedkeys = array();

        if (count($this->_keys['public']) == 0) {
            #require_once 'Zend/Filter/Exception.php';
            throw new Zend_Filter_Exception('Openssl can not encrypt without public keys');
        }

        $keys         = array();
        $fingerprints = array();
        $count        = -1;
        foreach($this->_keys['public'] as $key => $cert) {
            $keys[$key] = openssl_pkey_get_public($cert);
            if ($this->_package) {
                $details = openssl_pkey_get_details($keys[$key]);
                if ($details === false) {
                    $details = array('key' => 'ZendFramework');
                }

                ++$count;
                $fingerprints[$count] = md5($details['key']);
            }
        }

        // compress prior to encryption
        if (!empty($this->_compression)) {
            #require_once 'Zend/Filter/Compress.php';
            $compress = new Zend_Filter_Compress($this->_compression);
            $value    = $compress->filter($value);
        }

        $crypt  = openssl_seal($value, $encrypted, $encryptedkeys, $keys);
        foreach ($keys as $key) {
            openssl_free_key($key);
        }

        if ($crypt === false) {
            #require_once 'Zend/Filter/Exception.php';
            throw new Zend_Filter_Exception('Openssl was not able to encrypt your content with the given options');
        }

        $this->_keys['envelope'] = $encryptedkeys;

        // Pack data and envelope keys into single string
        if ($this->_package) {
            $header = pack('n', count($this->_keys['envelope']));
            foreach($this->_keys['envelope'] as $key => $envKey) {
                $header .= pack('H32n', $fingerprints[$key], strlen($envKey)) . $envKey;
            }

            $encrypted = $header . $encrypted;
        }

        return $encrypted;
    }

getCompression()

getCompression

(

)

Returns the compression

Returns

array

Definition at line 303 of file Openssl.php.

    {
        return $this->_compression;
    }

getEnvelopeKey()

getEnvelopeKey

(

)

Returns all envelope keys

Returns

array

Definition at line 248 of file Openssl.php.

    {
        $key = $this->_keys['envelope'];
        return $key;
    }

getPackage()

getPackage

(

)

Returns if header should be packaged

Returns

boolean

Definition at line 329 of file Openssl.php.

    {
        return $this->_package;
    }

getPassphrase()

getPassphrase

(

)

Returns the passphrase

Returns

string

Definition at line 281 of file Openssl.php.

    {
        return $this->_passphrase;
    }

getPrivateKey()

getPrivateKey

(

)

Returns all private keys

Returns

array

Definition at line 210 of file Openssl.php.

    {
        $key = $this->_keys['private'];
        return $key;
    }

getPublicKey()

getPublicKey

(

)

Returns all public keys

Returns

array

Definition at line 177 of file Openssl.php.

    {
        $key = $this->_keys['public'];
        return $key;
    }

setCompression()

setCompression

(

$compression

)

Sets a internal compression for values to encrypt

Parameters

string | array

$compression

Returns

Zend_Filter_Encrypt_Openssl

Definition at line 314 of file Openssl.php.

    {
        if (is_string($this->_compression)) {
            $compression = array('adapter' => $compression);
        }

        $this->_compression = $compression;
        return $this;
    }

setEnvelopeKey()

setEnvelopeKey

(

$key

)

Sets envelope keys

Parameters

string | array

$options

Envelope keys

Returns

Zend_Filter_Encrypt_Openssl

Definition at line 260 of file Openssl.php.

    {
        if (is_array($key)) {
            foreach($key as $type => $option) {
                if ($type !== 'envelope') {
                    $key['envelope'] = $option;
                    unset($key[$type]);
                }
            }
        } else {
            $key = array('envelope' => $key);
        }

        return $this->_setKeys($key);
    }

setPackage()

setPackage

(

$package

)

Sets if the envelope keys should be included in the encrypted value

Parameters

boolean

$package

Returns

Zend_Filter_Encrypt_Openssl

Definition at line 340 of file Openssl.php.

    {
        $this->_package = (boolean) $package;
        return $this;
    }

setPassphrase()

setPassphrase

(

$passphrase

)

Sets a new passphrase

Parameters

string

$passphrase

Returns

Zend_Filter_Encrypt_Openssl

Definition at line 292 of file Openssl.php.

    {
        $this->_passphrase = $passphrase;
        return $this;
    }

setPrivateKey()

setPrivateKey	(		$key,
			$passphrase = null
	)

Sets private keys

Parameters

string	$key	Private key
string	$passphrase

Returns

Zend_Filter_Encrypt_Openssl

Definition at line 223 of file Openssl.php.

    {
        if (is_array($key)) {
            foreach($key as $type => $option) {
                if ($type !== 'private') {
                    $key['private'] = $option;
                    unset($key[$type]);
                }
            }
        } else {
            $key = array('private' => $key);
        }

        if ($passphrase !== null) {
            $this->setPassphrase($passphrase);
        }

        return $this->_setKeys($key);
    }

setPublicKey()

setPublicKey

(

$key

)

Sets public keys

Parameters

string | array

$key

Public keys

Returns

Zend_Filter_Encrypt_Openssl

Definition at line 189 of file Openssl.php.

    {
        if (is_array($key)) {
            foreach($key as $type => $option) {
                if ($type !== 'public') {
                    $key['public'] = $option;
                    unset($key[$type]);
                }
            }
        } else {
            $key = array('public' => $key);
        }

        return $this->_setKeys($key);
    }

toString()

toString

(

)

Returns the adapter name

Returns

string

Definition at line 488 of file Openssl.php.

    {
        return 'Openssl';
    }

Field Documentation

$_compression

$_compression

protected

Definition at line 63 of file Openssl.php.

$_keys

$_keys

protected

Initial value:

= array(
        'public'   => array(),
        'private'  => array(),
        'envelope' => array()
    )

Definitions for encryption array( 'public' => public keys 'private' => private keys 'envelope' => resulting envelope keys )

Definition at line 45 of file Openssl.php.

$_package

$_package = false

protected

Definition at line 70 of file Openssl.php.

$_passphrase

$_passphrase

protected

Definition at line 56 of file Openssl.php.

---

The documentation for this class was generated from the following file:

• vendor/magento/zendframework1/library/Zend/Filter/Encrypt/Openssl.php