Xcloner_Encryption::decrypt_file() - Code Metrics - Inspection of "scrutinizer fixes" - ovidiul/XCloner-Wordpress - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — dev (953bb6)

by Liuta

created 2019-01-13 14:32 UTC

Xcloner_Encryption::decrypt_file() F

↳ Parent: Xcloner_Encryption

Complexity

Conditions	25
Paths	2176

Size

Total Lines

118

Duplication

Lines	33
Ratio	27.97 %

Importance

Changes

Metric	Value
cc	25
nc	2176
nop	6
dl	33
loc	118
rs	0
c	0
b	0
f	0

How to fix Long Method Complexity

<?php
/**
 * Created by PhpStorm.
 * User: thinkovi
 * Date: 2018-11-27
 * Time: 12:11
 */

//namespace XCloner;

class Xcloner_Encryption
{
    const FILE_ENCRYPTION_BLOCKS = 1024*1024;
    const FILE_ENCRYPTION_SUFFIX = ".encrypted";
    const FILE_DECRYPTION_SUFFIX = ".decrypted";

    private $xcloner_settings;
    private $logger;
    private $verification = false;

    public function __construct(Xcloner $xcloner_container)
    {
        $this->xcloner_container = $xcloner_container;
class MyClass { }

$x = new MyClass();
$x->foo = true;
        if(method_exists($xcloner_container, 'get_xcloner_settings')) {
            $this->xcloner_settings = $xcloner_container->get_xcloner_settings();

        }else{
            $this->xcloner_settings = "";
        }

        if(method_exists($xcloner_container, 'get_xcloner_logger')) {
            $this->logger = $xcloner_container->get_xcloner_logger()->withName("xcloner_encryption");

        }else{
            $this->logger = "";
        }
    }

    /**
     * Returns the backup encryption key
     *
     * @return SECURE_AUTH_SALT|null
     */
    public function get_backup_encryption_key()
    {
        if(is_object($this->xcloner_settings)) {
            return $this->xcloner_settings->get_xcloner_encryption_key();
        }

        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());
}

    }

    /**
     * Check if provided filename has encrypted suffix
     *
     * @param $filename
     * @return bool
     */
    public function is_encrypted_file($filename) {
        $fp = fopen($this->get_xcloner_path() .$filename, 'r');
        $encryption_length = fread($fp, 16);
        fclose($fp);
        if(is_numeric($encryption_length)) {
            return true;
        }

        return false;

    }

    /**
     * Returns the filename with encrypted suffix
     *
     * @param $filename
     * @return string
     */
    public function get_encrypted_target_backup_file_name( $filename ) {

        return str_replace(self::FILE_DECRYPTION_SUFFIX, "", $filename) . self::FILE_ENCRYPTION_SUFFIX;
    }

    /**
     * Returns the filename without encrypted suffix
     *
     * @param $filename
     * @return string
     */
    public function get_decrypted_target_backup_file_name( $filename ) {

        return str_replace(self::FILE_ENCRYPTION_SUFFIX, "", $filename) . self::FILE_DECRYPTION_SUFFIX;
    }

    /**
     * Encrypt the passed file and saves the result in a new file with ".enc" as suffix.
     *
     * @param string $source Path to file that should be encrypted
     * @param string $dest   File name where the encryped file should be written to.
     * @param string $key    The key used for the encryption
     * @param int $start   Start position for reading when doing incremental mode.
     * @param string $iv   The IV key to use.
     * @param bool $verfication   Weather we should we try to verify the decryption.
/**
 * @param array $germany
 * @param array $ireland
 */
