Tmilos\JoseJwt\Util\StringUtils

Complexity

Total Complexity

21

Size/Duplication

Total Lines	110
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	2

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	equals()	0	25	4
A	length()	0	13	3
A	substring()	0	15	4
B	payload2string()	0	18	9

<?php

/*
 * This file is part of the tmilos/jose-jwt package.
 *
 * (c) Milos Tomic <tmilos@gmail.com>
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

namespace Tmilos\JoseJwt\Util;

use Tmilos\JoseJwt\Error\JoseJwtException;
use Tmilos\JoseJwt\Json\JsonMapper;

class StringUtils
{
    private function __construct()
    {
    }

    /**
     * Compares two strings.
     *
     * This method implements a constant-time algorithm to compare strings.
     * Regardless of the used implementation, it will leak length information.
     *
     * @param string $knownString The string of known length to compare against
     * @param string $userInput   The string that the user can control
     *
     * @return bool true if the two strings are the same, false otherwise
     */
    public static function equals($knownString, $userInput)
    {
        static $exists = null;
        if (null === $exists) {
            $exists = function_exists('hash_equals');
        }
        $knownString = (string) $knownString;
        $userInput = (string) $userInput;
        if ($exists) {
            return hash_equals($knownString, $userInput);
        }
        $knownLen = strlen($knownString);
        $userLen = strlen($userInput);
        // Extend the known string to avoid uninitialized string offsets
        $knownString .= $userInput;
        // Set the result to the difference between the lengths
        $result = $knownLen - $userLen;
        // Note that we ALWAYS iterate over the user-supplied length
        // This is to mitigate leaking length information
        for ($i = 0; $i < $userLen; ++$i) {
            $result |= (ord($knownString[$i]) ^ ord($userInput[$i]));
        }
        // They are only identical strings if $result is exactly 0...
        return 0 === $result;
    }

    /**
     * @param string $value
     *
     * @return int
     */
    public static function length($value)
    {
        static $exists = null;
        if (null === $exists) {
            $exists = function_exists('mb_strlen');
        }

        if ($exists) {
            return mb_strlen($value, '8bit');
        }

        return strlen($value);
    }

    /**
     * @param string $value
     * @param int    $start
     * @param int    $length
     *
     * @return string
     */
    public static function substring($value, $start = 0, $length = null)
    {
        static $exists = null;
        if (null === $exists) {
            $exists = function_exists('mb_substr');
        }

        if ($exists) {
            return mb_substr($value, $start, $length, '8bit');
        } elseif ($length !== null) {
            return substr($value, $start, $length);
        }

        return substr($value, $start);
    }

    /**
     * @param string|array|object $payload
     * @param JsonMapper          $mapper
     *
     * @return string
     */
    public static function payload2string($payload, JsonMapper $mapper = null)
    {
        if (is_array($payload)) {
            return json_encode($payload, JSON_UNESCAPED_SLASHES);
        } elseif (is_string($payload) || null === $payload) {
            if (trim($payload) !== '') {
                return $payload;
            } else {
                throw new JoseJwtException('Payload can not be empty');
            }
        } elseif (is_object($payload) && $payload instanceof \JsonSerializable) {
            return json_encode($payload, JSON_UNESCAPED_SLASHES);
        } elseif (is_object($payload) && $mapper) {
            return $mapper->getJsonString($payload);
        }

        throw new JoseJwtException('Unable to serialize payload');
    }
}