McryptCrypto::decrypt() - Code Metrics - silverstripe/silverstripe-hybridsessions - Measure and Improve Code Quality continuously with Scrutinizer

McryptCrypto::decrypt() A
last analyzed 2019-11-21 03:21 UTC

↳ Parent: McryptCrypto

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	24
rs	9.536
c	0
b	0
f	0
cc	2
nc	2
nop	1

<?php

namespace SilverStripe\HybridSessions\Crypto;

/**
 * Some cryptography used for Session cookie encryption. Requires the mcrypt extension.
 *
 * @deprecated 2.2.0 The PHP mcrypt library is deprecated. Please use OpenSSLCrypto instead.
 *
 * WARNING: Please beware that McryptCrypto does not preserve zero bytes at the end of encrypted messages.
 *          Thus, a message such as "data\x00" will become "data" after encrypt-decrypt.
 *          As such, it is not binary safe.
 *          It is guaranteed for UTF-8 encoded text not to have zero bytes. However, other encodings may contain those.
 *          For example, be careful with UTF-16LE, since characters less than U+0100 are very common.
 */
class McryptCrypto implements CryptoHandler
{
    protected $key;

    protected $ivSize;

    protected $keySize;

    protected $salt;

    protected $saltedKey;

    /**
     * @return string
     */
    public function getKey()
    {
        return $this->key;
    }

    /**
     * @return string
     */
    public function getSalt()
    {
        return $this->salt;
    }

    /**
     * @param $key a per-site secret string which is used as the base encryption key.
     * @param $salt a per-session random string which is used as a salt to generate a per-session key
     *
     * The base encryption key needs to stay secret. If an attacker ever gets it, they can read their session,
     * and even modify & re-sign it.
     *
     * The salt is a random per-session string that is used with the base encryption key to create a per-session key.
     * This (amongst other things) makes sure an attacker can't use a known-plaintext attack to guess the key.
     *
     * Normally we could create a salt on encryption, send it to the client as part of the session (it doesn't
     * need to remain secret), then use the returned salt to decrypt. But we already have the Session ID which makes
     * a great salt, so no need to generate & handle another one.
     */
    public function __construct($key, $salt)
    {
        $this->ivSize = mcrypt_get_iv_size(MCRYPT_RIJNDAEL_256, MCRYPT_MODE_CBC);
        $this->keySize = mcrypt_get_key_size(MCRYPT_RIJNDAEL_256, MCRYPT_MODE_CBC);

        $this->key = $key;
        $this->salt = $salt;
        $this->saltedKey = hash_pbkdf2('sha256', $this->key, $this->salt, 1000, $this->keySize, true);
    }

    /**
     * Encrypt and then sign some cleartext
     *
     * @param $cleartext - The cleartext to encrypt and sign
     * @return string - The encrypted-and-signed message as base64 ASCII.
     */
    public function encrypt($cleartext)
    {
        $iv = mcrypt_create_iv($this->ivSize, MCRYPT_DEV_URANDOM);

        $enc = mcrypt_encrypt(
            MCRYPT_RIJNDAEL_256,
            $this->saltedKey,
            $cleartext,
            MCRYPT_MODE_CBC,
            $iv
        );

        $hash = hash_hmac('sha256', $enc, $this->saltedKey);

        return base64_encode($iv . $hash . $enc);
    }

    /**
     * Check the signature on an encrypted-and-signed message, and if valid
     * decrypt the content
     *
     * @param $data - The encrypted-and-signed message as base64 ASCII
     *
     * @return bool|string - The decrypted cleartext or false if signature failed
     */
    public function decrypt($data)
    {
        $data = base64_decode($data);

        $iv   = substr($data, 0, $this->ivSize);
        $hash = substr($data, $this->ivSize, 64);
        $enc  = substr($data, $this->ivSize + 64);

        $cleartext = rtrim(mcrypt_decrypt(
            MCRYPT_RIJNDAEL_256,
            $this->saltedKey,
            $enc,
            MCRYPT_MODE_CBC,
            $iv
        ), "\x00");

        // Needs to be after decrypt so it always runs, to avoid timing attack
        $gen_hash = hash_hmac('sha256', $enc, $this->saltedKey);

        if ($gen_hash == $hash) {
            return $cleartext;
        }
        return false;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }
}


