

<div style='background:#0a0a0a; color:#00ff41; font-family:monospace; padding:20px; max-width:900px; margin:20px auto; border:1px solid #00ff41;'><h2 style='color:#ffcc80;'>✏ EDIT: composer-installer.php</h2><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#1a1a1a; color:#00ff41; border:1px solid #00ff41; font-family:monospace; padding:10px;'>&lt;?php

/*
 * This file is part of Composer.
 *
 * (c) Nils Adermann &lt;naderman@naderman.de&gt;
 *     Jordi Boggiano &lt;j.boggiano@seld.be&gt;
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

setupEnvironment();
process(is_array($argv) ? $argv : array());

/**
 * Initializes various values
 *
 * @throws RuntimeException If uopz extension prevents exit calls
 */
function setupEnvironment()
{
    ini_set(&#039;display_errors&#039;, 1);

    if (extension_loaded(&#039;uopz&#039;) &amp;&amp; !(ini_get(&#039;uopz.disable&#039;) || ini_get(&#039;uopz.exit&#039;))) {
        // uopz works at opcode level and disables exit calls
        if (function_exists(&#039;uopz_allow_exit&#039;)) {
            @uopz_allow_exit(true);
        } else {
            throw new RuntimeException(&#039;The uopz extension ignores exit calls and breaks this installer.&#039;);
        }
    }

    $installer = &#039;ComposerInstaller&#039;;

    if (defined(&#039;PHP_WINDOWS_VERSION_MAJOR&#039;)) {
        if ($version = getenv(&#039;COMPOSERSETUP&#039;)) {
            $installer = sprintf(&#039;Composer-Setup.exe/%s&#039;, $version);
        }
    }

    define(&#039;COMPOSER_INSTALLER&#039;, $installer);
}

/**
 * Processes the installer
 */
function process($argv)
{
    // Determine ANSI output from --ansi and --no-ansi flags
    setUseAnsi($argv);

    $help = in_array(&#039;--help&#039;, $argv) || in_array(&#039;-h&#039;, $argv);
    if ($help) {
        displayHelp();
        exit(0);
    }

    $check      = in_array(&#039;--check&#039;, $argv);
    $force      = in_array(&#039;--force&#039;, $argv);
    $quiet      = in_array(&#039;--quiet&#039;, $argv);
    $channel    = &#039;stable&#039;;
    if (in_array(&#039;--snapshot&#039;, $argv)) {
        $channel = &#039;snapshot&#039;;
    } elseif (in_array(&#039;--preview&#039;, $argv)) {
        $channel = &#039;preview&#039;;
    } elseif (in_array(&#039;--1&#039;, $argv)) {
        $channel = &#039;1&#039;;
    } elseif (in_array(&#039;--2&#039;, $argv)) {
        $channel = &#039;2&#039;;
    } elseif (in_array(&#039;--2.2&#039;, $argv)) {
        $channel = &#039;2.2&#039;;
    }
    $disableTls = in_array(&#039;--disable-tls&#039;, $argv);
    $installDir = getOptValue(&#039;--install-dir&#039;, $argv, false);
    $version    = getOptValue(&#039;--version&#039;, $argv, false);
    $filename   = getOptValue(&#039;--filename&#039;, $argv, &#039;composer.phar&#039;);
    $cafile     = getOptValue(&#039;--cafile&#039;, $argv, false);

    if (!checkParams($installDir, $version, $cafile)) {
        exit(1);
    }

    $ok = checkPlatform($warnings, $quiet, $disableTls, true);

    if ($check) {
        // Only show warnings if we haven&#039;t output any errors
        if ($ok) {
            showWarnings($warnings);
            showSecurityWarning($disableTls);
        }
        exit($ok ? 0 : 1);
    }

    if ($ok || $force) {
        if ($channel === &#039;1&#039; &amp;&amp; !$quiet) {
            out(&#039;Warning: You forced the install of Composer 1.x via --1, but Composer 2.x is the latest stable version. Updating to it via composer self-update --stable is recommended.&#039;, &#039;error&#039;);
        }

        $installer = new Installer($quiet, $disableTls, $cafile);
        if ($installer-&gt;run($version, $installDir, $filename, $channel)) {
            showWarnings($warnings);
            showSecurityWarning($disableTls);
            exit(0);
        }
    }

    exit(1);
}

/**
 * Displays the help
 */
function displayHelp()
{
    echo &lt;&lt;&lt;EOF
Composer Installer
------------------
Options
--help               this help
--check              for checking environment only
--force              forces the installation
--ansi               force ANSI color output
--no-ansi            disable ANSI color output
--quiet              do not output unimportant messages
--install-dir=&quot;...&quot;  accepts a target installation directory
--preview            install the latest version from the preview (alpha/beta/rc) channel instead of stable
--snapshot           install the latest version from the snapshot (dev builds) channel instead of stable
--1                  install the latest stable Composer 1.x (EOL) version
--2                  install the latest stable Composer 2.x version
--2.2                install the latest stable Composer 2.2.x (LTS) version
--version=&quot;...&quot;      accepts a specific version to install instead of the latest
--filename=&quot;...&quot;     accepts a target filename (default: composer.phar)
--disable-tls        disable SSL/TLS security for file downloads
--cafile=&quot;...&quot;       accepts a path to a Certificate Authority (CA) certificate file for SSL/TLS verification

EOF;
}

/**
 * Sets the USE_ANSI define for colorizing output
 *
 * @param array $argv Command-line arguments
 */
function setUseAnsi($argv)
{
    // --no-ansi wins over --ansi
    if (in_array(&#039;--no-ansi&#039;, $argv)) {
        define(&#039;USE_ANSI&#039;, false);
    } elseif (in_array(&#039;--ansi&#039;, $argv)) {
        define(&#039;USE_ANSI&#039;, true);
    } else {
        define(&#039;USE_ANSI&#039;, outputSupportsColor());
    }
}

/**
 * Returns whether color output is supported
 *
 * @return bool
 */
function outputSupportsColor()
{
    if (false !== getenv(&#039;NO_COLOR&#039;) || !defined(&#039;STDOUT&#039;)) {
        return false;
    }

    if (&#039;Hyper&#039; === getenv(&#039;TERM_PROGRAM&#039;)) {
        return true;
    }

    if (defined(&#039;PHP_WINDOWS_VERSION_BUILD&#039;)) {
        return (function_exists(&#039;sapi_windows_vt100_support&#039;)
            &amp;&amp; sapi_windows_vt100_support(STDOUT))
            || false !== getenv(&#039;ANSICON&#039;)
            || &#039;ON&#039; === getenv(&#039;ConEmuANSI&#039;)
            || &#039;xterm&#039; === getenv(&#039;TERM&#039;);
    }

    if (function_exists(&#039;stream_isatty&#039;)) {
        return stream_isatty(STDOUT);
    }

    if (function_exists(&#039;posix_isatty&#039;)) {
        return posix_isatty(STDOUT);
    }

    $stat = fstat(STDOUT);
    // Check if formatted mode is S_IFCHR
    return $stat ? 0020000 === ($stat[&#039;mode&#039;] &amp; 0170000) : false;
}

/**
 * Returns the value of a command-line option
 *
 * @param string $opt The command-line option to check
 * @param array $argv Command-line arguments
 * @param mixed $default Default value to be returned
 *
 * @return mixed The command-line value or the default
 */
function getOptValue($opt, $argv, $default)
{
    $optLength = strlen($opt);

    foreach ($argv as $key =&gt; $value) {
        $next = $key + 1;
        if (0 === strpos($value, $opt)) {
            if ($optLength === strlen($value) &amp;&amp; isset($argv[$next])) {
                return trim($argv[$next]);
            } else {
                return trim(substr($value, $optLength + 1));
            }
        }
    }

    return $default;
}

/**
 * Checks that user-supplied params are valid
 *
 * @param mixed $installDir The required istallation directory
 * @param mixed $version The required composer version to install
 * @param mixed $cafile Certificate Authority file
 *
 * @return bool True if the supplied params are okay
 */
function checkParams($installDir, $version, $cafile)
{
    $result = true;

    if (false !== $installDir &amp;&amp; !is_dir($installDir)) {
        out(&quot;The defined install dir ({$installDir}) does not exist.&quot;, &#039;info&#039;);
        $result = false;
    }

    if (false !== $version &amp;&amp; 1 !== preg_match(&#039;/^\d+\.\d+\.\d+(\-(alpha|beta|RC)\d*)*$/&#039;, $version)) {
        out(&quot;The defined install version ({$version}) does not match release pattern.&quot;, &#039;info&#039;);
        $result = false;
    }

    if (false !== $cafile &amp;&amp; (!file_exists($cafile) || !is_readable($cafile))) {
        out(&quot;The defined Certificate Authority (CA) cert file ({$cafile}) does not exist or is not readable.&quot;, &#039;info&#039;);
        $result = false;
    }
    return $result;
}

/**
 * Checks the platform for possible issues running Composer
 *
 * Errors are written to the output, warnings are saved for later display.
 *
 * @param array $warnings Populated by method, to be shown later
 * @param bool $quiet Quiet mode
 * @param bool $disableTls Bypass tls
 * @param bool $install If we are installing, rather than diagnosing
 *
 * @return bool True if there are no errors
 */
function checkPlatform(&amp;$warnings, $quiet, $disableTls, $install)
{
    getPlatformIssues($errors, $warnings, $install);

    // Make openssl warning an error if tls has not been specifically disabled
    if (isset($warnings[&#039;openssl&#039;]) &amp;&amp; !$disableTls) {
        $errors[&#039;openssl&#039;] = $warnings[&#039;openssl&#039;];
        unset($warnings[&#039;openssl&#039;]);
    }

    if (!empty($errors)) {
        // Composer-Setup.exe uses &quot;Some settings&quot; to flag platform errors
        out(&#039;Some settings on your machine make Composer unable to work properly.&#039;, &#039;error&#039;);
        out(&#039;Make sure that you fix the issues listed below and run this script again:&#039;, &#039;error&#039;);
        outputIssues($errors);
        return false;
    }

    if (empty($warnings) &amp;&amp; !$quiet) {
        out(&#039;All settings correct for using Composer&#039;, &#039;success&#039;);
    }
    return true;
}

/**
 * Checks platform configuration for common incompatibility issues
 *
 * @param array $errors Populated by method
 * @param array $warnings Populated by method
 * @param bool $install If we are installing, rather than diagnosing
 *
 * @return bool If any errors or warnings have been found
 */
function getPlatformIssues(&amp;$errors, &amp;$warnings, $install)
{
    $errors = array();
    $warnings = array();

    if ($iniPath = php_ini_loaded_file()) {
        $iniMessage = PHP_EOL.&#039;The php.ini used by your command-line PHP is: &#039; . $iniPath;
    } else {
        $iniMessage = PHP_EOL.&#039;A php.ini file does not exist. You will have to create one.&#039;;
    }
    $iniMessage .= PHP_EOL.&#039;If you can not modify the ini file, you can also run `php -d option=value` to modify ini values on the fly. You can use -d multiple times.&#039;;

    if (ini_get(&#039;detect_unicode&#039;)) {
        $errors[&#039;unicode&#039;] = array(
            &#039;The detect_unicode setting must be disabled.&#039;,
            &#039;Add the following to the end of your `php.ini`:&#039;,
            &#039;    detect_unicode = Off&#039;,
            $iniMessage
        );
    }

    if (extension_loaded(&#039;suhosin&#039;)) {
        $suhosin = ini_get(&#039;suhosin.executor.include.whitelist&#039;);
        $suhosinBlacklist = ini_get(&#039;suhosin.executor.include.blacklist&#039;);
        if (false === stripos($suhosin, &#039;phar&#039;) &amp;&amp; (!$suhosinBlacklist || false !== stripos($suhosinBlacklist, &#039;phar&#039;))) {
            $errors[&#039;suhosin&#039;] = array(
                &#039;The suhosin.executor.include.whitelist setting is incorrect.&#039;,
                &#039;Add the following to the end of your `php.ini` or suhosin.ini (Example path [for Debian]: /etc/php5/cli/conf.d/suhosin.ini):&#039;,
                &#039;    suhosin.executor.include.whitelist = phar &#039;.$suhosin,
                $iniMessage
            );
        }
    }

    if (!function_exists(&#039;json_decode&#039;)) {
        $errors[&#039;json&#039;] = array(
            &#039;The json extension is missing.&#039;,
            &#039;Install it or recompile php without --disable-json&#039;
        );
    }

    if (!extension_loaded(&#039;Phar&#039;)) {
        $errors[&#039;phar&#039;] = array(
            &#039;The phar extension is missing.&#039;,
            &#039;Install it or recompile php without --disable-phar&#039;
        );
    }

    if (!extension_loaded(&#039;filter&#039;)) {
        $errors[&#039;filter&#039;] = array(
            &#039;The filter extension is missing.&#039;,
            &#039;Install it or recompile php without --disable-filter&#039;
        );
    }

    if (!extension_loaded(&#039;hash&#039;)) {
        $errors[&#039;hash&#039;] = array(
            &#039;The hash extension is missing.&#039;,
            &#039;Install it or recompile php without --disable-hash&#039;
        );
    }

    if (!extension_loaded(&#039;iconv&#039;) &amp;&amp; !extension_loaded(&#039;mbstring&#039;)) {
        $errors[&#039;iconv_mbstring&#039;] = array(
            &#039;The iconv OR mbstring extension is required and both are missing.&#039;,
            &#039;Install either of them or recompile php without --disable-iconv&#039;
        );
    }

    if (!ini_get(&#039;allow_url_fopen&#039;)) {
        $errors[&#039;allow_url_fopen&#039;] = array(
            &#039;The allow_url_fopen setting is incorrect.&#039;,
            &#039;Add the following to the end of your `php.ini`:&#039;,
            &#039;    allow_url_fopen = On&#039;,
            $iniMessage
        );
    }

    if (extension_loaded(&#039;ionCube Loader&#039;) &amp;&amp; ioncube_loader_iversion() &lt; 40009) {
        $ioncube = ioncube_loader_version();
        $errors[&#039;ioncube&#039;] = array(
            &#039;Your ionCube Loader extension (&#039;.$ioncube.&#039;) is incompatible with Phar files.&#039;,
            &#039;Upgrade to ionCube 4.0.9 or higher or remove this line (path may be different) from your `php.ini` to disable it:&#039;,
            &#039;    zend_extension = /usr/lib/php5/20090626+lfs/ioncube_loader_lin_5.3.so&#039;,
            $iniMessage
        );
    }

    if (version_compare(PHP_VERSION, &#039;5.3.2&#039;, &#039;&lt;&#039;)) {
        $errors[&#039;php&#039;] = array(
            &#039;Your PHP (&#039;.PHP_VERSION.&#039;) is too old, you must upgrade to PHP 5.3.2 or higher.&#039;
        );
    }

    if (version_compare(PHP_VERSION, &#039;5.3.4&#039;, &#039;&lt;&#039;)) {
        $warnings[&#039;php&#039;] = array(
            &#039;Your PHP (&#039;.PHP_VERSION.&#039;) is quite old, upgrading to PHP 5.3.4 or higher is recommended.&#039;,
            &#039;Composer works with 5.3.2+ for most people, but there might be edge case issues.&#039;
        );
    }

    if (!extension_loaded(&#039;openssl&#039;)) {
        $warnings[&#039;openssl&#039;] = array(
            &#039;The openssl extension is missing, which means that secure HTTPS transfers are impossible.&#039;,
            &#039;If possible you should enable it or recompile php with --with-openssl&#039;
        );
    }

    if (extension_loaded(&#039;openssl&#039;) &amp;&amp; OPENSSL_VERSION_NUMBER &lt; 0x1000100f) {
        // Attempt to parse version number out, fallback to whole string value.
        $opensslVersion = trim(strstr(OPENSSL_VERSION_TEXT, &#039; &#039;));
        $opensslVersion = substr($opensslVersion, 0, strpos($opensslVersion, &#039; &#039;));
        $opensslVersion = $opensslVersion ? $opensslVersion : OPENSSL_VERSION_TEXT;

        $warnings[&#039;openssl_version&#039;] = array(
            &#039;The OpenSSL library (&#039;.$opensslVersion.&#039;) used by PHP does not support TLSv1.2 or TLSv1.1.&#039;,
            &#039;If possible you should upgrade OpenSSL to version 1.0.1 or above.&#039;
        );
    }

    if (!defined(&#039;HHVM_VERSION&#039;) &amp;&amp; !extension_loaded(&#039;apcu&#039;) &amp;&amp; ini_get(&#039;apc.enable_cli&#039;)) {
        $warnings[&#039;apc_cli&#039;] = array(
            &#039;The apc.enable_cli setting is incorrect.&#039;,
            &#039;Add the following to the end of your `php.ini`:&#039;,
            &#039;    apc.enable_cli = Off&#039;,
            $iniMessage
        );
    }

    if (!$install &amp;&amp; extension_loaded(&#039;xdebug&#039;)) {
        $warnings[&#039;xdebug_loaded&#039;] = array(
            &#039;The xdebug extension is loaded, this can slow down Composer a little.&#039;,
            &#039;Disabling it when using Composer is recommended.&#039;
        );

        if (ini_get(&#039;xdebug.profiler_enabled&#039;)) {
            $warnings[&#039;xdebug_profile&#039;] = array(
                &#039;The xdebug.profiler_enabled setting is enabled, this can slow down Composer a lot.&#039;,
                &#039;Add the following to the end of your `php.ini` to disable it:&#039;,
                &#039;    xdebug.profiler_enabled = 0&#039;,
                $iniMessage
            );
        }
    }

    if (!extension_loaded(&#039;zlib&#039;)) {
        $warnings[&#039;zlib&#039;] = array(
            &#039;The zlib extension is not loaded, this can slow down Composer a lot.&#039;,
            &#039;If possible, install it or recompile php with --with-zlib&#039;,
            $iniMessage
        );
    }

    if (defined(&#039;PHP_WINDOWS_VERSION_BUILD&#039;)
        &amp;&amp; (version_compare(PHP_VERSION, &#039;7.2.23&#039;, &#039;&lt;&#039;)
        || (version_compare(PHP_VERSION, &#039;7.3.0&#039;, &#039;&gt;=&#039;)
        &amp;&amp; version_compare(PHP_VERSION, &#039;7.3.10&#039;, &#039;&lt;&#039;)))) {
        $warnings[&#039;onedrive&#039;] = array(
            &#039;The Windows OneDrive folder is not supported on PHP versions below 7.2.23 and 7.3.10.&#039;,
            &#039;Upgrade your PHP (&#039;.PHP_VERSION.&#039;) to use this location with Composer.&#039;
        );
    }

    if (extension_loaded(&#039;uopz&#039;) &amp;&amp; !(ini_get(&#039;uopz.disable&#039;) || ini_get(&#039;uopz.exit&#039;))) {
        $warnings[&#039;uopz&#039;] = array(
            &#039;The uopz extension ignores exit calls and may not work with all Composer commands.&#039;,
            &#039;Disabling it when using Composer is recommended.&#039;
        );
    }

    ob_start();
    phpinfo(INFO_GENERAL);
    $phpinfo = ob_get_clean();
    if (preg_match(&#039;{Configure Command(?: *&lt;/td&gt;&lt;td class=&quot;v&quot;&gt;| *=&gt; *)(.*?)(?:&lt;/td&gt;|$)}m&#039;, $phpinfo, $match)) {
        $configure = $match[1];

        if (false !== strpos($configure, &#039;--enable-sigchild&#039;)) {
            $warnings[&#039;sigchild&#039;] = array(
                &#039;PHP was compiled with --enable-sigchild which can cause issues on some platforms.&#039;,
                &#039;Recompile it without this flag if possible, see also:&#039;,
                &#039;    https://bugs.php.net/bug.php?id=22999&#039;
            );
        }

        if (false !== strpos($configure, &#039;--with-curlwrappers&#039;)) {
            $warnings[&#039;curlwrappers&#039;] = array(
                &#039;PHP was compiled with --with-curlwrappers which will cause issues with HTTP authentication and GitHub.&#039;,
                &#039;Recompile it without this flag if possible&#039;
            );
        }
    }

    // Stringify the message arrays
    foreach ($errors as $key =&gt; $value) {
        $errors[$key] = PHP_EOL.implode(PHP_EOL, $value);
    }

    foreach ($warnings as $key =&gt; $value) {
        $warnings[$key] = PHP_EOL.implode(PHP_EOL, $value);
    }

    return !empty($errors) || !empty($warnings);
}


/**
 * Outputs an array of issues
 *
 * @param array $issues
 */
function outputIssues($issues)
{
    foreach ($issues as $issue) {
        out($issue, &#039;info&#039;);
    }
    out(&#039;&#039;);
}

/**
 * Outputs any warnings found
 *
 * @param array $warnings
 */
function showWarnings($warnings)
{
    if (!empty($warnings)) {
        out(&#039;Some settings on your machine may cause stability issues with Composer.&#039;, &#039;error&#039;);
        out(&#039;If you encounter issues, try to change the following:&#039;, &#039;error&#039;);
        outputIssues($warnings);
    }
}

/**
 * Outputs an end of process warning if tls has been bypassed
 *
 * @param bool $disableTls Bypass tls
 */
function showSecurityWarning($disableTls)
{
    if ($disableTls) {
        out(&#039;You have instructed the Installer not to enforce SSL/TLS security on remote HTTPS requests.&#039;, &#039;info&#039;);
        out(&#039;This will leave all downloads during installation vulnerable to Man-In-The-Middle (MITM) attacks&#039;, &#039;info&#039;);
    }
}

/**
 * colorize output
 */
function out($text, $color = null, $newLine = true)
{
    $styles = array(
        &#039;success&#039; =&gt; &quot;\033[0;32m%s\033[0m&quot;,
        &#039;error&#039; =&gt; &quot;\033[31;31m%s\033[0m&quot;,
        &#039;info&#039; =&gt; &quot;\033[33;33m%s\033[0m&quot;
    );

    $format = &#039;%s&#039;;

    if (isset($styles[$color]) &amp;&amp; USE_ANSI) {
        $format = $styles[$color];
    }

    if ($newLine) {
        $format .= PHP_EOL;
    }

    printf($format, $text);
}

/**
 * Returns the system-dependent Composer home location, which may not exist
 *
 * @return string
 */
function getHomeDir()
{
    $home = getenv(&#039;COMPOSER_HOME&#039;);
    if ($home) {
        return $home;
    }

    $userDir = getUserDir();

    if (defined(&#039;PHP_WINDOWS_VERSION_MAJOR&#039;)) {
        return $userDir.&#039;/Composer&#039;;
    }

    $dirs = array();

    if (useXdg()) {
        // XDG Base Directory Specifications
        $xdgConfig = getenv(&#039;XDG_CONFIG_HOME&#039;);
        if (!$xdgConfig) {
            $xdgConfig = $userDir . &#039;/.config&#039;;
        }

        $dirs[] = $xdgConfig . &#039;/composer&#039;;
    }

    $dirs[] = $userDir . &#039;/.composer&#039;;

    // select first dir which exists of: $XDG_CONFIG_HOME/composer or ~/.composer
    foreach ($dirs as $dir) {
        if (is_dir($dir)) {
            return $dir;
        }
    }

    // if none exists, we default to first defined one (XDG one if system uses it, or ~/.composer otherwise)
    return $dirs[0];
}

/**
 * Returns the location of the user directory from the environment
 * @throws RuntimeException If the environment value does not exists
 *
 * @return string
 */
function getUserDir()
{
    $userEnv = defined(&#039;PHP_WINDOWS_VERSION_MAJOR&#039;) ? &#039;APPDATA&#039; : &#039;HOME&#039;;
    $userDir = getenv($userEnv);

    if (!$userDir) {
        throw new RuntimeException(&#039;The &#039;.$userEnv.&#039; or COMPOSER_HOME environment variable must be set for composer to run correctly&#039;);
    }

    return rtrim(strtr($userDir, &#039;\\&#039;, &#039;/&#039;), &#039;/&#039;);
}

/**
 * @return bool
 */
function useXdg()
{
    foreach (array_keys($_SERVER) as $key) {
        if (strpos($key, &#039;XDG_&#039;) === 0) {
            return true;
        }
    }

    if (is_dir(&#039;/etc/xdg&#039;)) {
        return true;
    }

    return false;
}

function validateCaFile($contents)
{
    // assume the CA is valid if php is vulnerable to
    // https://www.sektioneins.de/advisories/advisory-012013-php-openssl_x509_parse-memory-corruption-vulnerability.html
    if (
        PHP_VERSION_ID &lt;= 50327
        || (PHP_VERSION_ID &gt;= 50400 &amp;&amp; PHP_VERSION_ID &lt; 50422)
        || (PHP_VERSION_ID &gt;= 50500 &amp;&amp; PHP_VERSION_ID &lt; 50506)
    ) {
        return !empty($contents);
    }

    return (bool) openssl_x509_parse($contents);
}

class Installer
{
    private $quiet;
    private $disableTls;
    private $cafile;
    private $displayPath;
    private $target;
    private $tmpFile;
    private $tmpCafile;
    private $baseUrl;
    private $algo;
    private $errHandler;
    private $httpClient;
    private $pubKeys = array();
    private $installs = array();

    /**
     * Constructor - must not do anything that throws an exception
     *
     * @param bool $quiet Quiet mode
     * @param bool $disableTls Bypass tls
     * @param mixed $cafile Path to CA bundle, or false
     */
    public function __construct($quiet, $disableTls, $caFile)
    {
        if (($this-&gt;quiet = $quiet)) {
            ob_start();
        }
        $this-&gt;disableTls = $disableTls;
        $this-&gt;cafile = $caFile;
        $this-&gt;errHandler = new ErrorHandler();
    }

    /**
     * Runs the installer
     *
     * @param mixed $version Specific version to install, or false
     * @param mixed $installDir Specific installation directory, or false
     * @param string $filename Specific filename to save to, or composer.phar
     * @param string $channel Specific version channel to use
     * @throws Exception If anything other than a RuntimeException is caught
     *
     * @return bool If the installation succeeded
     */
    public function run($version, $installDir, $filename, $channel)
    {
        try {
            $this-&gt;initTargets($installDir, $filename);
            $this-&gt;initTls();
            $this-&gt;httpClient = new HttpClient($this-&gt;disableTls, $this-&gt;cafile);
            $result = $this-&gt;install($version, $channel);

            // in case --1 or --2 is passed, we leave the default channel for next self-update to stable
            if (1 === preg_match(&#039;{^\d+$}D&#039;, $channel)) {
                $channel = &#039;stable&#039;;
            }

            if ($result &amp;&amp; $channel !== &#039;stable&#039; &amp;&amp; !$version &amp;&amp; defined(&#039;PHP_BINARY&#039;)) {
                $null = (defined(&#039;PHP_WINDOWS_VERSION_MAJOR&#039;) ? &#039;NUL&#039; : &#039;/dev/null&#039;);
                @exec(escapeshellarg(PHP_BINARY) .&#039; &#039;.escapeshellarg($this-&gt;target).&#039; self-update --&#039;.$channel.&#039; --set-channel-only -q &gt; &#039;.$null.&#039; 2&gt; &#039;.$null, $output);
            }
        } catch (Exception $e) {
            $result = false;
        }

        // Always clean up
        $this-&gt;cleanUp($result);

        if (isset($e)) {
            // Rethrow anything that is not a RuntimeException
            if (!$e instanceof RuntimeException) {
                throw $e;
            }
            out($e-&gt;getMessage(), &#039;error&#039;);
        }
        return $result;
    }

    /**
     * Initialization methods to set the required filenames and composer url
     *
     * @param mixed $installDir Specific installation directory, or false
     * @param string $filename Specific filename to save to, or composer.phar
     * @throws RuntimeException If the installation directory is not writable
     */
    protected function initTargets($installDir, $filename)
    {
        $this-&gt;displayPath = ($installDir ? rtrim($installDir, &#039;/&#039;).&#039;/&#039; : &#039;&#039;).$filename;
        $installDir = $installDir ? realpath($installDir) : getcwd();

        if (!is_writeable($installDir)) {
            throw new RuntimeException(&#039;The installation directory &quot;&#039;.$installDir.&#039;&quot; is not writable&#039;);
        }

        $this-&gt;target = $installDir.DIRECTORY_SEPARATOR.$filename;
        $this-&gt;tmpFile = $installDir.DIRECTORY_SEPARATOR.basename($this-&gt;target, &#039;.phar&#039;).&#039;-temp.phar&#039;;

        $uriScheme = $this-&gt;disableTls ? &#039;http&#039; : &#039;https&#039;;
        $this-&gt;baseUrl = $uriScheme.&#039;://getcomposer.org&#039;;
    }

    /**
     * A wrapper around methods to check tls and write public keys
     * @throws RuntimeException If SHA384 is not supported
     */
    protected function initTls()
    {
        if ($this-&gt;disableTls) {
            return;
        }

        if (!in_array(&#039;sha384&#039;, array_map(&#039;strtolower&#039;, openssl_get_md_methods()))) {
            throw new RuntimeException(&#039;SHA384 is not supported by your openssl extension&#039;);
        }

        $this-&gt;algo = defined(&#039;OPENSSL_ALGO_SHA384&#039;) ? OPENSSL_ALGO_SHA384 : &#039;SHA384&#039;;
        $home = $this-&gt;getComposerHome();

        $this-&gt;pubKeys = array(
            &#039;dev&#039; =&gt; $this-&gt;installKey(self::getPKDev(), $home, &#039;keys.dev.pub&#039;),
            &#039;tags&#039; =&gt; $this-&gt;installKey(self::getPKTags(), $home, &#039;keys.tags.pub&#039;)
        );

        if (empty($this-&gt;cafile) &amp;&amp; !HttpClient::getSystemCaRootBundlePath()) {
            $this-&gt;cafile = $this-&gt;tmpCafile = $this-&gt;installKey(HttpClient::getPackagedCaFile(), $home, &#039;cacert-temp.pem&#039;);
        }
    }

    /**
     * Returns the Composer home directory, creating it if required
     * @throws RuntimeException If the directory cannot be created
     *
     * @return string
     */
    protected function getComposerHome()
    {
        $home = getHomeDir();

        if (!is_dir($home)) {
            $this-&gt;errHandler-&gt;start();

            if (!mkdir($home, 0777, true)) {
                throw new RuntimeException(sprintf(
                    &#039;Unable to create Composer home directory &quot;%s&quot;: %s&#039;,
                    $home,
                    $this-&gt;errHandler-&gt;message
                ));
            }
            $this-&gt;installs[] = $home;
            $this-&gt;errHandler-&gt;stop();
        }
        return $home;
    }

    /**
     * Writes public key data to disc
     *
     * @param string $data The public key(s) in pem format
     * @param string $path The directory to write to
     * @param string $filename The name of the file
     * @throws RuntimeException If the file cannot be written
     *
     * @return string The path to the saved data
     */
    protected function installKey($data, $path, $filename)
    {
        $this-&gt;errHandler-&gt;start();

        $target = $path.DIRECTORY_SEPARATOR.$filename;
        $installed = file_exists($target);
        $write = file_put_contents($target, $data, LOCK_EX);
        @chmod($target, 0644);

        $this-&gt;errHandler-&gt;stop();

        if (!$write) {
            throw new RuntimeException(sprintf(&#039;Unable to write %s to: %s&#039;, $filename, $path));
        }

        if (!$installed) {
            $this-&gt;installs[] = $target;
        }

        return $target;
    }

    /**
     * The main install function
     *
     * @param mixed $version Specific version to install, or false
     * @param string $channel Version channel to use
     *
     * @return bool If the installation succeeded
     */
    protected function install($version, $channel)
    {
        $retries = 3;
        $result = false;
        $infoMsg = &#039;Downloading...&#039;;
        $infoType = &#039;info&#039;;

        while ($retries--) {
            if (!$this-&gt;quiet) {
                out($infoMsg, $infoType);
                $infoMsg = &#039;Retrying...&#039;;
                $infoType = &#039;error&#039;;
            }

            if (!$this-&gt;getVersion($channel, $version, $url, $error)) {
                out($error, &#039;error&#039;);
                continue;
            }

            if (!$this-&gt;downloadToTmp($url, $signature, $error)) {
                out($error, &#039;error&#039;);
                continue;
            }

            if (!$this-&gt;verifyAndSave($version, $signature, $error)) {
                out($error, &#039;error&#039;);
                continue;
            }

            $result = true;
            break;
        }

        if (!$this-&gt;quiet) {
            if ($result) {
                out(PHP_EOL.&quot;Composer (version {$version}) successfully installed to: {$this-&gt;target}&quot;, &#039;success&#039;);
                out(&quot;Use it: php {$this-&gt;displayPath}&quot;, &#039;info&#039;);
                out(&#039;&#039;);
            } else {
                out(&#039;The download failed repeatedly, aborting.&#039;, &#039;error&#039;);
            }
        }
        return $result;
    }

    /**
     * Sets the version url, downloading version data if required
     *
     * @param string $channel Version channel to use
     * @param false|string $version Version to install, or set by method
     * @param null|string $url The versioned url, set by method
     * @param null|string $error Set by method on failure
     *
     * @return bool If the operation succeeded
     */
    protected function getVersion($channel, &amp;$version, &amp;$url, &amp;$error)
    {
        $error = &#039;&#039;;

        if ($version) {
            if (empty($url)) {
                $url = $this-&gt;baseUrl.&quot;/download/{$version}/composer.phar&quot;;
            }
            return true;
        }

        $this-&gt;errHandler-&gt;start();

        if ($this-&gt;downloadVersionData($data, $error)) {
            $this-&gt;parseVersionData($data, $channel, $version, $url);
        }

        $this-&gt;errHandler-&gt;stop();
        return empty($error);
    }

    /**
     * Downloads and json-decodes version data
     *
     * @param null|array $data Downloaded version data, set by method
     * @param null|string $error Set by method on failure
     *
     * @return bool If the operation succeeded
     */
    protected function downloadVersionData(&amp;$data, &amp;$error)
    {
        $url = $this-&gt;baseUrl.&#039;/versions&#039;;
        $errFmt = &#039;The &quot;%s&quot; file could not be %s: %s&#039;;

        if (!$json = $this-&gt;httpClient-&gt;get($url)) {
            $error = sprintf($errFmt, $url, &#039;downloaded&#039;, $this-&gt;errHandler-&gt;message);
            return false;
        }

        if (!$data = json_decode($json, true)) {
            $error = sprintf($errFmt, $url, &#039;json-decoded&#039;, $this-&gt;getJsonError());
            return false;
        }
        return true;
    }

    /**
     * A wrapper around the methods needed to download and save the phar
     *
     * @param string $url The versioned download url
     * @param null|string $signature Set by method on successful download
     * @param null|string $error Set by method on failure
     *
     * @return bool If the operation succeeded
     */
    protected function downloadToTmp($url, &amp;$signature, &amp;$error)
    {
        $error = &#039;&#039;;
        $errFmt = &#039;The &quot;%s&quot; file could not be downloaded: %s&#039;;
        $sigUrl = $url.&#039;.sig&#039;;
        $this-&gt;errHandler-&gt;start();

        if (!$fh = fopen($this-&gt;tmpFile, &#039;w&#039;)) {
            $error = sprintf(&#039;Could not create file &quot;%s&quot;: %s&#039;, $this-&gt;tmpFile, $this-&gt;errHandler-&gt;message);

        } elseif (!$this-&gt;getSignature($sigUrl, $signature)) {
            $error = sprintf($errFmt, $sigUrl, $this-&gt;errHandler-&gt;message);

        } elseif (!fwrite($fh, $this-&gt;httpClient-&gt;get($url))) {
            $error = sprintf($errFmt, $url, $this-&gt;errHandler-&gt;message);
        }

        if (is_resource($fh)) {
            fclose($fh);
        }
        $this-&gt;errHandler-&gt;stop();
        return empty($error);
    }

    /**
     * Verifies the downloaded file and saves it to the target location
     *
     * @param string $version The composer version downloaded
     * @param string $signature The digital signature to check
     * @param null|string $error Set by method on failure
     *
     * @return bool If the operation succeeded
     */
    protected function verifyAndSave($version, $signature, &amp;$error)
    {
        $error = &#039;&#039;;

        if (!$this-&gt;validatePhar($this-&gt;tmpFile, $pharError)) {
            $error = &#039;The download is corrupt: &#039;.$pharError;

        } elseif (!$this-&gt;verifySignature($version, $signature, $this-&gt;tmpFile)) {
            $error = &#039;Signature mismatch, could not verify the phar file integrity&#039;;

        } else {
            $this-&gt;errHandler-&gt;start();

            if (!rename($this-&gt;tmpFile, $this-&gt;target)) {
                $error = sprintf(&#039;Could not write to file &quot;%s&quot;: %s&#039;, $this-&gt;target, $this-&gt;errHandler-&gt;message);
            }
            chmod($this-&gt;target, 0755);
            $this-&gt;errHandler-&gt;stop();
        }

        return empty($error);
    }

    /**
     * Parses an array of version data to match the required channel
     *
     * @param array $data Downloaded version data
     * @param mixed $channel Version channel to use
     * @param false|string $version Set by method
     * @param mixed $url The versioned url, set by method
     */
    protected function parseVersionData(array $data, $channel, &amp;$version, &amp;$url)
    {
        foreach ($data[$channel] as $candidate) {
            if ($candidate[&#039;min-php&#039;] &lt;= PHP_VERSION_ID) {
                $version = $candidate[&#039;version&#039;];
                $url = $this-&gt;baseUrl.$candidate[&#039;path&#039;];
                break;
            }
        }

        if (!$version) {
            $error = sprintf(
                &#039;None of the %d %s version(s) of Composer matches your PHP version (%s / ID: %d)&#039;,
                count($data[$channel]),
                $channel,
                PHP_VERSION,
                PHP_VERSION_ID
            );
            throw new RuntimeException($error);
        }
    }

    /**
     * Downloads the digital signature of required phar file
     *
     * @param string $url The signature url
     * @param null|string $signature Set by method on success
     *
     * @return bool If the download succeeded
     */
    protected function getSignature($url, &amp;$signature)
    {
        if (!$result = $this-&gt;disableTls) {
            $signature = $this-&gt;httpClient-&gt;get($url);

            if ($signature) {
                $signature = json_decode($signature, true);
                $signature = base64_decode($signature[&#039;sha384&#039;]);
                $result = true;
            }
        }

        return $result;
    }

    /**
     * Verifies the signature of the downloaded phar
     *
     * @param string $version The composer versione
     * @param string $signature The downloaded digital signature
     * @param string $file The temp phar file
     *
     * @return bool If the operation succeeded
     */
    protected function verifySignature($version, $signature, $file)
    {
        if (!$result = $this-&gt;disableTls) {
            $path = preg_match(&#039;{^[0-9a-f]{40}$}&#039;, $version) ? $this-&gt;pubKeys[&#039;dev&#039;] : $this-&gt;pubKeys[&#039;tags&#039;];
            $pubkeyid = openssl_pkey_get_public(&#039;file://&#039;.$path);

            $result = 1 === openssl_verify(
                file_get_contents($file),
                $signature,
                $pubkeyid,
                $this-&gt;algo
            );

            // PHP 8 automatically frees the key instance and deprecates the function
            if (PHP_VERSION_ID &lt; 80000) {
                openssl_free_key($pubkeyid);
            }
        }

        return $result;
    }

    /**
     * Validates the downloaded phar file
     *
     * @param string $pharFile The temp phar file
     * @param null|string $error Set by method on failure
     *
     * @return bool If the operation succeeded
     */
    protected function validatePhar($pharFile, &amp;$error)
    {
        if (ini_get(&#039;phar.readonly&#039;)) {
            return true;
        }

        try {
            // Test the phar validity
            $phar = new Phar($pharFile);
            // Free the variable to unlock the file
            unset($phar);
            $result = true;

        } catch (Exception $e) {
            if (!$e instanceof UnexpectedValueException &amp;&amp; !$e instanceof PharException) {
                throw $e;
            }
            $error = $e-&gt;getMessage();
            $result = false;
        }
        return $result;
    }

    /**
     * Returns a string representation of the last json error
     *
     * @return string The error string or code
     */
    protected function getJsonError()
    {
        if (function_exists(&#039;json_last_error_msg&#039;)) {
            return json_last_error_msg();
        } else {
            return &#039;json_last_error = &#039;.json_last_error();
        }
    }

    /**
     * Cleans up resources at the end of the installation
     *
     * @param bool $result If the installation succeeded
     */
    protected function cleanUp($result)
    {
        if (!$result) {
            // Output buffered errors
            if ($this-&gt;quiet) {
                $this-&gt;outputErrors();
            }
            // Clean up stuff we created
            $this-&gt;uninstall();
        } elseif ($this-&gt;tmpCafile) {
            @unlink($this-&gt;tmpCafile);
        }
    }

    /**
     * Outputs unique errors when in quiet mode
     *
     */
    protected function outputErrors()
    {
        $errors = explode(PHP_EOL, ob_get_clean());
        $shown = array();

        foreach ($errors as $error) {
            if ($error &amp;&amp; !in_array($error, $shown)) {
                out($error, &#039;error&#039;);
                $shown[] = $error;
            }
        }
    }

    /**
     * Uninstalls newly-created files and directories on failure
     *
     */
    protected function uninstall()
    {
        foreach (array_reverse($this-&gt;installs) as $target) {
            if (is_file($target)) {
                @unlink($target);
            } elseif (is_dir($target)) {
                @rmdir($target);
            }
        }

        if ($this-&gt;tmpFile !== null &amp;&amp; file_exists($this-&gt;tmpFile)) {
            @unlink($this-&gt;tmpFile);
        }
    }

    public static function getPKDev()
    {
        return &lt;&lt;&lt;PKDEV
-----BEGIN PUBLIC KEY-----
MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAnBDHjZS6e0ZMoK3xTD7f
FNCzlXjX/Aie2dit8QXA03pSrOTbaMnxON3hUL47Lz3g1SC6YJEMVHr0zYq4elWi
i3ecFEgzLcj+pZM5X6qWu2Ozz4vWx3JYo1/a/HYdOuW9e3lwS8VtS0AVJA+U8X0A
hZnBmGpltHhO8hPKHgkJtkTUxCheTcbqn4wGHl8Z2SediDcPTLwqezWKUfrYzu1f
o/j3WFwFs6GtK4wdYtiXr+yspBZHO3y1udf8eFFGcb2V3EaLOrtfur6XQVizjOuk
8lw5zzse1Qp/klHqbDRsjSzJ6iL6F4aynBc6Euqt/8ccNAIz0rLjLhOraeyj4eNn
8iokwMKiXpcrQLTKH+RH1JCuOVxQ436bJwbSsp1VwiqftPQieN+tzqy+EiHJJmGf
TBAbWcncicCk9q2md+AmhNbvHO4PWbbz9TzC7HJb460jyWeuMEvw3gNIpEo2jYa9
pMV6cVqnSa+wOc0D7pC9a6bne0bvLcm3S+w6I5iDB3lZsb3A9UtRiSP7aGSo7D72
8tC8+cIgZcI7k9vjvOqH+d7sdOU2yPCnRY6wFh62/g8bDnUpr56nZN1G89GwM4d4
r/TU7BQQIzsZgAiqOGXvVklIgAMiV0iucgf3rNBLjjeNEwNSTTG9F0CtQ+7JLwaE
wSEuAuRm+pRqi8BRnQ/GKUcCAwEAAQ==
-----END PUBLIC KEY-----
PKDEV;
    }

    public static function getPKTags()
    {
        return &lt;&lt;&lt;PKTAGS
-----BEGIN PUBLIC KEY-----
MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA0Vi/2K6apCVj76nCnCl2
MQUPdK+A9eqkYBacXo2wQBYmyVlXm2/n/ZsX6pCLYPQTHyr5jXbkQzBw8SKqPdlh
vA7NpbMeNCz7wP/AobvUXM8xQuXKbMDTY2uZ4O7sM+PfGbptKPBGLe8Z8d2sUnTO
bXtX6Lrj13wkRto7st/w/Yp33RHe9SlqkiiS4MsH1jBkcIkEHsRaveZzedUaxY0M
mba0uPhGUInpPzEHwrYqBBEtWvP97t2vtfx8I5qv28kh0Y6t+jnjL1Urid2iuQZf
noCMFIOu4vksK5HxJxxrN0GOmGmwVQjOOtxkwikNiotZGPR4KsVj8NnBrLX7oGuM
nQvGciiu+KoC2r3HDBrpDeBVdOWxDzT5R4iI0KoLzFh2pKqwbY+obNPS2bj+2dgJ
rV3V5Jjry42QOCBN3c88wU1PKftOLj2ECpewY6vnE478IipiEu7EAdK8Zwj2LmTr
RKQUSa9k7ggBkYZWAeO/2Ag0ey3g2bg7eqk+sHEq5ynIXd5lhv6tC5PBdHlWipDK
tl2IxiEnejnOmAzGVivE1YGduYBjN+mjxDVy8KGBrjnz1JPgAvgdwJ2dYw4Rsc/e
TzCFWGk/HM6a4f0IzBWbJ5ot0PIi4amk07IotBXDWwqDiQTwyuGCym5EqWQ2BD95
RGv89BPD+2DLnJysngsvVaUCAwEAAQ==
-----END PUBLIC KEY-----
PKTAGS;
    }
}

class ErrorHandler
{
    public $message;
    protected $active;

    /**
     * Handle php errors
     *
     * @param mixed $code The error code
     * @param mixed $msg The error message
     */
    public function handleError($code, $msg)
    {
        if ($this-&gt;message) {
            $this-&gt;message .= PHP_EOL;
        }
        $this-&gt;message .= preg_replace(&#039;{^file_get_contents\(.*?\): }&#039;, &#039;&#039;, $msg);
    }

    /**
     * Starts error-handling if not already active
     *
     * Any message is cleared
     */
    public function start()
    {
        if (!$this-&gt;active) {
            set_error_handler(array($this, &#039;handleError&#039;));
            $this-&gt;active = true;
        }
        $this-&gt;message = &#039;&#039;;
    }

    /**
     * Stops error-handling if active
     *
     * Any message is preserved until the next call to start()
     */
    public function stop()
    {
        if ($this-&gt;active) {
            restore_error_handler();
            $this-&gt;active = false;
        }
    }
}

class NoProxyPattern
{
    private $composerInNoProxy = false;
    private $rulePorts = array();

    public function __construct($pattern)
    {
        $rules = preg_split(&#039;{[\s,]+}&#039;, $pattern, null, PREG_SPLIT_NO_EMPTY);

        if ($matches = preg_grep(&#039;{getcomposer\.org(?::\d+)?}i&#039;, $rules)) {
            $this-&gt;composerInNoProxy = true;

            foreach ($matches as $match) {
                if (strpos($match, &#039;:&#039;) !== false) {
                    list(, $port) = explode(&#039;:&#039;, $match);
                    $this-&gt;rulePorts[] = (int) $port;
                }
            }
        }
    }

    /**
     * Returns true if NO_PROXY contains getcomposer.org
     *
     * @param string $url http(s)://getcomposer.org
     *
     * @return bool
     */
    public function test($url)
    {
        if (!$this-&gt;composerInNoProxy) {
            return false;
        }

        if (empty($this-&gt;rulePorts)) {
            return true;
        }

        if (strpos($url, &#039;http://&#039;) === 0) {
            $port = 80;
        } else {
            $port = 443;
        }

        return in_array($port, $this-&gt;rulePorts);
    }
}

class HttpClient {

    /** @var null|string */
    private static $caPath;

    private $options = array(&#039;http&#039; =&gt; array());
    private $disableTls = false;

    public function __construct($disableTls = false, $cafile = false)
    {
        $this-&gt;disableTls = $disableTls;
        if ($this-&gt;disableTls === false) {
            if (!empty($cafile) &amp;&amp; !is_dir($cafile)) {
                if (!is_readable($cafile) || !validateCaFile(file_get_contents($cafile))) {
                    throw new RuntimeException(&#039;The configured cafile (&#039; .$cafile. &#039;) was not valid or could not be read.&#039;);
                }
            }
            $options = $this-&gt;getTlsStreamContextDefaults($cafile);
            $this-&gt;options = array_replace_recursive($this-&gt;options, $options);
        }
    }

    public function get($url)
    {
        $context = $this-&gt;getStreamContext($url);
        $result = file_get_contents($url, false, $context);

        if ($result &amp;&amp; extension_loaded(&#039;zlib&#039;)) {
            $decode = false;
            foreach ($http_response_header as $header) {
                if (preg_match(&#039;{^content-encoding: *gzip *$}i&#039;, $header)) {
                    $decode = true;
                    continue;
                } elseif (preg_match(&#039;{^HTTP/}i&#039;, $header)) {
                    $decode = false;
                }
            }

            if ($decode) {
                if (version_compare(PHP_VERSION, &#039;5.4.0&#039;, &#039;&gt;=&#039;)) {
                    $result = zlib_decode($result);
                } else {
                    // work around issue with gzuncompress &amp; co that do not work with all gzip checksums
                    $result = file_get_contents(&#039;compress.zlib://data:application/octet-stream;base64,&#039;.base64_encode($result));
                }

                if (!$result) {
                    throw new RuntimeException(&#039;Failed to decode zlib stream&#039;);
                }
            }
        }

        return $result;
    }

    protected function getStreamContext($url)
    {
        if ($this-&gt;disableTls === false) {
            if (PHP_VERSION_ID &lt; 50600) {
                $this-&gt;options[&#039;ssl&#039;][&#039;SNI_server_name&#039;] = parse_url($url, PHP_URL_HOST);
            }
        }
        // Keeping the above mostly isolated from the code copied from Composer.
        return $this-&gt;getMergedStreamContext($url);
    }

    protected function getTlsStreamContextDefaults($cafile)
    {
        $ciphers = implode(&#039;:&#039;, array(
            &#039;ECDHE-RSA-AES128-GCM-SHA256&#039;,
            &#039;ECDHE-ECDSA-AES128-GCM-SHA256&#039;,
            &#039;ECDHE-RSA-AES256-GCM-SHA384&#039;,
            &#039;ECDHE-ECDSA-AES256-GCM-SHA384&#039;,
            &#039;DHE-RSA-AES128-GCM-SHA256&#039;,
            &#039;DHE-DSS-AES128-GCM-SHA256&#039;,
            &#039;kEDH+AESGCM&#039;,
            &#039;ECDHE-RSA-AES128-SHA256&#039;,
            &#039;ECDHE-ECDSA-AES128-SHA256&#039;,
            &#039;ECDHE-RSA-AES128-SHA&#039;,
            &#039;ECDHE-ECDSA-AES128-SHA&#039;,
            &#039;ECDHE-RSA-AES256-SHA384&#039;,
            &#039;ECDHE-ECDSA-AES256-SHA384&#039;,
            &#039;ECDHE-RSA-AES256-SHA&#039;,
            &#039;ECDHE-ECDSA-AES256-SHA&#039;,
            &#039;DHE-RSA-AES128-SHA256&#039;,
            &#039;DHE-RSA-AES128-SHA&#039;,
            &#039;DHE-DSS-AES128-SHA256&#039;,
            &#039;DHE-RSA-AES256-SHA256&#039;,
            &#039;DHE-DSS-AES256-SHA&#039;,
            &#039;DHE-RSA-AES256-SHA&#039;,
            &#039;AES128-GCM-SHA256&#039;,
            &#039;AES256-GCM-SHA384&#039;,
            &#039;AES128-SHA256&#039;,
            &#039;AES256-SHA256&#039;,
            &#039;AES128-SHA&#039;,
            &#039;AES256-SHA&#039;,
            &#039;AES&#039;,
            &#039;CAMELLIA&#039;,
            &#039;DES-CBC3-SHA&#039;,
            &#039;!aNULL&#039;,
            &#039;!eNULL&#039;,
            &#039;!EXPORT&#039;,
            &#039;!DES&#039;,
            &#039;!RC4&#039;,
            &#039;!MD5&#039;,
            &#039;!PSK&#039;,
            &#039;!aECDH&#039;,
            &#039;!EDH-DSS-DES-CBC3-SHA&#039;,
            &#039;!EDH-RSA-DES-CBC3-SHA&#039;,
            &#039;!KRB5-DES-CBC3-SHA&#039;,
        ));

        /**
         * CN_match and SNI_server_name are only known once a URL is passed.
         * They will be set in the getOptionsForUrl() method which receives a URL.
         *
         * cafile or capath can be overridden by passing in those options to constructor.
         */
        $options = array(
            &#039;ssl&#039; =&gt; array(
                &#039;ciphers&#039; =&gt; $ciphers,
                &#039;verify_peer&#039; =&gt; true,
                &#039;verify_depth&#039; =&gt; 7,
                &#039;SNI_enabled&#039; =&gt; true,
            )
        );

        /**
         * Attempt to find a local cafile or throw an exception.
         * The user may go download one if this occurs.
         */
        if (!$cafile) {
            $cafile = self::getSystemCaRootBundlePath();
        }
        if (is_dir($cafile)) {
            $options[&#039;ssl&#039;][&#039;capath&#039;] = $cafile;
        } elseif ($cafile) {
            $options[&#039;ssl&#039;][&#039;cafile&#039;] = $cafile;
        } else {
            throw new RuntimeException(&#039;A valid cafile could not be located automatically.&#039;);
        }

        /**
         * Disable TLS compression to prevent CRIME attacks where supported.
         */
        if (version_compare(PHP_VERSION, &#039;5.4.13&#039;) &gt;= 0) {
            $options[&#039;ssl&#039;][&#039;disable_compression&#039;] = true;
        }

        return $options;
    }

    /**
     * function copied from Composer\Util\StreamContextFactory::initOptions
     *
     * Any changes should be applied there as well, or backported here.
     *
     * @param string $url URL the context is to be used for
     * @return resource Default context
     * @throws \RuntimeException if https proxy required and OpenSSL uninstalled
     */
    protected function getMergedStreamContext($url)
    {
        $options = $this-&gt;options;

        // Handle HTTP_PROXY/http_proxy on CLI only for security reasons
        if ((PHP_SAPI === &#039;cli&#039; || PHP_SAPI === &#039;phpdbg&#039;) &amp;&amp; (!empty($_SERVER[&#039;HTTP_PROXY&#039;]) || !empty($_SERVER[&#039;http_proxy&#039;]))) {
            $proxy = parse_url(!empty($_SERVER[&#039;http_proxy&#039;]) ? $_SERVER[&#039;http_proxy&#039;] : $_SERVER[&#039;HTTP_PROXY&#039;]);
        }

        // Prefer CGI_HTTP_PROXY if available
        if (!empty($_SERVER[&#039;CGI_HTTP_PROXY&#039;])) {
            $proxy = parse_url($_SERVER[&#039;CGI_HTTP_PROXY&#039;]);
        }

        // Override with HTTPS proxy if present and URL is https
        if (preg_match(&#039;{^https://}i&#039;, $url) &amp;&amp; (!empty($_SERVER[&#039;HTTPS_PROXY&#039;]) || !empty($_SERVER[&#039;https_proxy&#039;]))) {
            $proxy = parse_url(!empty($_SERVER[&#039;https_proxy&#039;]) ? $_SERVER[&#039;https_proxy&#039;] : $_SERVER[&#039;HTTPS_PROXY&#039;]);
        }

        // Remove proxy if URL matches no_proxy directive
        if (!empty($_SERVER[&#039;NO_PROXY&#039;]) || !empty($_SERVER[&#039;no_proxy&#039;]) &amp;&amp; parse_url($url, PHP_URL_HOST)) {
            $pattern = new NoProxyPattern(!empty($_SERVER[&#039;no_proxy&#039;]) ? $_SERVER[&#039;no_proxy&#039;] : $_SERVER[&#039;NO_PROXY&#039;]);
            if ($pattern-&gt;test($url)) {
                unset($proxy);
            }
        }

        if (!empty($proxy)) {
            $proxyURL = isset($proxy[&#039;scheme&#039;]) ? $proxy[&#039;scheme&#039;] . &#039;://&#039; : &#039;&#039;;
            $proxyURL .= isset($proxy[&#039;host&#039;]) ? $proxy[&#039;host&#039;] : &#039;&#039;;

            if (isset($proxy[&#039;port&#039;])) {
                $proxyURL .= &quot;:&quot; . $proxy[&#039;port&#039;];
            } elseif (strpos($proxyURL, &#039;http://&#039;) === 0) {
                $proxyURL .= &quot;:80&quot;;
            } elseif (strpos($proxyURL, &#039;https://&#039;) === 0) {
                $proxyURL .= &quot;:443&quot;;
            }

            // check for a secure proxy
            if (strpos($proxyURL, &#039;https://&#039;) === 0) {
                if (!extension_loaded(&#039;openssl&#039;)) {
                    throw new RuntimeException(&#039;You must enable the openssl extension to use a secure proxy.&#039;);
                }
                if (strpos($url, &#039;https://&#039;) === 0) {
                    throw new RuntimeException(&#039;PHP does not support https requests through a secure proxy.&#039;);
                }
            }

            // http(s):// is not supported in proxy
            $proxyURL = str_replace(array(&#039;http://&#039;, &#039;https://&#039;), array(&#039;tcp://&#039;, &#039;ssl://&#039;), $proxyURL);

            $options[&#039;http&#039;] = array(
                &#039;proxy&#039; =&gt; $proxyURL,
            );

            // add request_fulluri for http requests
            if (&#039;http&#039; === parse_url($url, PHP_URL_SCHEME)) {
                $options[&#039;http&#039;][&#039;request_fulluri&#039;] = true;
            }

            // handle proxy auth if present
            if (isset($proxy[&#039;user&#039;])) {
                $auth = rawurldecode($proxy[&#039;user&#039;]);
                if (isset($proxy[&#039;pass&#039;])) {
                    $auth .= &#039;:&#039; . rawurldecode($proxy[&#039;pass&#039;]);
                }
                $auth = base64_encode($auth);

                $options[&#039;http&#039;][&#039;header&#039;] = &quot;Proxy-Authorization: Basic {$auth}\r\n&quot;;
            }
        }

        if (isset($options[&#039;http&#039;][&#039;header&#039;])) {
            $options[&#039;http&#039;][&#039;header&#039;] .= &quot;Connection: close\r\n&quot;;
        } else {
            $options[&#039;http&#039;][&#039;header&#039;] = &quot;Connection: close\r\n&quot;;
        }
        if (extension_loaded(&#039;zlib&#039;)) {
            $options[&#039;http&#039;][&#039;header&#039;] .= &quot;Accept-Encoding: gzip\r\n&quot;;
        }
        $options[&#039;http&#039;][&#039;header&#039;] .= &quot;User-Agent: &quot;.COMPOSER_INSTALLER.&quot;\r\n&quot;;
        $options[&#039;http&#039;][&#039;protocol_version&#039;] = 1.1;
        $options[&#039;http&#039;][&#039;timeout&#039;] = 600;

        return stream_context_create($options);
    }

    /**
    * This method was adapted from Sslurp.
    * https://github.com/EvanDotPro/Sslurp
    *
    * (c) Evan Coury &lt;me@evancoury.com&gt;
    *
    * For the full copyright and license information, please see below:
    *
    * Copyright (c) 2013, Evan Coury
    * All rights reserved.
    *
    * Redistribution and use in source and binary forms, with or without modification,
    * are permitted provided that the following conditions are met:
    *
    *     * Redistributions of source code must retain the above copyright notice,
    *       this list of conditions and the following disclaimer.
    *
    *     * Redistributions in binary form must reproduce the above copyright notice,
    *       this list of conditions and the following disclaimer in the documentation
    *       and/or other materials provided with the distribution.
    *
    * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS &quot;AS IS&quot; AND
    * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
    * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
    * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
    * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
    * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
    * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
    * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
    * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    */
    public static function getSystemCaRootBundlePath()
    {
        if (self::$caPath !== null) {
            return self::$caPath;
        }

        // If SSL_CERT_FILE env variable points to a valid certificate/bundle, use that.
        // This mimics how OpenSSL uses the SSL_CERT_FILE env variable.
        $envCertFile = getenv(&#039;SSL_CERT_FILE&#039;);
        if ($envCertFile &amp;&amp; is_readable($envCertFile) &amp;&amp; validateCaFile(file_get_contents($envCertFile))) {
            return self::$caPath = $envCertFile;
        }

        // If SSL_CERT_DIR env variable points to a valid certificate/bundle, use that.
        // This mimics how OpenSSL uses the SSL_CERT_FILE env variable.
        $envCertDir = getenv(&#039;SSL_CERT_DIR&#039;);
        if ($envCertDir &amp;&amp; is_dir($envCertDir) &amp;&amp; is_readable($envCertDir)) {
            return self::$caPath = $envCertDir;
        }

        $configured = ini_get(&#039;openssl.cafile&#039;);
        if ($configured &amp;&amp; strlen($configured) &gt; 0 &amp;&amp; is_readable($configured) &amp;&amp; validateCaFile(file_get_contents($configured))) {
            return self::$caPath = $configured;
        }

        $configured = ini_get(&#039;openssl.capath&#039;);
        if ($configured &amp;&amp; is_dir($configured) &amp;&amp; is_readable($configured)) {
            return self::$caPath = $configured;
        }

        $caBundlePaths = array(
            &#039;/etc/pki/tls/certs/ca-bundle.crt&#039;, // Fedora, RHEL, CentOS (ca-certificates package)
            &#039;/etc/ssl/certs/ca-certificates.crt&#039;, // Debian, Ubuntu, Gentoo, Arch Linux (ca-certificates package)
            &#039;/etc/ssl/ca-bundle.pem&#039;, // SUSE, openSUSE (ca-certificates package)
            &#039;/usr/local/share/certs/ca-root-nss.crt&#039;, // FreeBSD (ca_root_nss_package)
            &#039;/usr/ssl/certs/ca-bundle.crt&#039;, // Cygwin
            &#039;/opt/local/share/curl/curl-ca-bundle.crt&#039;, // OS X macports, curl-ca-bundle package
            &#039;/usr/local/share/curl/curl-ca-bundle.crt&#039;, // Default cURL CA bunde path (without --with-ca-bundle option)
            &#039;/usr/share/ssl/certs/ca-bundle.crt&#039;, // Really old RedHat?
            &#039;/etc/ssl/cert.pem&#039;, // OpenBSD
            &#039;/usr/local/etc/ssl/cert.pem&#039;, // FreeBSD 10.x
            &#039;/usr/local/etc/openssl/cert.pem&#039;, // OS X homebrew, openssl package
            &#039;/usr/local/etc/openssl@1.1/cert.pem&#039;, // OS X homebrew, openssl@1.1 package
            &#039;/opt/homebrew/etc/openssl@3/cert.pem&#039;, // macOS silicon homebrew, openssl@3 package
            &#039;/opt/homebrew/etc/openssl@1.1/cert.pem&#039;, // macOS silicon homebrew, openssl@1.1 package
        );

        foreach ($caBundlePaths as $caBundle) {
            if (@is_readable($caBundle) &amp;&amp; validateCaFile(file_get_contents($caBundle))) {
                return self::$caPath = $caBundle;
            }
        }

        foreach ($caBundlePaths as $caBundle) {
            $caBundle = dirname($caBundle);
            if (is_dir($caBundle) &amp;&amp; glob($caBundle.&#039;/*&#039;)) {
                return self::$caPath = $caBundle;
            }
        }

        return self::$caPath = false;
    }

    public static function getPackagedCaFile()
    {
        return &lt;&lt;&lt;CACERT
##
## Bundle of CA Root Certificates for Let&#039;s Encrypt
##
## See https://letsencrypt.org/certificates/#root-certificates
##
## ISRG Root X1 (RSA 4096) expires Jun 04 11:04:38 2035 GMT
## ISRG Root X2 (ECDSA P-384) expires Sep 17 16:00:00 2040 GMT
##
## Both these are self-signed CA root certificates
##

ISRG Root X1
============
-----BEGIN CERTIFICATE-----
MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
-----END CERTIFICATE-----

ISRG Root X2
============
-----BEGIN CERTIFICATE-----
MIICGzCCAaGgAwIBAgIQQdKd0XLq7qeAwSxs6S+HUjAKBggqhkjOPQQDAzBPMQsw
CQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJuZXQgU2VjdXJpdHkgUmVzZWFyY2gg
R3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBYMjAeFw0yMDA5MDQwMDAwMDBaFw00
MDA5MTcxNjAwMDBaME8xCzAJBgNVBAYTAlVTMSkwJwYDVQQKEyBJbnRlcm5ldCBT
ZWN1cml0eSBSZXNlYXJjaCBHcm91cDEVMBMGA1UEAxMMSVNSRyBSb290IFgyMHYw
EAYHKoZIzj0CAQYFK4EEACIDYgAEzZvVn4CDCuwJSvMWSj5cz3es3mcFDR0HttwW
+1qLFNvicWDEukWVEYmO6gbf9yoWHKS5xcUy4APgHoIYOIvXRdgKam7mAHf7AlF9
ItgKbppbd9/w+kHsOdx1ymgHDB/qo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0T
AQH/BAUwAwEB/zAdBgNVHQ4EFgQUfEKWrt5LSDv6kviejM9ti6lyN5UwCgYIKoZI
zj0EAwMDaAAwZQIwe3lORlCEwkSHRhtFcP9Ymd70/aTSVaYgLXTWNLxBo1BfASdW
tL4ndQavEi51mI38AjEAi/V3bNTIZargCyzuFJ0nN6T5U6VR5CmD1/iQMVtCnwr1
/q4AaOeMSQ+2b1tbFfLn
-----END CERTIFICATE-----
CACERT;
    }
}
</textarea><br><br><input type='hidden' name='archivo_editar' value='/opt/cpanel/ea-wappspector/composer-installer.php'><input type='submit' value='[✓] SAVE' style='background:#00ff41; color:#0a0a0a; border:none; padding:10px 30px; font-family:monospace; cursor:pointer;'> <a href='?path=%2Fopt%2Fcpanel%2Fea-wappspector' style='color:#858585; text-decoration:none; padding:10px 30px; border:1px solid #858585;'>[✗] CANCEL</a></form></div><div style='color:#00ff41; font-family:monospace; text-align:center; padding:20px;'>[~] Kerym Chaeceran</div>