function finale($germany, $island) {
    return "2:1";
}
     * @return string|false  Returns the file name that has been created or FALSE if an error occured
    */
    public function encrypt_file($source, $dest = "" , $key= "", $start = 0, $iv = 0, $verification = true, $recursive = false)
    {
        if(is_object($this->logger)) {

            $this->logger->info(sprintf('Encrypting file %s at position %d IV %s', $source, $start, base64_encode($iv)));
        }

        //$key = substr(sha1($key, true), 0, 16);
        if(!$key){
            $key = self::get_backup_encryption_key();
        }
        $key_digest = openssl_digest ($key, "md5", true);

        $keep_local = 1;
        if(!$dest) {
            $dest = $this->get_encrypted_target_backup_file_name($source);
            $keep_local = 0;
        }

        if(!$iv || !$start) {
            //$iv = openssl_random_pseudo_bytes(16);
            $iv = str_pad(self::FILE_ENCRYPTION_BLOCKS, 16, "0000000000000000", STR_PAD_LEFT);
        }

        if( !$start ) {
            $fpOut = fopen($this->get_xcloner_path() .$dest, 'w');
        }else{
            $fpOut = fopen($this->get_xcloner_path() .$dest, 'a');
        }

        if ( $fpOut ) {

            // Put the initialization vector to the beginning of the file
            if(!$start) {
                fwrite($fpOut, $iv);
            }

            if (file_exists($this->get_xcloner_path() .$source) &&
                $fpIn = fopen($this->get_xcloner_path() .$source, 'rb')) {

                fseek($fpIn, (int)$start);

                if (!feof($fpIn)) {

                    $plaintext = fread($fpIn, 16 * self::FILE_ENCRYPTION_BLOCKS);
                    $ciphertext = openssl_encrypt($plaintext, 'AES-128-CBC', $key_digest, OPENSSL_RAW_DATA, $iv);

                    // Use the first 16 bytes of the ciphertext as the next initialization vector
                    $iv = substr($ciphertext, 0, 16);
                    //$iv = openssl_random_pseudo_bytes(16);

                    fwrite($fpOut, $ciphertext);

                    $start = ftell($fpIn);

                    fclose($fpOut );

                    if(!feof($fpIn)) {
                        fclose($fpIn);
                        //echo "\n NEW:".$key.md5($iv);
                        //self::encryptFile($source, $dest, $key, $start, $iv);
                        if($recursive ){
                            $this->encrypt_file($source, $dest, $key, $start, ($iv), $verification, $recursive);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
                        }else {


                            if(($iv) != base64_decode(base64_encode($iv)))
                            {
                                throw new \Exception('Could not encode IV for transport');
                            }

                            return array(
                                "start" => $start,
                                "iv" => base64_encode($iv),
                                "target_file" => $dest,
                                "finished" => 0
                            );
                        }
                    }

                }
            } else {
                if(is_object($this->logger)) {
                    $this->logger->error('Unable to read source file for encryption.');
                }
                throw new \Exception("Unable to read source file for encryption.");
            }
        } else {
            if(is_object($this->logger)) {
                $this->logger->error('Unable to write destination file for encryption.');
            }
            throw new \Exception("Unable to write destination file for encryption.");
        }

        if($verification) {
            $this->verify_encrypted_file($dest);
        }

        //we replace the original backup with the encrypted one
        if( !$keep_local && copy($this->get_xcloner_path() .$dest,

             $this->get_xcloner_path() .$source) ) {
            unlink($this->get_xcloner_path() .$dest);
        }


        return array("target_file" => $dest, "finished" => 1);
    }

    public function verify_encrypted_file($file) {
        if(is_object($this->logger)) {
            $this->logger->info(sprintf('Verifying encrypted file %s', $file));
        }

        $this->verification = true;
        $this->decrypt_file($file);
        $this->verification = false;
    }

    /**
     * Dencrypt the passed file and saves the result in a new file, removing the
     * last 4 characters from file name.
     *
     * @param string $source Path to file that should be decrypted
     * @param string $dest   File name where the decryped file should be written to.
     * @param string $key    The key used for the decryption (must be the same as for encryption)
     * @param int $start   Start position for reading when doing incremental mode.
     * @param string $iv   The IV key to use.
     * @return string|false  Returns the file name that has been created or FALSE if an error occured
     */
    public function decrypt_file($source, $dest = "", $key = "", $start = 0, $iv = 0, $recursive = false)
    {
        if(is_object($this->logger)) {

            $this->logger->info(sprintf('Decrypting file %s at position %d with IV %s', $source, $start, base64_encode($iv)));
        }

        //$key = substr(sha1($key, true), 0, 16);
        if(!$key){
            $key = self::get_backup_encryption_key();
        }

        $key_digest = openssl_digest ($key, "md5", true);

        $keep_local = 1;
        if(!$dest) {
            $dest = $this->get_decrypted_target_backup_file_name($source);
            $keep_local = 0;
        }

        if( !$start ) {
            if($this->verification){

                $fpOut = fopen("php://stdout", 'w');
            }else {
                $fpOut = fopen($this->get_xcloner_path() . $dest, 'w');
            }
        }else{

            if($this->verification){
                $fpOut = fopen("php://stdout", 'a');
            }else {
                $fpOut = fopen($this->get_xcloner_path() . $dest, 'a');
            }
        }

        if ( $fpOut ) {
            if ( file_exists($this->get_xcloner_path() .$source) &&
                $fpIn = fopen($this->get_xcloner_path() .$source, 'rb')) {

                $encryption_length = (int)fread($fpIn, 16);
                if(!$encryption_length) {
                    $encryption_length = self::FILE_ENCRYPTION_BLOCKS;
                }

                fseek($fpIn, (int)$start);

                // Get the initialzation vector from the beginning of the file
                if(!$iv) {
                    $iv = fread($fpIn, 16);
                }

                if (!feof($fpIn)) {

                    // we have to read one block more for decrypting than for encrypting
                    $ciphertext = fread($fpIn, 16 * ($encryption_length + 1));
                    $plaintext = openssl_decrypt($ciphertext, 'AES-128-CBC', $key_digest, OPENSSL_RAW_DATA, $iv);

                    if(!$plaintext){
                        unlink($this->get_xcloner_path() . $dest);
                        if(is_object($this->logger)) {
                            $this->logger->error('Backup decryption failed, please check your provided Encryption Key.');
                        }
                        throw new \Exception("Backup decryption failed, please check your provided Encryption Key.");
                    }

                    // Use the first 16 bytes of the ciphertext as the next initialization vector
                    $iv = substr($ciphertext, 0, 16);

                    if( !$this->verification) {
                        fwrite($fpOut, $plaintext);
                    }

                    $start = ftell($fpIn);

                    fclose($fpOut );

                    if(!feof($fpIn)) {
                        fclose($fpIn);
                        if($this->verification || $recursive) {
                            $ciphertext = "";
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
                            $plaintext = "";
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
                            $this->decrypt_file($source, $dest, $key, $start, $iv, $recursive);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
                        }else {

                            if(($iv) != base64_decode(base64_encode($iv)))
                            {
                                throw new \Exception('Could not encode IV for transport');
                            }

                            return array(
                                "start" => $start,
                                "encryption_length" => $encryption_length,
                                "iv" => base64_encode($iv),
                                "target_file" => $dest,
                                "finished" => 0
                            );
                    }
                    }

                }
            } else {
                if(is_object($this->logger)) {
                    $this->logger->error('Unable to read source file for decryption');
                }
                throw new \Exception("Unable to read source file for decryption");
            }
        } else {
            if(is_object($this->logger)) {
                $this->logger->error('Unable to write destination file for decryption');
            }
            throw new \Exception("Unable to write destination file for decryption");
        }

        //we replace the original backup with the encrypted one
        if( !$keep_local && !$this->verification && copy($this->get_xcloner_path()  .$dest,

            $this->get_xcloner_path()  .$source) ) {
            unlink($this->get_xcloner_path()  .$dest);
        }

        return array("target_file" => $dest, "finished" => 1);
    }

    public function get_xcloner_path(){
        if(is_object($this->xcloner_settings)) {
            return $this->xcloner_settings->get_xcloner_store_path() . DS;
        }

        return null;
    }

}


