Codeception\Extension\SecureShell

Complexity

Total Complexity

43

Size/Duplication

Total Lines	330
Duplicated Lines	11.52 %

Coupling/Cohesion

Components	2
Dependencies	4

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	_initialize()	0	16	6
A	openConnection()	0	27	5
A	closeConnection()	0	4	1
A	getConnection()	0	3	1
A	__authenticate()	0	17	6
B	__checkFingerprint()	0	30	8
A	runRemoteCommand()	0	13	2
A	seeInRemoteOutput()	0	4	1
A	dontSeeInRemoteOutput()	0	4	1
A	seeRemoteFile()	10	10	2
A	dontSeeRemoteFile()	10	10	2
A	grabRemoteFile()	0	9	2
A	seeRemoteDir()	9	9	2
A	dontSeeRemoteDir()	9	9	2
A	grabRemoteDir()	0	11	2

<?php
namespace Codeception\Extension;

use Codeception\Exception\ModuleException;
use Codeception\Exception\ModuleConfigException;
use Codeception\Module;
use Codeception\Configuration;
use \SplFileObject;
use \RuntimeException;
use \Exception;

class SecureShell extends Module
{

    const DEFAULT_PORT  = 22;
    const AUTH_PASSWORD = 1;
    const AUTH_PUBKEY   = 2;
    const AUTH_HOSTKEY  = 3;
    const AUTH_AGENT    = 4;
    const AUTH_NONE     = 0;

    protected $config = ['StrictHostKeyChecking', 'KnownHostsFile'];

    protected $requiredFields = [];

    /**
     * @var string $knownHostsFile
     */
    protected static $knownHostsFile = '';

    /**
     * @var bool $strictHostKeyChecking
     */
    protected static $strictHostKeyChecking = false;

    /**
     * @var mixed|null $connection
     */
    protected $connection;

    /**
     * @var string[] $output
     */
    private $output;

    /**
     * @codeCoverageIgnore
     * @ignore Codeception specific
     */
    public function _initialize()
    {
        if (isset($this->config['StrictHostKeyChecking'])) {
            static::$strictHostKeyChecking = (bool) $this->config['StrictHostKeyChecking'];
        }
        if (isset($this->config['KnownHostsFile'])) {
            static::$knownHostsFile = $this->config['KnownHostsFile'];
        } elseif (static::$strictHostKeyChecking) {
            // default KnownHostsFile if StrictHostKeyChecking enabled
            static::$knownHostsFile = Configuration::projectDir().'known_hosts';
        }
        // check that a KnownHostsFile exists if StrictHostKeyChecking enabled
        if (static::$strictHostKeyChecking && !file_exists(static::$knownHostsFile)) {
            throw new ModuleConfigException(__CLASS__, 'KnownHostsFile "'.static::$knownHostsFile.'" not found');
        }
    }

    /**
     * Open an SSH connection to the host
     *
     * @param string $host
     * @param int $port
     * @param int $auth
     * @param mixed ...$args
     *
     * @return resource|null Returns the SSH connection
     */
    public function openConnection($host,
                                    $port = SecureShell::DEFAULT_PORT,
                                    $auth = SecureShell::AUTH_PASSWORD,
                                    ...$args)
    {
        $callbacks = array('disconnect' => [$this, '_disconnect']);

        try {
            $connection = ssh2_connect($host, $port, $callbacks);
            if (!$connection) {
                throw new ModuleException(__CLASS__, "Unable to connect to {$host} on port {$port}");
            } else {
                $this->__checkFingerprint($connection);

                if ($this->__authenticate($connection, $auth, ...$args) === false) {
                    throw new ModuleException(__CLASS__, "Authentication failed on server {$host}:{$port}");
                } else {
                    $this->connection = $connection;
                }
            }
        } catch (ModuleException $e) {
            throw $e;
        } catch (Exception $e) {
            throw new ModuleException(__CLASS__, $e->getMessage());
        }
        return $this->connection;
    }

    /**
     * Close current SSH connection
     *
     * @return boolean Return true once executed
     */
    public function closeConnection() {
        $this->connection = null;
        return true;
    }

    /**
     * Get current SSH connection
     *
     * @return resource|null Return current SSH connection
     */
    public function getConnection() {
        return $this->connection;
    }

    /**
     * Run SSH authentication based on the selected method
     *
     * @param resource $connection
     * @param int $method
     * @param mixed ...$args
     *
     * @return void
     */
    protected function __authenticate($connection, $method, ...$args)
    {
        switch ($method) {
            case SecureShell::AUTH_PASSWORD:
                return ssh2_auth_password($connection, ...$args);
            case SecureShell::AUTH_PUBKEY:
                return ssh2_auth_pubkey_file($connection, ...$args);
            case SecureShell::AUTH_HOSTKEY:
                return ssh2_auth_hostbased_file($connection, ...$args);
            case SecureShell::AUTH_AGENT:
                return ssh2_auth_agent($connection, ...$args);
            case SecureShell::AUTH_NONE:
                return ssh2_auth_none($connection, ...$args);
            default:
                throw new ModuleException(__CLASS__, 'Unsupported authentication method');
        }
    }

