Jose\Object\StorableJWKSet

Complexity

Total Complexity

34

Size/Duplication

Total Lines	286
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

27 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	1
A	current()	0	4	1
A	next()	0	4	1
A	key()	0	4	1
A	valid()	0	4	1
A	rewind()	0	4	1
A	offsetExists()	0	4	1
A	offsetGet()	0	4	1
A	offsetSet()	0	4	1
A	offsetUnset()	0	4	1
A	getKey()	0	4	1
A	hasKey()	0	4	1
A	getKeys()	0	4	1
A	addKey()	0	4	1
A	removeKey()	0	4	1
A	countKeys()	0	4	1
A	selectKey()	0	4	1
A	count()	0	4	1
A	getFilename()	0	4	1
A	jsonSerialize()	0	4	1
A	getJWKSet()	0	6	1
A	loadJWKSet()	0	16	4
A	getFileContent()	0	13	3
A	hasJWKSetBeenUpdated()	0	9	2
A	createJWKSet()	0	10	2
A	createJWK()	0	7	1
A	save()	0	4	1

<?php

/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2014-2016 Spomky-Labs
 *
 * This software may be modified and distributed under the terms
 * of the MIT license.  See the LICENSE file for details.
 */

namespace Jose\Object;

use Assert\Assertion;
use Base64Url\Base64Url;
use Jose\Factory\JWKFactory;

/**
 * Class StorableJWKSet.
 */
class StorableJWKSet implements StorableJWKSetInterface
{
    /**
     * @var \Jose\Object\JWKSetInterface
     */
    protected $jwkset;

    /**
     * @var string
     */
    protected $filename;

    /**
     * @var int
     */
    protected $last_modification_time = null;

    /**
     * @var array
     */
    protected $parameters;

    /**
     * @var array
     */
    protected $nb_keys;

    /**
     * StorableJWKSet constructor.
     *
     * @param string $filename
     * @param array  $parameters
     * @param int    $nb_keys
     */
    public function __construct($filename, array $parameters, $nb_keys)
    {
        Assertion::directory(dirname($filename), 'The selected directory does not exist.');
        Assertion::writeable(dirname($filename), 'The selected directory is not writable.');
        Assertion::integer($nb_keys, 'The key set must contain at least one key.');
        Assertion::greaterThan($nb_keys, 0, 'The key set must contain at least one key.');
        $this->filename = $filename;
        $this->parameters = $parameters;
        $this->nb_keys = $nb_keys;

It seems like $nb_keys of type integer is incompatible with the declared type array of property $nb_keys.

    }

    /**
     * {@inheritdoc}
     */
    public function current()
    {
        return $this->getJWKSet()->current();
    }

    /**
     * {@inheritdoc}
     */
    public function next()
    {
        $this->getJWKSet()->next();
    }

    /**
     * {@inheritdoc}
     */
    public function key()
    {
        return $this->getJWKSet()->key();
    }

    /**
     * {@inheritdoc}
     */
    public function valid()
    {
        return $this->getJWKSet()->valid();
    }

    /**
     * {@inheritdoc}
     */
    public function rewind()
    {
        $this->getJWKSet()->rewind();
    }

    /**
     * {@inheritdoc}
     */
    public function offsetExists($offset)
    {
        return $this->getJWKSet()->offsetExists($offset);
    }

    /**
     * {@inheritdoc}
     */
    public function offsetGet($offset)
    {
        return $this->getJWKSet()->offsetGet($offset);
    }

    /**
     * {@inheritdoc}
     */
    public function offsetSet($offset, $value)
    {
        return $this->getJWKSet()->offsetSet($offset, $value);
    }

    /**
     * {@inheritdoc}
     */
    public function offsetUnset($offset)
    {
        return $this->getJWKSet()->offsetUnset($offset);
    }

    /**
     * {@inheritdoc}
     */
    public function getKey($index)
    {
        return $this->getJWKSet()->getKey($index);
    }

    /**
     * {@inheritdoc}
     */
    public function hasKey($index)
    {
        return $this->getJWKSet()->hasKey($index);
    }

    /**
     * {@inheritdoc}
     */
    public function getKeys()
    {
        return $this->getJWKSet()->getKeys();
    }

    /**
     * {@inheritdoc}
     */
    public function addKey(JWKInterface $key)
    {
        return $this->getJWKSet()->addKey($key);
    }

    /**
     * {@inheritdoc}
     */
    public function removeKey($index)
    {
        return $this->getJWKSet()->removeKey($index);
    }

    /**
     * {@inheritdoc}
     */
    public function countKeys()
    {
        return $this->getJWKSet()->countKeys();
    }

    /**
     * {@inheritdoc}
     */
    public function selectKey($type, $algorithm = null, array $restrictions = [])
    {
        return $this->getJWKSet()->selectKey($type, $algorithm, $restrictions);
    }

    /**
     * {@inheritdoc}
     */
    public function count()
    {
        return $this->getJWKSet()->count();
    }

    /**
     * @return string
     */
    protected function getFilename()
    {
        return $this->filename;
    }

    /**
     * {@inheritdoc}
     */
    public function jsonSerialize()
    {
        return $this->getJWKSet()->jsonSerialize();
    }

    /**
     * @return \Jose\Object\JWKSetInterface
     */
    protected function getJWKSet()
    {
        $this->loadJWKSet();

        return $this->jwkset;
    }


    protected function loadJWKSet()
    {
        if (file_exists($this->filename)) {
            if (false === $this->hasJWKSetBeenUpdated()) {
                return;
            }
            $content = $this->getFileContent();
            if (null === $content) {
                $this->createJWKSet();
            }
            $this->last_modification_time = filemtime($this->getFilename());
            $this->jwkset = new JWKSet($content);

It seems like $content defined by $this->getFileContent() on line 235 can also be of type null; however, Jose\Object\JWKSet::__construct() does only seem to accept array, maybe add an additional type check?

        } else {
            $this->createJWKSet();
        }
    }

    /**
     * @return null|string
     */
    protected function getFileContent()
    {
        $content = file_get_contents($this->filename);
        if (false === $content) {
            return null;
        }
        $content = json_decode($content, true);
        if (!is_array($content)) {
            return null;
        }

        return $content;
    }

    /**
     * @return bool
     */
    protected function hasJWKSetBeenUpdated()
    {
        if (null !== $this->last_modification_time) {
            $mtime = filemtime($this->getFilename());
            return $mtime !== $this->last_modification_time;
        }

        return true;
    }

    /**
     *
     */
    protected function createJWKSet()
    {
        $this->jwkset = new JWKSet();
        for ($i = 0; $i < $this->nb_keys; $i++) {
            $key = $this->createJWK();
            $this->jwkset->addKey($key);

It seems like $key defined by $this->createJWK() on line 283 can also be of type object<Jose\Object\JWKSet>; however, Jose\Object\JWKSet::addKey() does only seem to accept object<Jose\Object\JWKInterface>, maybe add an additional type check?

        }

        $this->save();
    }

    /**
     * @return \Jose\Object\JWKInterface
     */
    protected function createJWK()
    {
        $data = JWKFactory::createKey($this->parameters)->getAll();
        $data['kid'] = Base64Url::encode(random_bytes(64));

        return JWKFactory::createFromValues($data);
    }


    protected function save()
    {
        file_put_contents($this->getFilename(), json_encode($this->jwkset));
    }
}