Signature::get() - Code Metrics - Inspection of "Cleanup" - humbug/box - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( bc7d7f...7a9596 )

by Théo
created 2017-12-03 15:44 UTC
Signature::get() C

↳ Parent: Signature
Complexity

Conditions	8
Paths	22
Size

Total Lines	63
Code Lines	35
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
dl	0
loc	63
c	0
b	0
f	0
rs	6.8825
cc	8
eloc	35
nc	22
nop	1
How to fix Long Method

<?php

declare(strict_types=1);

/*
 * This file is part of the box project.
 *
 * (c) Kevin Herrera <[email protected]>
 *     Théo Fidry <[email protected]>
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

namespace KevinGH\Box;

use KevinGH\Box\Exception\Exception;
use KevinGH\Box\Exception\FileException;
use KevinGH\Box\Exception\OpenSslException;
use KevinGH\Box\Signature\Hash;
use KevinGH\Box\Signature\PublicKeyDelegate;
use KevinGH\Box\Signature\VerifyInterface;
use PharException;

/**
 * Retrieves and verifies a phar's signature without using the extension.
 *
 * While the phar extension is not used to retrieve or verify a phar's
 * signature, other extensions may still be needed to properly process
 * the signature.
 *
 * @author Kevin Herrera <[email protected]>
 */
class Signature
{
    /**
     * The phar file path.
     *
     * @var string
     */
    private $file;

    /**
     * The file handle.
     *
     * @var resource
     */
    private $handle;

    /**
     * The size of the file.
     *
     * @var int
     */
    private $size;

    /**
     * The recognized signature types.
     *
     * @var array
     */
    private static $types = [
        [
            'name' => 'MD5',
            'flag' => 0x01,
            'size' => 16,
            'class' => Hash::class,
        ],
        [
            'name' => 'SHA-1',
            'flag' => 0x02,
            'size' => 20,
            'class' => Hash::class,
        ],
        [
            'name' => 'SHA-256',
            'flag' => 0x03,
            'size' => 32,
            'class' => Hash::class,
        ],
        [
            'name' => 'SHA-512',
            'flag' => 0x04,
            'size' => 64,
            'class' => Hash::class,
        ],
        [
            'name' => 'OpenSSL',
            'flag' => 0x10,
            'size' => null,
            'class' => PublicKeyDelegate::class,
        ],
    ];

    /**
     * Sets the phar file path.
     *
     * @param string $path the phar file path
     *
     * @throws Exception
     * @throws FileException if the file does not exist
     */
    public function __construct($path)
    {
        if (!is_file($path)) {
            throw FileException::create(
                'The path "%s" does not exist or is not a file.',
                $path
            );
        }

        $this->file = realpath($path);
class Id
{
    public $id;

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

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}

        if (false === ($this->size = @filesize($path))) {
            throw FileException::lastError();
        }
    }

    /**
     * Closes the open file handle.
     */
    public function __destruct()
    {
        $this->close();
    }

    /**
     * Creates a new instance of Signature.
     *
     * @param string $path the phar file path
     *
     * @return Signature the new instance
     */
    public static function create($path)
    {
        return new self($path);
    }