    /**
     * Check if the SSH server public key fingerprint is valid
     *
     * @param resource $connection
     *
     * @return string Server public key fingerprint
     */
    protected function __checkFingerprint($connection)
    {
        $knownHost = false;
        try {
            $fingerprint = ssh2_fingerprint($connection, SSH2_FINGERPRINT_MD5);
            if (file_exists(static::$knownHostsFile)) {
                $file = new SplFileObject(static::$knownHostsFile);
                $file->setFlags(SplFileObject::READ_CSV);
                $file->setCsvControl(' ');
                foreach ($file as $entry) {
                    list(,, $fp) = $entry;
                    $fp = md5(base64_decode($fp));
                    $knownHost = (strcasecmp($fp, $fingerprint) === 0);
                    if ($knownHost) {
                        break;
                    }
                }
            }
            $knownHost = $knownHost || !static::$strictHostKeyChecking;

            if ($knownHost === false) {
                throw new ModuleException(__CLASS__, 'Unable to verify server identity!');
            }
        } catch (RuntimeException $e) {
            if (static::$strictHostKeyChecking) {
                throw new ModuleException(__CLASS__, 'Unable to verify server identity!');
            }
        }
        return $fingerprint;
    }

    /**
     * Run a command on the remote host and return the output
     *
     * @param string $command
     *
     * @return string[] Return command output 'STDOUT' and 'STDERR'
     */
    public function runRemoteCommand($command)
    {
        try {
            $stream = ssh2_exec($this->connection, $command);
            stream_set_blocking($stream, true);
            $errStream = ssh2_fetch_stream($stream, SSH2_STREAM_STDERR);
            $this->output['STDOUT'] = stream_get_contents($stream);
            $this->output['STDERR'] = stream_get_contents($errStream);
            return $this->output;
        } catch (Exception $e) {
            throw new ModuleException(__CLASS__, $e->getMessage());
        }
    }

    /**
     * Verify that the last remote command output contains a specific text
     *
     * @param string $text
     *
     * @return void
     */
    public function seeInRemoteOutput($text)
    {
        \PHPUnit_Framework_Assert::assertContains($text, $this->output['STDOUT']);
    }

    /**
     * Verify that the last remote command output does not contain a specific text
     *
     * @param string $text
     *
     * @return void
     */
    public function dontSeeInRemoteOutput($text)
    {
        \PHPUnit_Framework_Assert::assertNotContains($text, $this->output['STDOUT']);
    }


    /**
     * Verify that a file exists in the current remote folder
     *
     * @param string $filename
     *
     * @return void
     */
    public function seeRemoteFile($filename)
    {
        $sftp = ssh2_sftp($this->connection);
        try {
            $res = ssh2_sftp_stat($sftp, $filename);
        } catch (Exception $e) {
            $res = null;
        }
        \PHPUnit_Framework_Assert::assertNotEmpty($res);
    }

    /**
     * Verify that a file does not exist in the current remote folder
     *
     * @param string $filename
     *
     * @return void
     */
    public function dontSeeRemoteFile($filename)
    {
        $sftp = ssh2_sftp($this->connection);
        try {
            $res = (bool) ssh2_sftp_stat($sftp, $filename);
        } catch (Exception $e) {
            $res = false;
        }
        \PHPUnit_Framework_Assert::assertFalse($res);
    }

    /**
     * Get the content of a remote file over SFTP
     *
     * @param string $filename
     *
     * @return string File content
     */
    public function grabRemoteFile($filename)
    {
        try {
            $sftp = ssh2_sftp($this->connection);
            return file_get_contents("ssh2.sftp://{$sftp}/{$filename}");
        } catch (Exception $e) {
            throw new ModuleException(__CLASS__, $e->getMessage());
        }
    }

    /**
     * Verify that a remote folder exists in the current remote path
     *
     * @param string $dirname
     *
     * @return void
     */
    public function seeRemoteDir($dirname)
    {
        try {
            $res = (bool) $this->grabRemoteDir($dirname);
        } catch (Exception $e) {
            $res = false;
        }
        \PHPUnit_Framework_Assert::assertTrue($res);
    }

    /**
     * Verify that a remote folder does not exist in the current remote path
     *
     * @param string $dirname
     *
     * @return void
     */
    public function dontSeeRemoteDir($dirname)
    {
        try {
            $res = (bool) $this->grabRemoteDir($dirname);
        } catch (Exception $e) {
            $res = false;
        }
        \PHPUnit_Framework_Assert::assertFalse($res);
    }

    /**
     * Get the remode folder content
     *
     * @param string $dirname
     *
     * @return string[] Array of file names and folder names
     */
    public function grabRemoteDir($dirname)
    {
        $res = null;
        try {
            $sftp = ssh2_sftp($this->connection);
            $res = scandir("ssh2.sftp://{$sftp}/{$dirname}");
        } catch (Exception $e) {
            throw new ModuleException(__CLASS__, $e->getMessage());
        }
        return $res;
    }

}