Gameap\Services\CertificateService

Complexity

Total Complexity

7

Size/Duplication

Total Lines	124
Duplicated Lines	0 %

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	generate()	0	20	2
A	generateRoot()	0	11	1
A	fingerprintString()	0	4	1
A	certificateInfo()	0	24	1
A	signCertificate()	0	18	2

<?php

namespace Gameap\Services;

use Illuminate\Support\Facades\Storage;
use Carbon\Carbon;

class CertificateService
{
    const ROOT_CA = 'certs/root.crt';
    const ROOT_KEY = 'certs/root.key';

    const CERT_DN = [
        "countryName" => "RU",
        "stateOrProvinceName" => "GameAP",
        "localityName" => "GameAP",
        "organizationName" => "GameAP.ru",
        "organizationalUnitName" => "Development",
        "commonName" => "GameAP",
        "emailAddress" => "support@gameap.ru"
    ];

    const CERT_DAYS = 3650;

    /**
     * Generate root certificate
     */
    static public function generateRoot()
    {
        $privateKey = openssl_pkey_new();
        $csr = openssl_csr_new(self::CERT_DN, $privateKey);
        $certificate = openssl_csr_sign($csr, null, $privateKey, 3650);

        openssl_x509_export($certificate, $pemCertificate);
        openssl_pkey_export($privateKey, $pemPrivateKey);

        Storage::put(self::ROOT_CA, $pemCertificate);
        Storage::put(self::ROOT_KEY, $pemPrivateKey);
    }

    /**
     * @param $certificatePath string   path to certificate in storage
     * @param $keyPath string   path to key in storage
     */
    static public function generate($certificatePath, $keyPath)
    {
        $privateKey = openssl_pkey_new();
        $csr = openssl_csr_new(self::CERT_DN, $privateKey);

        if (!Storage::exists(self::ROOT_CA)) {
            self::generateRoot();
        }

        $rootCa = Storage::get(self::ROOT_CA);
        $rootKey = Storage::get(self::ROOT_KEY);
        $certificate = openssl_csr_sign($csr, $rootCa, $rootKey, 3650);

        openssl_x509_export($certificate, $pemCertificate);
        openssl_pkey_export($privateKey, $pemPrivateKey);

        Storage::makeDirectory('certs');

        Storage::put($certificatePath, $pemCertificate);
        Storage::put($keyPath, $pemPrivateKey);
    }

    /**
     * @param $certificatePath
     *
     * @return string
     */
    static public function fingerprintString($certificatePath)
    {
        $fingerpring = openssl_x509_fingerprint(Storage::get($certificatePath), 'sha1');

Illuminate\Support\Facades\Storage::get($certificatePath) of type Illuminate\Contracts\Filesystem\Filesystem is incompatible with the type string expected by parameter $x509 of openssl_x509_fingerprint().

        return strtoupper(implode(':', str_split($fingerpring, 2)));
    }

    /**
     * @param $certificatePath
     *
     * @return array
     */
    static public function certificateInfo($certificatePath)
    {
        $parsed = openssl_x509_parse(Storage::get($certificatePath));

        return [
            'expires' => Carbon::createFromTimestamp($parsed['validTo_time_t'])->toDateTimeString(),

            'signature_type' => $parsed['signatureTypeSN'],

            'country' => $parsed['subject']['C'],
            'state' => $parsed['subject']['ST'],
            'locality' => $parsed['subject']['L'],
            'organization' => $parsed['subject']['O'],
            'organizational_unit' => $parsed['subject']['OU'],
            'common_name' => $parsed['subject']['CN'],
            'email' => $parsed['subject']['emailAddress'],

            'issuer_country' => $parsed['issuer']['C'],
            'issuer_state' => $parsed['issuer']['ST'],
            'issuer_locality' => $parsed['issuer']['L'],
            'issuer_organization' => $parsed['issuer']['O'],
            'issuer_organizational_unit' => $parsed['issuer']['OU'],
            'issuer_common_name' => $parsed['issuer']['CN'],
            'issuer_email' => $parsed['issuer']['emailAddress'],
        ];
    }

    /**
     * @param $csrPath
     * @return string
     */
    static public function signCertificate($csrPath)
    {
        if (!Storage::exists(self::ROOT_CA)) {
            self::generateRoot();
        }

        $rootCa = Storage::get(self::ROOT_CA);
        $rootKey = Storage::get(self::ROOT_KEY);
        $certificate = Storage::get($csrPath);

        $signedCertificate = openssl_csr_sign($certificate, $rootCa, $rootKey, 3650);
        openssl_x509_export($signedCertificate, $pemCertificate);

        $pathinfo = pathinfo($csrPath);
        $signedCertificatePath = $pathinfo['dirname'] . '/' . $pathinfo['filename'] . '.crt';

        Storage::put($signedCertificatePath, $pemCertificate);
        return $signedCertificatePath;
    }
}