public function signRequest(RequestInterface $request, CredentialsInterface $credentials) { $params = Psr7\parse_query($request->getBody()); $params['Timestamp'] = gmdate('c'); $params['SignatureVersion'] = '2'; $params['SignatureMethod'] = 'HmacSHA256'; $params['AWSAccessKeyId'] = $credentials->getAccessKeyId(); if ($token = $credentials->getSecurityToken()) { $params['SecurityToken'] = $token; } // build string to sign $sign = $request->getMethod() . "\n" . $request->getHeaderLine('Host') . "\n" . '/' . "\n" . $this->getCanonicalizedParameterString($params); $params['Signature'] = base64_encode(hash_hmac('sha256', $sign, $credentials->getSecretKey(), true)); return $request->withBody(Psr7\stream_for(http_build_query($params))); }
public function signRequest(RequestInterface $request, CredentialsInterface $credentials) { $params = Psr7\parse_query($request->getBody()->__toString()); $params['SignatureVersion'] = '2'; $params['SignatureMethod'] = 'HmacSHA256'; $params['AWSAccessKeyId'] = $credentials->getAccessKeyId(); if ($credentials->getSecurityToken()) { $params['MWSAuthToken'] = $credentials->getSecurityToken(); } $params['Timestamp'] = gmdate(self::ISO8601_BASIC); ksort($params); $canonicalizedQueryString = $this->getCanonicalizedQuery($params); $stringToSign = implode("\n", [$request->getMethod(), $request->getUri()->getHost(), $request->getUri()->getPath(), $canonicalizedQueryString]); // calculate HMAC with SHA256 and base64-encoding $signature = base64_encode(hash_hmac('sha256', $stringToSign, $credentials->getSecretKey(), TRUE)); // encode the signature for the request $signature = str_replace('%7E', '~', rawurlencode($signature)); $signature = str_replace('+', '%20', $signature); $signature = str_replace('*', '%2A', $signature); $queryString = $canonicalizedQueryString . "&Signature=" . $signature; if ($request->getMethod() === 'POST') { return new Request('POST', $request->getUri(), ['Content-Length' => strlen($queryString), 'Content-Type' => 'application/x-www-form-urlencoded'], $queryString); } else { return new Request('GET', $request->getUri()->withQuery($queryString)); } }
public function getSelectedValues(UriInterface $uri) { $queryParams = Psr7\parse_query($uri->getQuery()); $selectedValues = []; foreach ($queryParams as $paramName => $params) { if (!isset($this->paramFacets[$paramName])) { continue; } $facetName = $this->paramFacets[$paramName]; $selectedValues[$facetName] = $params; } return $selectedValues; }
/** * Updates the request query with the developer key if auth is set to simple * * use Google\Auth\Middleware\SimpleMiddleware; * use GuzzleHttp\Client; * use GuzzleHttp\HandlerStack; * * $my_key = 'is not the same as yours'; * $middleware = new SimpleMiddleware(['key' => $my_key]); * $stack = HandlerStack::create(); * $stack->push($middleware); * * $client = new Client([ * 'handler' => $stack, * 'base_uri' => 'https://www.googleapis.com/discovery/v1/', * 'auth' => 'simple' * ]); * * $res = $client->get('drive/v2/rest'); */ public function __invoke(callable $handler) { return function (RequestInterface $request, array $options) use($handler) { // Requests using "auth"="scoped" will be authorized. if (!isset($options['auth']) || $options['auth'] !== 'simple') { return $handler($request, $options); } $query = Psr7\parse_query($request->getUri()->getQuery()); $params = array_merge($query, $this->config); $uri = $request->getUri()->withQuery(Psr7\build_query($params)); $request = $request->withUri($uri); return $handler($request, $options); }; }
/** * Create a signed Amazon CloudFront URL. * * Keep in mind that URLs meant for use in media/flash players may have * different requirements for URL formats (e.g. some require that the * extension be removed, some require the file name to be prefixed * - mp4:<path>, some require you to add "/cfx/st" into your URL). * * @param string $url URL to sign (can include query * string string and wildcards) * @param string|integer|null $expires UTC Unix timestamp used when signing * with a canned policy. Not required * when passing a custom $policy. * @param string $policy JSON policy. Use this option when * creating a signed URL for a custom * policy. * * @return string The file URL with authentication parameters * @throws \InvalidArgumentException if the URL provided is invalid * @link http://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/WorkingWithStreamingDistributions.html */ public function getSignedUrl($url, $expires = null, $policy = null) { // Determine the scheme of the url $urlSections = explode('://', $url); if (count($urlSections) < 2) { throw new \InvalidArgumentException("Invalid URL: {$url}"); } // Get the real scheme by removing wildcards from the scheme $scheme = str_replace('*', '', $urlSections[0]); $uri = new Uri($scheme . '://' . $urlSections[1]); $query = Psr7\parse_query($uri->getQuery(), PHP_QUERY_RFC3986); $signature = $this->signer->getSignature($this->createResource($scheme, (string) $uri), $expires, $policy); $uri = $uri->withQuery(http_build_query($query + $signature, null, '&', PHP_QUERY_RFC3986)); return $scheme === 'rtmp' ? $this->createRtmpUrl($uri) : (string) $uri; }
protected function assertUriEquals($expectedUri, $actualUri) { if (is_string($expectedUri)) { $expectedUri = new Psr7\Uri($expectedUri); } if (is_string($actualUri)) { $actualUri = new Psr7\Uri($actualUri); } $this->assertEquals($expectedUri->getScheme(), $actualUri->getScheme()); $this->assertEquals($expectedUri->getPort(), $actualUri->getPort()); $this->assertEquals($expectedUri->getHost(), $actualUri->getHost()); $this->assertEquals($expectedUri->getPath(), $actualUri->getPath()); $expectedQueryParts = Psr7\parse_query($expectedUri->getQuery()); $actualQueryParts = Psr7\parse_query($actualUri->getQuery()); $this->assertEquals($expectedQueryParts, $actualQueryParts); }
/** * Create a signed Amazon CloudFront URL. * * Keep in mind that URLs meant for use in media/flash players may have * different requirements for URL formats (e.g. some require that the * extension be removed, some require the file name to be prefixed * - mp4:<path>, some require you to add "/cfx/st" into your URL). * * @param string $url URL to sign (can include query * string string and wildcards * @param string|integer|null $expires UTC Unix timestamp used when signing * with a canned policy. Not required * when passing a custom $policy. * @param string $policy JSON policy. Use this option when * creating a signed URL for a custom * policy. * * @return string The file URL with authentication parameters * @throws \InvalidArgumentException if the URL provided is invalid * @link http://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/WorkingWithStreamingDistributions.html */ public function getSignedUrl($url, $expires = null, $policy = null) { // Determine the scheme of the url $urlSections = explode('://', $url); if (count($urlSections) < 2) { throw new \InvalidArgumentException("Invalid URL: {$url}"); } // Get the real scheme by removing wildcards from the scheme $scheme = str_replace('*', '', $urlSections[0]); $uri = new Uri($scheme . '://' . $urlSections[1]); if ($policy) { $isCustom = true; } else { $isCustom = false; $policy = $this->createCannedPolicy($scheme, (string) $uri, $expires); } $policy = str_replace(' ', '', $policy); $query = Psr7\parse_query($uri->getQuery(), PHP_QUERY_RFC3986); $query = $this->prepareQuery($isCustom, $policy, $query, $expires); $uri = $uri->withQuery(http_build_query($query, null, '&', PHP_QUERY_RFC3986)); return $scheme === 'rtmp' ? $this->createRtmpUrl($uri) : (string) $uri; }
public function testCanControlDecodingType() { $result = Psr7\parse_query('var=foo+bar', PHP_QUERY_RFC3986); $this->assertEquals('foo+bar', $result['var']); $result = Psr7\parse_query('var=foo+bar', PHP_QUERY_RFC1738); $this->assertEquals('foo bar', $result['var']); }
/** * Asserts that the query string of the request contains the specified query parameter. * * If value is provided, the value will also be comaped * * @param RequestInterface $request * @param string $name * @param string|null $value */ public function assertHasQuery(RequestInterface $request, $name, $value = null) { $query = Psr7\parse_query($request->getUri()->getQuery()); $this->assertArrayHasKey($name, $query, "The request does not contain the query parameter {$name}"); if (!is_null($value)) { $this->assertEquals($value, $query[$name], "The request contains the query parameter {$name}, but with the wrong value."); } }
public function testGeneratesExtendedRequests() { $testConfig = $this->tokenRequestMinimal; $o = new OAuth2($testConfig); $o->setGrantType('urn:my_test_grant_type'); $o->setExtensionParams(['my_param' => 'my_value']); // Generate the request and confirm that it's correct. $req = $o->generateCredentialsRequest(); $this->assertInstanceOf('Psr\\Http\\Message\\RequestInterface', $req); $this->assertEquals('POST', $req->getMethod()); $fields = Psr7\parse_query((string) $req->getBody()); $this->assertEquals('my_value', $fields['my_param']); $this->assertEquals('urn:my_test_grant_type', $fields['grant_type']); }
protected function parseConnections($options, $defaultHost, $defaultPort, $defaultScheme = 'tcp') { if (isset($options['host']) || isset($options['port'])) { $options['connections'][] = $options; } elseif ($options['connection']) { $options['connections'][] = $options['connection']; } /** @var ParameterBag[] $toParse */ $toParse = []; if (isset($options['connections'])) { foreach ((array) $options['connections'] as $alias => $conn) { if (is_string($conn)) { $conn = ['host' => $conn]; } $conn += ['scheme' => $defaultScheme, 'host' => $defaultHost, 'port' => $defaultPort]; $conn = new ParameterBag($conn); if ($conn->has('password')) { $conn->set('pass', $conn->get('password')); $conn->remove('password'); } $conn->set('uri', Uri::fromParts($conn->all())); $toParse[] = $conn; } } else { $connections = isset($options['save_path']) ? (array) explode(',', $options['save_path']) : []; if (empty($connections)) { $connections[] = $defaultHost . ':' . $defaultPort; } foreach ($connections as $conn) { // Default scheme if not given so parse_url works correctly. if (!preg_match('~^\\w+://.+~', $conn)) { $conn = $defaultScheme . '://' . $conn; } $uri = new Uri($conn); $connBag = new ParameterBag(); $connBag->set('uri', $uri); $connBag->add(Psr7\parse_query($uri->getQuery())); $toParse[] = $connBag; } } $connections = []; foreach ($toParse as $conn) { /** @var Uri $uri */ $uri = $conn->get('uri'); $parts = explode(':', $uri->getUserInfo(), 2); $password = isset($parts[1]) ? $parts[1] : null; $connections[] = ['scheme' => $uri->getScheme(), 'host' => $uri->getHost(), 'port' => $uri->getPort(), 'path' => $uri->getPath(), 'alias' => $conn->get('alias'), 'prefix' => $conn->get('prefix'), 'password' => $password, 'database' => $conn->get('database'), 'persistent' => $conn->get('persistent'), 'weight' => $conn->get('weight'), 'timeout' => $conn->get('timeout')]; } return $connections; }
/** * Builds the authorization Uri that the user should be redirected to. * * @param array $config configuration options that customize the return url * * @return UriInterface the authorization Url. * * @throws InvalidArgumentException */ public function buildFullAuthorizationUri(array $config = []) { if (is_null($this->getAuthorizationUri())) { throw new InvalidArgumentException('requires an authorizationUri to have been set'); } $params = array_merge(['response_type' => 'code', 'access_type' => 'offline', 'client_id' => $this->clientId, 'redirect_uri' => $this->redirectUri, 'state' => $this->state, 'scope' => $this->getScope()], $config); // Validate the auth_params if (is_null($params['client_id'])) { throw new InvalidArgumentException('missing the required client identifier'); } if (is_null($params['redirect_uri'])) { throw new InvalidArgumentException('missing the required redirect URI'); } if (!empty($params['prompt']) && !empty($params['approval_prompt'])) { throw new InvalidArgumentException('prompt and approval_prompt are mutually exclusive'); } // Construct the uri object; return it if it is valid. $result = clone $this->authorizationUri; $existingParams = Psr7\parse_query($result->getQuery()); $result = $result->withQuery(Psr7\build_query(array_merge($existingParams, $params))); if ($result->getScheme() != 'https') { throw new InvalidArgumentException('Authorization endpoint must be protected by TLS'); } return $result; }
private function parseRequest(RequestInterface $request) { // Clean up any previously set headers. /** @var RequestInterface $request */ $request = $request->withoutHeader('X-Amz-Date')->withoutHeader('Date')->withoutHeader('Authorization'); $uri = $request->getUri(); return ['method' => $request->getMethod(), 'path' => $uri->getPath(), 'query' => Psr7\parse_query($uri->getQuery()), 'uri' => $uri, 'headers' => $request->getHeaders(), 'body' => $request->getBody(), 'version' => $request->getProtocolVersion()]; }
private function applyQuery(RequestInterface $request, $query) { $uri = $request->getUri(); if (!is_array($query)) { $query = GuzzlePsr7\parse_query($query); } $newQuery = array_merge(GuzzlePsr7\parse_query($uri->getQuery()), $query); return $request->withUri($uri->withQuery(http_build_query($newQuery, null, '&'))); }
private function fetchSourceMetadata() { if ($this->config['source_metadata'] instanceof ResultInterface) { return $this->config['source_metadata']; } list($bucket, $key) = explode('/', ltrim($this->source, '/'), 2); $headParams = ['Bucket' => $bucket, 'Key' => $key]; if (strpos($key, '?')) { list($key, $query) = explode('?', $key, 2); $headParams['Key'] = $key; $query = Psr7\parse_query($query, false); if (isset($query['versionId'])) { $headParams['VersionId'] = $query['versionId']; } } return $this->client->headObject($headParams); }
/** * Returns the parsed query string for the passed request as key-value array. * * @param RequestInterface $request * * @return array */ protected function getQueryAsArray(RequestInterface $request) { return Psr7\parse_query($request->getUri()->getQuery()); }
/** * @When I retrieve :type with id :id and the query string :query * * @param string $type * @param string $id * @param string $query * * @return void */ public function iRetrieveWithIdAndTheQueryString($type, $id, $query) { $this->getClient()->get($this->createUri($type, $id), parse_query($query, false)); }
/** * Helper method to generate an alternative form of an URL, where array indices have either * been added or removed. foo[] is transformed into foo[0], while foo[0] is transformed into foo[]. * * The result for URLs with both formats is undefined, or for URLs that intermingle their parameters, * i.e. t[]=foo&b[]=bar&t[]=baz * * This was introduced because of differences between the URLs generated by the different clients, and * because Facebook (at least) generates URLs were []s in URL arguments are expanded to [0] when * requested from the backend. Since we sign our URLs, this breaks the token generation and thus breaks * URLs when Facebook attempts to retrieve them. * * @param string $url The URL to generate the alternative form of * @param int $encoding The encoding to use - from GuzzleHttp\Psr7 * @return string */ protected function getAlternativeURL($url, $encoding = PHP_QUERY_RFC3986) { $urlParts = parse_url($url); if (!isset($urlParts['query'])) { return $url; } $queryString = $urlParts['query']; $fixKeyPattern = '#\\[[0-9]+\\]$#'; $parsed = Psr7\parse_query($queryString); $newArguments = array(); foreach ($parsed as $key => $value) { $fixedKey = preg_replace($fixKeyPattern, '', $key); // if the key came out different, we're talking about a t[x] format - so we store those // to allow for the correct sequence when regenerating the URL further below. if ($fixedKey != $key) { $fixedKey .= '[]'; if (!isset($newArguments[$fixedKey])) { $newArguments[$fixedKey] = array(); } $newArguments[$fixedKey][] = $value; } else { if (is_array($value) && substr($key, -2) == '[]') { // if the value is an array, and we have the [] format already, we expand the keys foreach ($value as $innerKey => $innerValue) { // remove [] from the key and append the inner array key $indexedKey = substr($key, 0, -2) . '[' . $innerKey . ']'; $newArguments[$indexedKey] = $innerValue; } } else { $newArguments[$key] = $value; } } } $urlParts['query'] = Psr7\build_query($newArguments, $encoding); $url = Urls::buildFromParseUrlParts($urlParts); return $url; }