/** * {@inheritdoc} */ public function checkerParameter(ClientInterface $client, array &$parameters) { if (!array_key_exists('prompt', $parameters)) { return; } Assertion::true(empty(array_diff($parameters['prompt'], $this->getAllowedPromptValues())), sprintf('Invalid parameter "prompt". Allowed values are %s', json_encode($this->getAllowedPromptValues()))); Assertion::false(in_array('none', $parameters['prompt']) && 1 !== count($parameters['prompt']), 'Invalid parameter "prompt". Prompt value "none" must be used alone.'); }
/** * @param string $gameId * @param string $letter * @return int */ public function chooseLetter($gameId, $letter) { Assertion::false($this->gameWon, "Game already won"); Assertion::false($this->gameLost, "Game already lost"); // if letter already exists do nothing if ($this->lettersCorrectlyGuessed->LetterExistsInContainer($letter) || $this->lettersWrongGuessed->LetterExistsInContainer($letter)) { $this->wrongGuessedLetter($gameId, $letter); return; } // Execute the right event $wordContainsLetter = $this->word->wordContainsLetter($letter); if ($wordContainsLetter === false) { $this->wrongGuessedLetter($gameId, $letter); return; } // throw good guess $this->correctlyGuessedLetters($gameId, $letter); }
/** * {@inheritdoc} */ public function encrypt(Object\JWEInterface &$jwe) { Assertion::false($jwe->isEncrypted(), 'The JWE is already encrypted.'); Assertion::greaterThan($jwe->countRecipients(), 0, 'The JWE does not contain recipient.'); $additional_headers = []; $nb_recipients = $jwe->countRecipients(); $content_encryption_algorithm = $this->getContentEncryptionAlgorithm($jwe); $compression_method = $this->getCompressionMethod($jwe); $key_management_mode = $this->getKeyManagementMode($jwe); $cek = $this->determineCEK($jwe, $content_encryption_algorithm, $key_management_mode, $additional_headers); for ($i = 0; $i < $nb_recipients; $i++) { $this->processRecipient($jwe, $jwe->getRecipient($i), $cek, $content_encryption_algorithm, $additional_headers); } if (!empty($additional_headers) && 1 === $jwe->countRecipients()) { $jwe = $jwe->withSharedProtectedHeaders(array_merge($jwe->getSharedProtectedHeaders(), $additional_headers)); } $iv_size = $content_encryption_algorithm->getIVSize(); $iv = $this->createIV($iv_size); $this->encryptJWE($jwe, $content_encryption_algorithm, $cek, $iv, $compression_method); }
/** * @param \Jose\Object\JWSInterface $jws * @param null|string $detached_payload */ private function checkPayload(Object\JWSInterface $jws, $detached_payload = null) { Assertion::false(null !== $detached_payload && !empty($jws->getPayload()), 'A detached payload is set, but the JWS already has a payload.'); Assertion::true(!empty($jws->getPayload()) || null !== $detached_payload, 'No payload.'); }
/** * @param array $complete_header The complete header * @param \Jose\Object\JWKInterface $key * * @return \Jose\Algorithm\SignatureAlgorithmInterface */ private function getSignatureAlgorithm(array $complete_header, Object\JWKInterface $key) { Assertion::keyExists($complete_header, 'alg', 'No "alg" parameter set in the header.'); Assertion::false($key->has('alg') && $key->get('alg') !== $complete_header['alg'], sprintf('The algorithm "%s" is not allowed with this key.', $complete_header['alg'])); $signature_algorithm = $this->getJWAManager()->getAlgorithm($complete_header['alg']); Assertion::isInstanceOf($signature_algorithm, Algorithm\SignatureAlgorithmInterface::class, sprintf('The algorithm "%s" is not supported.', $complete_header['alg'])); return $signature_algorithm; }
/** * @throws \InvalidArgumentException * * @return string */ private function downloadContent() { $params = [CURLOPT_RETURNTRANSFER => true, CURLOPT_URL => $this->url]; if (false === $this->allow_unsecured_connection) { $params[CURLOPT_SSL_VERIFYPEER] = true; $params[CURLOPT_SSL_VERIFYHOST] = 2; } $ch = curl_init(); curl_setopt_array($ch, $params); $content = curl_exec($ch); curl_close($ch); Assertion::false(false === $content, 'Unable to get content.'); return $content; }
/** * @Then /^the block should not be confirmed$/ */ public function ensureNotBlocked() { Assertion::false($this->isBlocked); }
public function testInvalidFalse() { $this->setExpectedException('Assert\\AssertionFailedException', null, Assertion::INVALID_FALSE); Assertion::false(true); }
/** * {@inheritdoc} */ public function uncompress($data) { $data = gzuncompress($data); Assertion::false(false === $data, 'Unable to uncompress data'); return $data; }
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 \SpomkyLabs\JoseBundle\DependencyInjection\Source\SourceInterface $source */ public function addServiceSource(Source\SourceInterface $source) { $name = $source->getName(); Assertion::false(in_array($name, $this->service_sources), sprintf('The source "%s" is already set.', $name)); $this->service_sources[$name] = $source; }
/** * @throws \InvalidArgumentException */ private function checkRedirectUriForAllClient() { Assertion::false($this->isRedirectUriStorageEnforced(), 'Clients must register at least one redirect URI.'); }
/** * @param string $data * * @throws \Exception * @throws \FG\ASN1\Exception\ParserException * * @return array */ private function loadPEM($data) { $res = openssl_pkey_get_private($data); if (false === $res) { $res = openssl_pkey_get_public($data); } Assertion::false(false === $res, 'Unable to load the key'); $details = openssl_pkey_get_details($res); Assertion::keyExists($details, 'rsa', 'Unable to load the key'); $this->values['kty'] = 'RSA'; $keys = ['n' => 'n', 'e' => 'e', 'd' => 'd', 'p' => 'p', 'q' => 'q', 'dp' => 'dmp1', 'dq' => 'dmq1', 'qi' => 'iqmp']; foreach ($details['rsa'] as $key => $value) { if (in_array($key, $keys)) { $value = Base64Url::encode($value); $this->values[array_search($key, $keys)] = $value; } } }
/** * @Then /^no log about "(.*)" should exist on user "(.*)" should exist$/ * * @param string $ip * @param string $username */ public function ensureNoLogRemains(string $ip, string $username) { Assertion::false($this->getEntityManager()->getRepository('Account:User')->findOneBy(['username' => $username])->exceedsIpFailedAuthAttemptMaximum($ip, new DateTimeComparison())); }
/** * {@inheritdoc} */ public function addPKCEMethod(PKCEMethodInterface $method) { Assertion::false(array_key_exists($method->getMethodName(), $this->pkce_methods), sprintf('The method "%s" already exists.', $method->getMethodName())); $this->pkce_methods[$method->getMethodName()] = $method; }
/** * @param array $x5c * * @return array */ public static function loadFromX5C(array $x5c) { $certificate = null; $last_issuer = null; $last_subject = null; foreach ($x5c as $cert) { $current_cert = '-----BEGIN CERTIFICATE-----' . PHP_EOL . $cert . PHP_EOL . '-----END CERTIFICATE-----'; $x509 = openssl_x509_read($current_cert); if (false === $x509) { $last_issuer = null; $last_subject = null; break; } $parsed = openssl_x509_parse($x509); openssl_x509_free($x509); if (false === $parsed) { $last_issuer = null; $last_subject = null; break; } if (null === $last_subject) { $last_subject = $parsed['subject']; $last_issuer = $parsed['issuer']; $certificate = $current_cert; } else { if (json_encode($last_issuer) === json_encode($parsed['subject'])) { $last_subject = $parsed['subject']; $last_issuer = $parsed['issuer']; } else { $last_issuer = null; $last_subject = null; break; } } } Assertion::false(null === $last_issuer || json_encode($last_issuer) !== json_encode($last_subject), 'Invalid certificate chain.'); return self::loadKeyFromCertificate($certificate); }
/** * @param string $thumbnailLocation * @param string $title * @param string $description * @param string|null $contentLocation * @param PlayerLocationInterface|null $playerLocation * * @throws \InvalidArgumentException */ public function __construct($thumbnailLocation, $title, $description, $contentLocation = null, PlayerLocationInterface $playerLocation = null) { Assertion::maxLength($title, VideoInterface::TITLE_MAX_LENGTH); Assertion::maxLength($description, VideoInterface::DESCRIPTION_MAX_LENGTH); Assertion::false($contentLocation === null && $playerLocation === null, sprintf('At least one of parameters "%s" needs to be specified', implode('", "', ['contentLocation', 'playerLocation']))); $this->thumbnailLocation = $thumbnailLocation; $this->title = $title; $this->description = $description; $this->contentLocation = $contentLocation; $this->playerLocation = $playerLocation; }
/** * @When I enter this api key in order to approve the recently created account */ public function iEnterThisApiKeyInOrderToApproveTheRecentlyCreatedAccount() { $user = $this->getRegisteredUser(); $query = http_build_query(['username' => $user->getUsername(), 'activation_key' => $user->getActivationKey()]); Assertion::false(empty($user->getActivationKey())); $this->response = $this->performRequest('PATCH', sprintf('/api/users/activate.json?%s', $query), [], true, [], [], 204); }
/** * Authenticates a user and returns the api key. * * @param string $username * @param string $password * @param bool $expectSuccess * * @throws \Exception If the authentication failed * * @return string */ protected function authenticate($username, $password, $expectSuccess = true) { $response = $this->performRequest('POST', '/api/api-key.json', ['username' => $username, 'password' => $password], $expectSuccess, [], [], $expectSuccess ? 200 : 401); if ($expectSuccess) { return $response['apiKey']; } else { Assertion::false(isset($response['apiKey'])); return false; } }
/** * @param string $key The Key to wrap * @param bool $padding_enabled */ private static function checkKeySize($key, $padding_enabled) { Assertion::false(false === $padding_enabled && 0 !== mb_strlen($key, '8bit') % 8, 'Bad key size'); Assertion::greaterOrEqualThan(mb_strlen($key, '8bit'), 1, 'Bad key size'); }
/** * @param array $request_parameters */ private function checkSoftwareStatement(array &$request_parameters) { if ($this->isSoftwareStatementSupported()) { Assertion::false(false === array_key_exists('software_statement', $request_parameters) && true === $this->is_software_statement_required, 'Software Statement required.'); if (array_key_exists('software_statement', $request_parameters)) { $this->updateRequestParametersWithSoftwareStatement($request_parameters); } } elseif (array_key_exists('software_statement', $request_parameters)) { throw new \InvalidArgumentException('Software Statement parameter not supported.'); } }
/** * @param string $issuer */ public function setIssuer($issuer) { Assertion::string($issuer, 'Issuer must be a string.'); Assertion::false($this->hasColon($issuer), 'Issuer must not contain a colon.'); $this->issuer = $issuer; }
/** * @Then the key should not be approvable */ public function theKeyShouldNotBeApprovable() { Assertion::false($this->result); }