1			<?php
2
3			namespace SilverStripe\HybridSessions\Crypto;
4
5			/**
6			* Some cryptography used for Session cookie encryption. Requires the mcrypt extension.
7			*
8			* @deprecated 2.2.0 The PHP mcrypt library is deprecated. Please use OpenSSLCrypto instead.
9			*
10			* WARNING: Please beware that McryptCrypto does not preserve zero bytes at the end of encrypted messages.
11			* Thus, a message such as "data\x00" will become "data" after encrypt-decrypt.
12			* As such, it is not binary safe.
13			* It is guaranteed for UTF-8 encoded text not to have zero bytes. However, other encodings may contain those.
14			* For example, be careful with UTF-16LE, since characters less than U+0100 are very common.
15			*/
16			class McryptCrypto implements CryptoHandler
17			{
18			protected $key;
19
20			protected $ivSize;
21
22			protected $keySize;
23
24			protected $salt;
25
26			protected $saltedKey;
27
28			/**
29			* @return string
30			*/
31			public function getKey()
32			{
33			return $this->key;
34			}
35
36			/**
37			* @return string
38			*/
39			public function getSalt()
40			{
41			return $this->salt;
42			}
43
44			/**
45			* @param $key a per-site secret string which is used as the base encryption key.
46			* @param $salt a per-session random string which is used as a salt to generate a per-session key
47			*
48			* The base encryption key needs to stay secret. If an attacker ever gets it, they can read their session,
49			* and even modify & re-sign it.
50			*
51			* The salt is a random per-session string that is used with the base encryption key to create a per-session key.
52			* This (amongst other things) makes sure an attacker can't use a known-plaintext attack to guess the key.
53			*
54			* Normally we could create a salt on encryption, send it to the client as part of the session (it doesn't
55			* need to remain secret), then use the returned salt to decrypt. But we already have the Session ID which makes
56			* a great salt, so no need to generate & handle another one.
57			*/
58			public function __construct($key, $salt)
59			{
60			$this->ivSize = mcrypt_get_iv_size(MCRYPT_RIJNDAEL_256, MCRYPT_MODE_CBC);
61			$this->keySize = mcrypt_get_key_size(MCRYPT_RIJNDAEL_256, MCRYPT_MODE_CBC);
62
63			$this->key = $key;
64			$this->salt = $salt;
65			$this->saltedKey = hash_pbkdf2('sha256', $this->key, $this->salt, 1000, $this->keySize, true);
66			}
67
68			/**
69			* Encrypt and then sign some cleartext
70			*
71			* @param $cleartext - The cleartext to encrypt and sign
72			* @return string - The encrypted-and-signed message as base64 ASCII.
73			*/
74			public function encrypt($cleartext)
75			{
76			$iv = mcrypt_create_iv($this->ivSize, MCRYPT_DEV_URANDOM);
77
78			$enc = mcrypt_encrypt(
79			MCRYPT_RIJNDAEL_256,
80			$this->saltedKey,
81			$cleartext,
82			MCRYPT_MODE_CBC,
83			$iv
84			);
85
86			$hash = hash_hmac('sha256', $enc, $this->saltedKey);
87
88			return base64_encode($iv . $hash . $enc);
89			}
90
91			/**
92			* Check the signature on an encrypted-and-signed message, and if valid
93			* decrypt the content
94			*
95			* @param $data - The encrypted-and-signed message as base64 ASCII
96			*
97			* @return bool\|string - The decrypted cleartext or false if signature failed
98			*/
99			public function decrypt($data)
100			{
101			$data = base64_decode($data);
102
103			$iv = substr($data, 0, $this->ivSize);
104			$hash = substr($data, $this->ivSize, 64);
105			$enc = substr($data, $this->ivSize + 64);
106
107			$cleartext = rtrim(mcrypt_decrypt(
108			MCRYPT_RIJNDAEL_256,
109			$this->saltedKey,
110			$enc,
111			MCRYPT_MODE_CBC,
112			$iv
113			), "\x00");
114
115			// Needs to be after decrypt so it always runs, to avoid timing attack
116			$gen_hash = hash_hmac('sha256', $enc, $this->saltedKey);
117
118			if ($gen_hash == $hash) {
119			return $cleartext;
120			}
121			return false;
			0 ignored issues – show Bug Best Practice introduced 2017-09-20 05:27 UTC by Report Bug Copy Issue Report The return type of `return false;` (`false`) is incompatible with the return type declared by the interface `SilverStripe\HybridSessi...\CryptoHandler::decrypt` of type `string`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
122			}
123			}
124

silverstripe / silverstripe-hybridsessions

McryptCrypto::decrypt() A last analyzed 2019-11-21 03:21 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

McryptCrypto::decrypt() A
last analyzed 2019-11-21 03:21 UTC