EasyAlipay\Kernel\Traits\Helpers

Complexity

Total Complexity

33

Size/Duplication

Total Lines	243
Duplicated Lines	0 %

Test Coverage

Coverage

36.26%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	checkEmpty()	0	18	6
A	sign()	0	29	5
A	getSignContentUrlencode()	0	20	5
A	checkResponseSign()	0	20	3
A	parserSignSource()	0	13	3
A	verify()	0	32	5
A	getSignContent()	0	20	5
A	generateSign()	0	3	1

<?php
/*
 * This file is part of the wannanbigpig/alipay.
 *
 * (c) wannanbigpig <liuml0211@gmail.com>
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

namespace EasyAlipay\Kernel\Traits;

use EasyAlipay\Kernel\Exceptions\InvalidSignException;
use WannanBigPig\Supports\Exceptions\InvalidArgumentException;

/**
 * Class Helpers
 *
 * @author   liuml  <liumenglei0211@163.com>
 * @DateTime 2019-07-18  17:00
 */
trait Helpers
{
    /**
     * generateSign.
     *
     * @param        $data
     * @param string $signType
     *
     * @return string
     *
     * @throws \WannanBigPig\Supports\Exceptions\InvalidArgumentException
     */
    public function generateSign($data, $signType = 'RSA2')
    {
        return $this->sign($this->getSignContent($data), $signType);
    }

    /**
     * getSignContent.
     *
     * @param $params
     *
     * @return string
     */
    public function getSignContent($params)
    {
        ksort($params);

        $stringToBeSigned = "";
        $i = 0;
        foreach ($params as $k => $v) {
            if (false === $this->checkEmpty($v) && "@" !== substr($v, 0, 1)) {
                if ($i === 0) {
                    $stringToBeSigned .= "$k"."="."$v";
                } else {
                    $stringToBeSigned .= "&"."$k"."="."$v";
                }
                $i++;
            }
        }

        unset($k, $v);

        return $stringToBeSigned;
    }

    /**
     * This method does URLEncode for values.
     *
     * @param $params
     *
     * @return string
     */
    public function getSignContentUrlencode($params)
    {
        ksort($params);

        $stringToBeSigned = "";
        $i = 0;
        foreach ($params as $k => $v) {
            if (false === $this->checkEmpty($v) && "@" !== substr($v, 0, 1)) {
                if ($i === 0) {
                    $stringToBeSigned .= "$k"."=".urlencode($v);
                } else {
                    $stringToBeSigned .= "&"."$k"."=".urlencode($v);
                }
                $i++;
            }
        }

        unset($k, $v);

        return $stringToBeSigned;
    }

    /**
     * sign.
     *
     * @param        $data
     * @param string $signType
     *
     * @return string
     *
     * @throws \WannanBigPig\Supports\Exceptions\InvalidArgumentException
     */
    protected function sign($data, $signType = "RSA2")
    {
        $rsaPrivateKeyFilePath = $this->app['config']->get('private_key_path');
        if ($this->checkEmpty($rsaPrivateKeyFilePath)) {
            $priKey = $this->app['config']['private_key'];
            $res = "-----BEGIN RSA PRIVATE KEY-----\n".
                wordwrap($priKey, 64, "\n", true).
                "\n-----END RSA PRIVATE KEY-----";
        } else {
            $priKey = file_get_contents($rsaPrivateKeyFilePath);
            $res = openssl_get_privatekey($priKey);
        }

        if ($res === false) {
            throw new InvalidArgumentException('Invalid private_key configuration');
        }

        if ("RSA2" === $signType) {
            openssl_sign($data, $sign, $res, OPENSSL_ALGO_SHA256);
        } else {
            openssl_sign($data, $sign, $res);
        }

        if (!$this->checkEmpty($rsaPrivateKeyFilePath)) {
            openssl_free_key($res);

It seems like $res can also be of type string; however, parameter $key_identifier of openssl_free_key() does only seem to accept resource, maybe add an additional type check?

        }
        $sign = base64_encode($sign);

        return $sign;
    }

    /**
     * checkEmpty.
     *
     * @param $value
     *
     * @return bool
     */
    protected function checkEmpty($value)
    {
        if ($value === null) {
            return true;
        }

        if (is_string($value)) {
            if (trim($value) === "") {
                return true;
            }
        } elseif (is_array($value)) {
            if (count($value) < 1) {
                return true;
            }
        }


        return false;
    }

    /**
     * parserSignSource.
     *
     * @param array       $response
     * @param string|null $apiMethod
     *
     * @return array|mixed
     */
    public function parserSignSource(array $response, string $apiMethod = null)
    {
        $response_suffix = '_response';
        $error_respones = 'error_response';
        $apiMethod = $this->app['config']['api_method'] ?? $apiMethod;
        $rootNodeName = str_replace(".", "_", $apiMethod).$response_suffix;

        if (isset($response[$rootNodeName])) {
            return $response[$rootNodeName];
        } elseif (isset($response[$error_respones])) {
            return $response[$error_respones];
        } else {
            return $response;
        }
    }

    /**
     * verify sign.
     *
     * @param string $data
     * @param        $sign
     * @param string $signType
     *
     * @return bool
     *
     * @throws \WannanBigPig\Supports\Exceptions\InvalidArgumentException
     */
    public function verify(string $data, $sign, $signType = 'RSA2')
    {
        $alipayPublicKeyPath = $this->app['config']->get('alipay_public_Key_path');
        if ($this->checkEmpty($alipayPublicKeyPath)) {
            $pubKey = $this->app['config']->get('alipay_public_Key');
            $res = "-----BEGIN PUBLIC KEY-----\n".
                wordwrap($pubKey, 64, "\n", true).
                "\n-----END PUBLIC KEY-----";
        } else {
            // Read public key file
            $pubKey = file_get_contents($alipayPublicKeyPath);
            // Convert to openssl format key
            $res = openssl_get_publickey($pubKey);
        }

        if ($res === false) {

The condition $res === false is always false.

            throw new InvalidArgumentException('Invalid alipay_public_Key configuration');
        }

        // Call openssl built-in method checksum, return bool value
        if ("RSA2" === $signType) {
            $result = (openssl_verify($data, base64_decode($sign, true), $res, OPENSSL_ALGO_SHA256) === 1);
        } else {
            $result = (openssl_verify($data, base64_decode($sign, true), $res) === 1);
        }

        if (!$this->checkEmpty($alipayPublicKeyPath)) {
            // Release resources
            openssl_free_key($res);

It seems like $res can also be of type string; however, parameter $key_identifier of openssl_free_key() does only seem to accept resource, maybe add an additional type check?

        }

        return $result;
    }

    /**
     * checkResponseSign.
     *
     * @param             $content
     * @param string|null $sign
     *
     * @return bool
     *
     * @throws \EasyAlipay\Kernel\Exceptions\InvalidSignException
     * @throws \WannanBigPig\Supports\Exceptions\InvalidArgumentException
     */
    public function checkResponseSign($content, string $sign = null)
    {
        if (!is_null($sign)) {
            $result = $this->verify(
                $content,
                $sign,
                $this->app['config']->get('sign_type', 'RSA2')
            );
        } else {
            throw new InvalidSignException('check sign Fail! The reason : sign data is Empty', 0, $content);
        }

        if (!$result) {
            throw new InvalidSignException(sprintf(
                '"%s" method responds to parameter validation signature error',
                $this->app['config']['api_method']
            ));
        }

        return $result;
    }
}