try {

    if(isset($argv[1])) {

        class Xcloner {
            public function __construct()
            {
            }
        }
        $xcloner_encryption = new Xcloner_Encryption( new Xcloner() );

        if ($argv[1] == "-e") {
            $xcloner_encryption->encrypt_file($argv[2], $argv[2] . ".enc", $argv[4], '', '', '', true);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        } elseif ($argv[1] == "-d") {
            $xcloner_encryption->decrypt_file($argv[2], $argv[2] . ".dec", $argv[4], '', '', true);
        }
    }
}catch(\Exception $e) {
    echo "CAUGHT: " . $e->getMessage();
}


1			<?php
2			/**
3			* Created by PhpStorm.
4			* User: thinkovi
5			* Date: 2018-11-27
6			* Time: 12:11
7			*/
8
9			//namespace XCloner;
10
11			class Xcloner_Encryption
12			{
13			const FILE_ENCRYPTION_BLOCKS = 1024*1024;
14			const FILE_ENCRYPTION_SUFFIX = ".encrypted";
15			const FILE_DECRYPTION_SUFFIX = ".decrypted";
16
17			private $xcloner_settings;
18			private $logger;
19			private $verification = false;
20
21			public function __construct(Xcloner $xcloner_container)
22			{
23			$this->xcloner_container = $xcloner_container;
			0 ignored issues – show Bug introduced 2017-03-18 13:21 UTC by Report Bug Copy Issue Report The property `xcloner_container` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
24			if(method_exists($xcloner_container, 'get_xcloner_settings')) {
25			$this->xcloner_settings = $xcloner_container->get_xcloner_settings();
			0 ignored issues – show Bug introduced 2019-01-13 14:34 UTC by Report Bug Copy Issue Report The method `get_xcloner_settings()` does not seem to exist on `object<Xcloner>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
26			}else{
27			$this->xcloner_settings = "";
28			}
29
30			if(method_exists($xcloner_container, 'get_xcloner_logger')) {
31			$this->logger = $xcloner_container->get_xcloner_logger()->withName("xcloner_encryption");
			0 ignored issues – show Bug introduced 2019-01-13 14:34 UTC by Report Bug Copy Issue Report The method `get_xcloner_logger()` does not seem to exist on `object<Xcloner>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
32			}else{
33			$this->logger = "";
34			}
35			}
36
37			/**

ovidiul / XCloner-Wordpress

GitHub Access Token became invalid

Branch — dev (953bb6)

Xcloner_Encryption::decrypt_file() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like