    /**
     * Returns the signature for the phar.
     *
     * The value returned is identical to that of `Phar->getSignature()`. If
     * $required is not given, it will default to the `phar.require_hash`
     * current value.
     *
     * @param bool $required Is the signature required?
     *
     * @throws PharException if the phar is not valid
     *
     * @return array the signature
     */
    public function get($required = null)
    {
        if (null === $required) {
            $required = (bool) ini_get('phar.require_hash');
        }

        $this->seek(-4, SEEK_END);

        if ('GBMB' !== $this->read(4)) {
            if ($required) {
                throw new PharException(
                    sprintf(
                        'The phar "%s" is not signed.',
                        $this->file
                    )
                );
            }

            return null;
        }

        $this->seek(-8, SEEK_END);

        $flag = unpack('V', $this->read(4));
        $flag = /** @scrutinizer ignore-call */ unpack('V', $this->read(4));
        $flag = $flag[1];

        foreach (self::$types as $type) {
            if ($flag === $type['flag']) {
                break;
            }

            unset($type);
        }

        if (!isset($type)) {
            throw new PharException(
                sprintf(
                    'The signature type (%x) is not recognized for the phar "%s".',
                    $flag,
                    $this->file
                )
            );
        }

        $offset = -8;

        if (0x10 === $type['flag']) {

            $offset = -12;

            $this->seek(-12, SEEK_END);

            $type['size'] = unpack('V', $this->read(4));
            $type['size'] = $type['size'][1];
        }

        $this->seek($offset - $type['size'], SEEK_END);

        $hash = $this->read($type['size']);
        $hash = unpack('H*', $hash);

        return [
            'hash_type' => $type['name'],
            'hash' => strtoupper($hash[1]),
        ];
    }

    /**
     * Verifies the signature of the phar.
     *
     * @throws Exception
     * @throws FileException    if the private key could not be read
     * @throws OpenSslException if there is an OpenSSL error
     *
     * @return bool TRUE if verified, FALSE if not
     */
    public function verify()
    {
        $signature = $this->get();

        $size = $this->size;
        $type = null;

        foreach (self::$types as $type) {
            if ($type['name'] === $signature['hash_type']) {
                if (0x10 === $type['flag']) {
                    $this->seek(-12, SEEK_END);

                    $less = $this->read(4);
                    $less = unpack('V', $less);
                    $less = /** @scrutinizer ignore-call */ unpack('V', $less);
                    $less = $less[1];

                    $size -= 12 + $less;
                } else {
                    $size -= 8 + $type['size'];
                }

                break;
            }
        }

        $this->seek(0);

        /** @var $verify VerifyInterface */
        $verify = new $type['class']();
        $verify->init($type['name'], $this->file);

        $buffer = 64;

        while (0 < $size) {
            if ($size < $buffer) {
                $buffer = $size;
                $size = 0;
            }

            $verify->update($this->read($buffer));

            $size -= $buffer;
        }

        return $verify->verify($signature['hash']);
    }

    /**
     * Closes the open file handle.
     */
    private function close(): void
    {
        if (is_resource($this->handle)) {
            @fclose($this->handle);
            /** @scrutinizer ignore-unhandled */ @fclose($this->handle);

            $this->handle = null;
        }
    }

    /**
     * Returns the file handle.
     *
     * If the file handle is not opened, it will be automatically opened.
     *
     * @throws Exception
     * @throws FileException if the file could not be opened
     *
     * @return resource the file handle
     */
    private function handle()
    {
        if (!$this->handle) {
            if (!($this->handle = @fopen($this->file, 'rb'))) {
class Id
{
    public $id;

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

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}
                throw FileException::lastError();
            }
        }

        return $this->handle;

    }

    /**
     * Reads a number of bytes from the file.
     *
     * @param int $bytes the number of bytes
     *
     * @throws Exception
     * @throws FileException if the file could not be read
     *
     * @return string the read bytes
     */
    private function read($bytes)
    {
        if (false === ($read = @fread($this->handle(), $bytes))) {
            throw FileException::lastError();
        }

        if (($actual = strlen($read)) !== $bytes) {
            throw FileException::create(
                'Only read %d of %d bytes from "%s".',
                $actual,
                $bytes,
                $this->file
            );
        }

        return $read;
    }

    /**
     * Seeks to a specific point in the file.
     *
     * @param int $offset the offset to seek
     * @param int $whence the direction
     *
     * @throws Exception
     * @throws FileException if the file could not be seeked
     */
    private function seek($offset, $whence = SEEK_SET): void
    {
        if (-1 === @fseek($this->handle(), $offset, $whence)) {
            throw FileException::lastError();
        }
    }
}

humbug / box

Push — master ( bc7d7f...7a9596 )

Signature::get() C

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like
