pax_global_header00006660000000000000000000000064124165647230014524gustar00rootroot0000000000000052 comment=c9f8ceddac1a6ccf2d010c4010605d5fb01e2e69 message-integrity-subscriber-0.2.0/000077500000000000000000000000001241656472300173245ustar00rootroot00000000000000message-integrity-subscriber-0.2.0/.gitignore000066400000000000000000000000731241656472300213140ustar00rootroot00000000000000.idea .DS_STORE coverage phpunit.xml composer.lock vendor/ message-integrity-subscriber-0.2.0/.travis.yml000066400000000000000000000002661241656472300214410ustar00rootroot00000000000000language: php php: - 5.4 - 5.5 - 5.6 - hhvm before_script: - composer self-update - composer install --no-interaction --prefer-source --dev script: vendor/bin/phpunit message-integrity-subscriber-0.2.0/LICENSE000066400000000000000000000021271241656472300203330ustar00rootroot00000000000000Copyright (c) 2014 Michael Dowling, https://github.com/mtdowling Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. message-integrity-subscriber-0.2.0/Makefile000066400000000000000000000003651241656472300207700ustar00rootroot00000000000000all: clean coverage test: vendor/bin/phpunit $(TEST) coverage: vendor/bin/phpunit --coverage-html=build/artifacts/coverage $(TEST) view-coverage: open build/artifacts/coverage/index.html clean: rm -rf build/artifacts/* .PHONY: coverage message-integrity-subscriber-0.2.0/README.rst000066400000000000000000000062761241656472300210260ustar00rootroot00000000000000=================================== Guzzle Message Integrity Subscriber =================================== Verifies the integrity of HTTP responses using customizable validators. This plugin can be used, for example, to validate the message integrity of responses based on the ``Content-MD5`` header. The plugin offers a convenience method for validating a ``Content-MD5`` header. .. code-block:: php use GuzzleHttp\Client(); use GuzzleHttp\Subscriber\MessageIntegrity\ResponseIntegrity; $subscriber = ResponseIntegrity::createForContentMd5(); $client = new Client(); $client->getEmitter()->attach($subscriber); Installing ---------- This project can be installed using Composer. Add the following to your composer.json: .. code-block:: javascript { "require": { "guzzlehttp/message-integrity-subscriber": "0.2.*" } } Constructor Options ------------------- The ``GuzzleHttp\Subscriber\MessageIntegrity\ResponseIntegrity`` class accepts an associative array of options: expected (callable) A function that returns the hash that is expected for a response. The function accepts a ResponseInterface objects and returns a string that is compared against the calculated rolling hash. hash (``GuzzleHttp\Subscriber\MessageIntegrity\HashInterface``) A hash object used to compute a hash of the response body. The result created by the has is then compared against the extracted header value. size_cutoff (integer) If specified, the message integrity will only be validated if the response size is less than the ``size_cutoff`` value (in bytes). .. code-block:: php use GuzzleHttp\Client(); use GuzzleHttp\Message\ResponseInterface; use GuzzleHttp\Subscriber\MessageIntegrity\ResponseIntegrity; $subscriber = new ResponseIntegrity([ 'hash' => new PhpHash('md5', ['base64' => true]) 'expected' => function (ResponseInterface $response) { return $response->getHeader('Content-MD5'); } ]); $client = new Client(); $client->getEmitter()->attach($subscriber); Handling Errors --------------- If the calculated hash of the response body does not match the extracted response's header, then a ``GuzzleHttp\Subscriber\MessageIntegrity\MessageIntegrityException`` is thrown. This exception extends from ``GuzzleHttp\Exception\RequestException`` so it contains a request accessed via ``getRequest()`` and a response via ``getResponse()``. .. code-block:: php use GuzzleHttp\Client(); use GuzzleHttp\Subscriber\MessageIntegrity\ResponseIntegrity; use GuzzleHttp\Subscriber\MessageIntegrity\MessageIntegrityException; $subscriber = ResponseIntegrity::createForContentMd5(); $client = new Client(); $client->getEmitter()->attach($subscriber); try { $client->get('http://httpbin.org/get'); } catch (MessageIntegrityException $e) { echo $e->getRequest() . "\n"; echo $e->getResponse() . "\n"; } Limitations ----------- - Only works with seekable responses or streaming responses. - Does not currently work with responses that use a ``Transfer-Encoding`` header. - Does not currently work with responses that use a ``Content-Encoding`` header. message-integrity-subscriber-0.2.0/composer.json000066400000000000000000000014261241656472300220510ustar00rootroot00000000000000{ "name": "guzzlehttp/message-integrity-subscriber", "description": "Verifies the integrity of HTTP responses using customizable validators (Guzzle 4+)", "homepage": "http://guzzlephp.org/", "keywords": ["http", "guzzle"], "license": "MIT", "authors": [ { "name": "Michael Dowling", "email": "mtdowling@gmail.com", "homepage": "https://github.com/mtdowling" } ], "require": { "php": ">=5.4.0", "guzzlehttp/guzzle": "~4.0|~5.0" }, "require-dev": { "phpunit/phpunit": "~4.0" }, "autoload": { "psr-4": { "GuzzleHttp\\Subscriber\\MessageIntegrity\\": "src/" } }, "extra": { "branch-alias": { "dev-master": "0.2-dev" } } } message-integrity-subscriber-0.2.0/phpunit.xml.dist000066400000000000000000000005431241656472300225010ustar00rootroot00000000000000 tests src message-integrity-subscriber-0.2.0/src/000077500000000000000000000000001241656472300201135ustar00rootroot00000000000000message-integrity-subscriber-0.2.0/src/CompleteResponse.php000066400000000000000000000053521241656472300241200ustar00rootroot00000000000000expectedFn = $config['expected']; $this->hash = $config['hash']; $this->sizeCutoff = isset($config['size_cutoff']) ? $config['size_cutoff'] : null; } public function getEvents() { // Fire at the same level of normal response verification. return ['complete' => ['onComplete', RequestEvents::VERIFY_RESPONSE]]; } public function onComplete(CompleteEvent $event) { $response = $event->getResponse(); $expected = call_user_func($this->expectedFn, $response); if ($expected !== null && $this->canValidate($response)) { $this->matchesHash($event, $expected, $response->getBody()); } } private function canValidate(ResponseInterface $response) { if (!($body = $response->getBody())) { return false; } elseif ($response->hasHeader('Transfer-Encoding') || $response->hasHeader('Content-Encoding') ) { // Currently does not support un-gzipping or inflating responses return false; } elseif (!$body->isSeekable()) { return false; } elseif ($this->sizeCutoff !== null && $body->getSize() > $this->sizeCutoff ) { return false; } return true; } private function matchesHash( CompleteEvent $event, $hash, StreamInterface $body ) { $body->seek(0); while (!$body->eof()) { $this->hash->update($body->read(16384)); } $result = $this->hash->complete(); if ($hash !== $result) { throw new MessageIntegrityException( sprintf('Message integrity check failure. Expected "%s" but' . ' got "%s"', $hash, $result), $event->getRequest(), $event->getResponse() ); } } } message-integrity-subscriber-0.2.0/src/HashInterface.php000066400000000000000000000010661241656472300233330ustar00rootroot00000000000000stream = $stream; $this->hash = $hash; $this->callback = $onComplete; } public function read($length) { $data = $this->stream->read($length); $this->hash->update($data); if ($this->eof()) { $result = $this->hash->complete(); if ($this->callback) { call_user_func($this->callback, $result); } } return $data; } public function seek($offset, $whence = SEEK_SET) { if ($offset === 0) { $this->hash->reset(); return $this->stream->seek($offset); } else { // Seeking arbitrarily is not supported. return false; } } } message-integrity-subscriber-0.2.0/src/MessageIntegrityException.php000066400000000000000000000002411241656472300257630ustar00rootroot00000000000000algo = $algo; $this->options = $options; } public function update($data) { if ($this->hash !== null) { $this->reset(); } hash_update($this->getContext(), $data); } public function complete() { if ($this->hash) { return $this->hash; } $this->hash = hash_final($this->getContext(), true); if (isset($this->options['base64']) && $this->options['base64']) { $this->hash = base64_encode($this->hash); } return $this->hash; } public function reset() { $this->context = $this->hash = null; } /** * Get a hash context or create one if needed * * @return resource */ private function getContext() { if (!$this->context) { $key = isset($this->options['key']) ? $this->options['key'] : null; $this->context = hash_init( $this->algo, $key ? HASH_HMAC : 0, $key ); } return $this->context; } } message-integrity-subscriber-0.2.0/src/ReadIntegrityStream.php000066400000000000000000000032241241656472300245530ustar00rootroot00000000000000mismatchCallback = $onMismatch; $this->expected = $expected; parent::__construct($stream, $hash, function ($result) { if ($this->expected !== $result) { $this->mismatch($result); } }); } private function mismatch($result) { if ($this->mismatchCallback) { call_user_func($this->mismatchCallback, $result, $this->expected); } throw new \UnexpectedValueException( sprintf('Message integrity check failure. Expected %s ' . 'but got %s', $this->expected, $result) ); } } message-integrity-subscriber-0.2.0/src/ResponseIntegrity.php000066400000000000000000000056261241656472300243320ustar00rootroot00000000000000 new PhpHash('md5', ['base64' => true]), 'expected' => function (ResponseInterface $response) { return $response->getHeader('Content-MD5'); } ]); } /** * Validates the options provided to an integrity plugin. * * @param array $config Associative array of configuration options. * @throws \InvalidArgumentException */ public static function validateOptions(array $config) { if (!isset($config['expected'])) { throw new \InvalidArgumentException('expected is required'); } if (!is_callable($config['expected'])) { throw new \InvalidArgumentException('expected must be callable'); } if (!isset($config['hash'])) { throw new \InvalidArgumentException('hash is required'); } if (!($config['hash']) instanceof HashInterface) { throw new \InvalidArgumentException('hash must be an instance of ' . __NAMESPACE__ . '\\HashInterface'); } } /** * @param array $config Associative array of configuration options. * - expected: (callable) A function that returns the hash that is * expected for a response. The function accepts a ResponseInterface * objects and returns a string that is compared against the * calculated rolling hash. * - hash: (HashInterface) used to validate the header value * - size_cutoff: (int) Don't validate when size is greater than this * number. * @throws \InvalidArgumentException */ public function __construct(array $config) { $this->full = new CompleteResponse($config); $this->streaming = new StreamResponse($config); } public function getEvents() { return ['before' => ['onBefore']]; } public function onBefore(BeforeEvent $event) { $request = $event->getRequest(); $config = $request->getConfig(); // So that we do not attach subscribers multiple times. if (isset($config['applied_message_integrity'])) { return; } $config['applied_message_integrity'] = true; $request->getEmitter()->attach( $config['stream'] ? $this->streaming : $this->full ); } } message-integrity-subscriber-0.2.0/src/StreamResponse.php000066400000000000000000000042341241656472300236010ustar00rootroot00000000000000expectedFn = $config['expected']; $this->hash = $config['hash']; } public function getEvents() { // Fire this event near the end of the event chain. return ['complete' => ['onComplete', RequestEvents::LATE]]; } public function onComplete(CompleteEvent $event) { $response = $event->getResponse(); if (!($expected = $this->getExpected($response))) { return; } $request = $event->getRequest(); $response->setBody(new ReadIntegrityStream( $response->getBody(), $this->hash, $expected, function ($result, $expected) use ($request, $response) { throw new MessageIntegrityException( sprintf('Message integrity check failure. Expected ' . '"%s" but got "%s"', $expected, $result), $request, $response ); } )); } private function getExpected(ResponseInterface $response) { if (!($body = $response->getBody())) { return false; } elseif ($response->hasHeader('Transfer-Encoding') || $response->hasHeader('Content-Encoding') ) { // Currently does not support un-gzipping or inflating responses return false; } return call_user_func($this->expectedFn, $response); } } message-integrity-subscriber-0.2.0/tests/000077500000000000000000000000001241656472300204665ustar00rootroot00000000000000message-integrity-subscriber-0.2.0/tests/CompleteResponseTest.php000066400000000000000000000023471241656472300253340ustar00rootroot00000000000000 new PhpHash('md5', ['base64' => true]), 'expected' => function (ResponseInterface $response) { return $response->getHeader('Content-MD5'); } ]); $client = new Client(); $client->getEmitter()->attach($sub); $client->getEmitter()->attach(new Mock([ new Response(200, ['Content-MD5' => 'fud'], Stream::factory('foo')) ])); $request = $client->createRequest('GET', 'http://httpbin.org'); $client->send($request); } } message-integrity-subscriber-0.2.0/tests/HashingStreamTest.php000066400000000000000000000026321241656472300245770ustar00rootroot00000000000000getContents(); $this->assertEquals(md5('foobar'), bin2hex($hash->complete())); } public function testCallbackTriggeredWhenComplete() { $source = Stream::factory('foobar'); $hash = new PhpHash('md5'); $called = false; $stream = new HashingStream($source, $hash, function () use (&$called) { $called = true; }); $stream->getContents(); $this->assertTrue($called); } public function testCanOnlySeekToTheBeginning() { $source = Stream::factory('foobar'); $hash = new PhpHash('md5'); $stream = new HashingStream($source, $hash); // Reading works fine $bytes = $stream->read(3); $this->assertEquals('foo', $bytes); // Seeking to 0 is fine $stream->seek(0); $stream->getContents(); $this->assertEquals(md5('foobar'), bin2hex($hash->complete())); // Seeking arbitrarily is not fine $stream->seek(3); } } message-integrity-subscriber-0.2.0/tests/PhpHashTest.php000066400000000000000000000024631241656472300233770ustar00rootroot00000000000000update('foo'); $hash->update('bar'); $result = $hash->complete(); $this->assertEquals(md5('foobar', true), $result); } public function testHashesDataAndBase64Encodes() { $hash = new PhpHash('md5', ['base64' => true]); $hash->update('foo'); $hash->update('bar'); $result = $hash->complete(); $this->assertEquals(base64_encode(md5('foobar', true)), $result); } public function testCreatesNewHash() { $hash = new PhpHash('md5', ['base64' => true]); $hash->update('foo'); $hash->complete(); $hash->update('foo'); $hash->update('bar'); $result = $hash->complete(); $this->assertEquals(base64_encode(md5('foobar', true)), $result); $this->assertSame($result, $hash->complete()); } public function testCanResetHash() { $hash = new PhpHash('md5'); $hash->update('foo'); $hash->reset(); $hash->update('bar'); $this->assertEquals(md5('bar'), bin2hex($hash->complete())); } } message-integrity-subscriber-0.2.0/tests/ReadIntegrityStreamTest.php000066400000000000000000000033371241656472300257730ustar00rootroot00000000000000getContents(); } /** * @expectedException \UnderflowException */ public function testValidatesRollingMd5WithCallback() { $real = Stream::factory('foobar'); $hash = new PhpHash('md5', ['base64' => true]); $stream = new ReadIntegrityStream($real, $hash, 'foo', function ($a, $b) { $this->assertEquals(base64_encode(md5('foobar', true)), $a); $this->assertEquals('foo', $b); throw new \UnderflowException('test'); }); $stream->getContents(); } /** * @expectedException \UnexpectedValueException */ public function testValidatesRollingMd5WithCallbackThatDoesNotThrow() { $real = Stream::factory('foobar'); $hash = new PhpHash('md5'); $stream = new ReadIntegrityStream($real, $hash, 'foo', function () {}); $stream->getContents(); } public function testValidatesSuccessfully() { $real = Stream::factory('foobar'); $hash = new PhpHash('md5', ['base64' => true]); $expected = base64_encode(md5('foobar', true)); $stream = new ReadIntegrityStream($real, $hash, $expected); $stream->getContents(); } } message-integrity-subscriber-0.2.0/tests/ResponseIntegrityTest.php000066400000000000000000000057301241656472300255410ustar00rootroot00000000000000 'foo']], [['expected' => function() {}]], [['expected' => function() {}, 'hash' => 'foo']] ]; } /** * @dataProvider configProvider * @expectedException \InvalidArgumentException */ public function testValidatesConfig($config) { ResponseIntegrity::validateOptions($config); } public function testAddsFullResponse() { $sub = ResponseIntegrity::createForContentMd5(); $md5Test = base64_encode(md5('foo', true)); $client = new Client(); $client->getEmitter()->attach($sub); $client->getEmitter()->attach(new Mock([ new Response(200, ['Content-MD5' => $md5Test], Stream::factory('foo')) ])); $request = $client->createRequest('GET', 'http://httpbin.org'); $client->send($request); $ins = array_map(function ($rec) { return get_class($rec[0]); }, $request->getEmitter()->listeners('complete')); $this->assertContains( 'GuzzleHttp\\Subscriber\\MessageIntegrity\\CompleteResponse', $ins ); } public function testAddsStreaming() { $sub = ResponseIntegrity::createForContentMd5(); $md5Test = base64_encode(md5('foo', true)); $client = new Client(); $client->getEmitter()->attach($sub); $client->getEmitter()->attach(new Mock([ new Response(200, ['Content-MD5' => $md5Test], Stream::factory('foo')) ])); $request = $client->createRequest( 'GET', 'http://httpbin.org', ['stream' => true] ); $response = $client->send($request); $this->assertInstanceOf( 'GuzzleHttp\Subscriber\MessageIntegrity\ReadIntegrityStream', $response->getBody() ); $response->getBody()->getContents(); } public function testAddsOnlyOncePerRequest() { $sub = ResponseIntegrity::createForContentMd5(); $client = new Client(); $client->getEmitter()->attach($sub); $client->getEmitter()->attach(new Mock([ new Response(200), new Response(200) ])); $request = $client->createRequest('GET', 'http://httpbin.org'); $client->send($request); $client->send($request); $ins = array_filter( $request->getEmitter()->listeners('complete'), function ($rec) { return get_class($rec[0]) === 'GuzzleHttp\\Subscriber\\MessageIntegrity\\CompleteResponse'; } ); $this->assertCount(1, $ins); } } message-integrity-subscriber-0.2.0/tests/StreamResponseTest.php000066400000000000000000000024321241656472300250120ustar00rootroot00000000000000 new PhpHash('md5', ['base64' => true]), 'expected' => function (ResponseInterface $response) { return $response->getHeader('Content-MD5'); } ]); $client = new Client(); $client->getEmitter()->attach($sub); $client->getEmitter()->attach(new Mock([ new Response(200, ['Content-MD5' => 'fud'], Stream::factory('foo')) ])); $request = $client->createRequest('GET', 'http://httpbin.org'); $response = $client->send($request); $response->getBody()->getContents(); } }