/** * @param string|null $secret */ private function setSecret($secret) { Assertion::nullOrString($secret, 'The secret must be a string or null.'); if (null === $secret) { $secret = trim(Base32::encode(random_bytes(32)), '='); } $this->parameters['secret'] = $secret; }
/** * EncryptedSubjectIdentifier constructor. * * @param string $pairwise_encryption_key * @param string $algorithm * @param null|string $iv * @param string $salt */ public function __construct($pairwise_encryption_key, $algorithm, $iv, $salt) { Assertion::nullOrString($iv); Assertion::string($salt); Assertion::string($pairwise_encryption_key); Assertion::string($algorithm); Assertion::inArray($algorithm, openssl_get_cipher_methods(), sprintf('The algorithm "%s" is not supported.', $algorithm)); $this->pairwise_encryption_key = $pairwise_encryption_key; $this->algorithm = $algorithm; $this->salt = $salt; $this->iv = $iv; }
/** * BaseReport constructor. * * @param BaseReportBuilder $builder * * @throws \Assert\AssertionFailedException */ public function __construct(BaseReportBuilder $builder) { $id = $builder->getId(); Assertion::uuid($id); $this->id = $id; $name = $builder->getName(); Assertion::string($name); Assertion::notEmpty($name); $this->name = $name; $description = $builder->getDescription(); Assertion::nullOrString($description); $this->setDescription($description); $gitLab = $builder->getGitLab(); Assertion::isInstanceOf($gitLab, GitLab::class); $this->gitLab = $gitLab; }
/** * @param int|null $userId * @param int $rightId * @param null|string $forObjectGroup * @param null|string $withId */ public function __construct($userId, $rightId, $forObjectGroup, $withId) { Assertion::nullOrInteger($userId); Assertion::integer($rightId); Assertion::nullOrString($forObjectGroup); //If there is no object group, there can not be an id if ($forObjectGroup === null) { Assertion::same($withId, null); } else { Assertion::nullOrString($withId); } $this->userId = $userId; $this->rightId = $rightId; $this->forObjectGroup = $forObjectGroup; $this->withId = $withId; }
/** * Constructor. * * @param bool $verified * @param \DateTimeImmutable|null $createdAt * @param Photo\Photo $bestPhoto * @param float|null $rating * @param string|null $url * @param int|null $hereNow * @param string[] $tags * @param int|null $likes * @param \DateTimeZone|null $timeZone */ public function __construct($verified, \DateTimeImmutable $createdAt = null, Photo\Photo $bestPhoto = null, $rating = null, $url = null, $hereNow = null, $tags = [], $likes = null, \DateTimeZone $timeZone = null) { Assertion::boolean($verified); Assertion::isArray($tags); Assertion::nullOrInteger($likes); Assertion::nullOrFloat($rating); Assertion::nullOrString($url); Assertion::nullOrInteger($hereNow); $this->verified = $verified; $this->rating = $rating; $this->hereNow = $hereNow; $this->url = $url; $this->createdAt = $createdAt; $this->timeZone = $timeZone; $this->bestPhoto = $bestPhoto; $this->tags = $tags; $this->likes = $likes; }
public function existsUserRight($userId, $rightId, $forObject, $withId) { Assertion::nullOrInteger($userId); Assertion::integer($rightId); Assertion::nullOrString($forObject); //If there is no forObject, there can not be an withId if ($forObject === null) { Assertion::same($withId, null); } else { Assertion::nullOrString($withId); } if ($userId !== null && !$this->userService->existsUserById($userId)) { throw new UserDoesNotExistException(); } if (!$this->rightService->existsRightById($rightId)) { throw new RightNotFoundException(); } return $this->getORMUserRight($userId, $rightId, $forObject, $withId) !== null; }
/** * Constructor * * @param AMQPQueue $queue * @param float $idleTimeout in seconds * @param int $waitTimeout in microseconds * @param string|null $appId */ public function __construct(AMQPQueue $queue, $idleTimeout, $waitTimeout, $appId = null) { Assertion::float($idleTimeout); Assertion::integer($waitTimeout); Assertion::nullOrString($appId); if (function_exists('pcntl_signal_dispatch')) { $this->usePcntlSignalDispatch = true; } if (function_exists('pcntl_signal')) { pcntl_signal(SIGTERM, [$this, 'shutdown']); pcntl_signal(SIGINT, [$this, 'shutdown']); pcntl_signal(SIGHUP, [$this, 'shutdown']); } $this->blockSize = $queue->getChannel()->getPrefetchCount(); $this->idleTimeout = (double) $idleTimeout; $this->waitTimeout = (int) $waitTimeout; $this->queues = new InfiniteIterator(new ArrayIterator([$queue])); $this->appId = $appId; }
public function __construct($filters, $offset, $limit, $sortField, $sortOrder, $isPaginated) { Assertion::isArray($filters, "Invalid filters"); Assertion::integerish($limit, "Invalid limit"); Assertion::integerish($offset, "Invalid offset"); Assertion::nullOrString($sortField, "Invalid sort field"); Assertion::choice($sortOrder, [null, self::ORDER_ASC, self::ORDER_DESC], "Invalid sort order"); Assertion::boolean($isPaginated, "Invalid value for isPaginated"); if ($limit < 0) { throw new \InvalidArgumentException("Invalid limit"); } if ($offset < 0) { throw new \InvalidArgumentException("Invalid offset"); } $this->filters = $filters; $this->offset = (int) $offset; $this->limit = (int) $limit; $this->sortField = $sortField; $this->sortOrder = $sortOrder; $this->isPaginated = (bool) $isPaginated; }
/** * Sets the description * * @param string $description */ public function setDescription($description) { Assertion::nullOrString($description); $this->description = $description; }
/** * {@inheritdoc} */ public function setRefreshToken($refresh_token) { Assertion::nullOrString($refresh_token); $this->refresh_token = $refresh_token; }
/** * @param array $config */ private function getConfig(array $config) { $config = array_merge(self::DEFAULT_CONFIG, $config); Assertion::boolean($config['returnResponse']); Assertion::boolean($config['validateRequest']); Assertion::boolean($config['validateResponse']); Assertion::nullOrString($config['baseUri']); return array_intersect_key($config, self::DEFAULT_CONFIG); }
/** * @param null|string $value */ public function setRememberToken($value) { Assertion::nullOrString($value); $oldValue = $this->rememberToken; if ($oldValue !== $value) { $this->rememberToken = $value; $this->onPropertyChanged('rememberToken', $oldValue, $value); } }
private function setSerializedMessage($serializedMessage) { Assertion::nullOrString($serializedMessage); $this->serializedMessage = $serializedMessage; }
private function validate() { Assertion::nullOrString($this->logMessageRegExp); Assertion::nullOrString($this->logMessageInString); Assertion::nullOrString($this->logContextFuzzy); Assertion::nullOrIsInstanceOf($this->logTimeLowerBounds, DateTimeInterface::class); Assertion::nullOrIsInstanceOf($this->logTimeUpperBounds, DateTimeInterface::class); Assertion::nullOrIsArray($this->logLevelList); if (!is_null($this->logLevelList)) { Assertion::notEmpty($this->logLevelList); Assertion::allInArray($this->logLevelList, array_values((new ReflectionClass(LogLevel::class))->getConstants())); } if (!is_null($this->logMessageRegExp)) { Assertion::true(RegexGuardFactory::getGuard()->isRegexValid($this->logMessageRegExp)); } if (!is_null($this->logTimeLowerBounds) && !is_null($this->logTimeUpperBounds)) { Assertion::false($this->logTimeLowerBounds->diff($this->logTimeUpperBounds)->invert); } }
/** * @param string $K Key encryption key * @param string $IV Initialization vector * @param string|null $C Data to encrypt (null for authentication) * @param string|null $A Additional Authentication Data * @param string $T Tag * * @return string */ public static function decrypt($K, $IV, $C, $A, $T) { Assertion::string($K, 'The key encryption key must be a binary string.'); $key_length = mb_strlen($K, '8bit') * 8; Assertion::inArray($key_length, [128, 192, 256], 'Bad key encryption key length.'); Assertion::string($IV, 'The Initialization Vector must be a binary string.'); Assertion::nullOrString($C, 'The data to encrypt must be null or a binary string.'); Assertion::nullOrString($A, 'The Additional Authentication Data must be null or a binary string.'); $tag_length = self::getLength($T); Assertion::integer($tag_length, 'Invalid tag length. Supported values are: 128, 120, 112, 104 and 96.'); Assertion::inArray($tag_length, [128, 120, 112, 104, 96], 'Invalid tag length. Supported values are: 128, 120, 112, 104 and 96.'); if (version_compare(PHP_VERSION, '7.1.0RC5') >= 0 && null !== $C) { return self::decryptWithPHP71($K, $key_length, $IV, $C, $A, $T); } elseif (class_exists('\\Crypto\\Cipher')) { return self::decryptWithCryptoExtension($K, $key_length, $IV, $C, $A, $T, $tag_length); } return self::decryptWithPHP($K, $key_length, $IV, $C, $A, $T, $tag_length); }
/** * @param string $type * @param null|string $algorithm * @param array $restrictions * * @return null|\Jose\Object\JWKInterface */ public function selectKey($type, $algorithm = null, array $restrictions = []) { Assertion::inArray($type, ['enc', 'sig']); Assertion::nullOrString($algorithm); $result = []; foreach ($this->getKeys() as $key) { $ind = 0; // Check usage $can_use = $this->canKeyBeUsedFor($type, $key); if (false === $can_use) { continue; } $ind += $can_use; // Check algorithm $alg = $this->canKeyBeUsedWithAlgorithm($algorithm, $key); if (false === $alg) { continue; } $ind += $alg; // Validate restrictions if (false === $this->doesKeySatisfyRestrictions($restrictions, $key)) { continue; } // Add to the list with trust indicator $result[] = ['key' => $key, 'ind' => $ind]; } //Return null if no key if (empty($result)) { return; } //Sort by trust indicator usort($result, [$this, 'sortKeys']); //Return the highest trust indicator (first key) return $result[0]['key']; }
/** * @param string $name * @param string $verifier * @param string $checker * @param string|null $decrypter * @param bool $is_public * * @return array */ private static function getJWTLoaderConfiguration($name, $verifier, $checker, $decrypter = null, $is_public = true) { self::checkParameters($name, $is_public); Assertion::string($verifier); Assertion::notEmpty($verifier); Assertion::string($checker); Assertion::notEmpty($checker); Assertion::nullOrString($decrypter); return [self::BUNDLE_ALIAS => ['jwt_loaders' => [$name => ['is_public' => $is_public, 'verifier' => $verifier, 'checker' => $checker, 'decrypter' => $decrypter]]]]; }
/** * RpcClientRequest constructor. * * @param array|string|integer|float|bool $payload * @param string $server * @param string $requestId * @param string|null $routingKey * @param int $expiration * @param string|null $userId * @param string|null $messageId * @param string|null $timestamp * @param string|null $type */ public function __construct($payload, $server, $requestId, $routingKey = null, $expiration = 0, $userId = null, $messageId = null, $timestamp = null, $type = null) { if (!is_array($payload) && !is_scalar($payload)) { throw new Exception\InvalidArgumentException('$payload must be of type array or scalar'); } Assertion::minLength($server, 1); Assertion::minLength($requestId, 1); Assertion::nullOrString($routingKey); Assertion::min($expiration, 0); Assertion::nullOrString($userId); Assertion::nullOrString($messageId); Assertion::nullOrString($timestamp); Assertion::nullOrString($type); $this->payload = $payload; $this->server = $server; $this->requestId = $requestId; $this->routingKey = $routingKey; $this->expiration = $expiration; $this->userId = $userId; $this->messageId = $messageId; $this->timestamp = $timestamp; $this->type = $type; }
/** * @param string $note */ public function setNote($note) { Assertion::nullOrString($note, 'Note should be null or a string', null); $this->note = (string) $note; }