Carteni / crypto-bundle

Command/AbstractCommand.php

Doc Comments +5 added lines, -5 removed lines

@@ -74,8 +74,8 @@ 
     }
 
     /**
-     * @param $question
-     * @param $default
+     * @param string $question
+     * @param string $default
      * @param string $sep
      *
      * @return string
@@ -90,7 +90,7 @@ 
 
     /**
      * @param \Symfony\Component\Console\Output\OutputInterface $output
-     * @param $text
+     * @param string $text
      * @param string $style
      */
     protected function writeSection(OutputInterface $output, $text, $style = 'bg=blue;fg=white')
@@ -109,8 +109,8 @@ 
     }
 
     /**
-     * @param $text
-     * @param $style
+     * @param string $text
+     * @param string $style
      *
      * @return string
      */

Indentation +1 added lines, -1 removed lines

@@ -99,7 +99,7 @@
          * @var FormatterHelper
          */
         $formatter = $this->getHelperSet()
-                          ->get('formatter');
+                            ->get('formatter');
 
         $output->writeln(array(
             '',

Model/Key.php

Indentation +1 added lines, -1 removed lines

@@ -92,7 +92,7 @@
 
         // rawKey is locked and become instance of \Defuse\Crypto\Key.
         $this->rawKey = $this->getRawKey()
-                             ->unlockKey($this->getSecret());
+                                ->unlockKey($this->getSecret());
 
         return $this;
     }

Command/SecretGeneratorCommand.php

Indentation +3 added lines, -3 removed lines

@@ -26,13 +26,13 @@
     protected function configure()
     {
         $this->setName('mes:crypto:generate-secret')
-             ->setDescription('Generates an authentication secret')
-             ->setHelp(<<<'EOF'
+                ->setDescription('Generates an authentication secret')
+                ->setHelp(<<<'EOF'
 The <info>%command.name%</info> generates an authentication secret.
 
 <info>%command.full_name%</info>
 EOF
-             );
+                );
     }
 
     /**

DependencyInjection/Configuration.php

Spacing +2 added lines, -2 removed lines

@@ -41,7 +41,7 @@ 
                 ->info('Encoded key or path to .crypto file. If key is null, it generates a different random key for each request.')
                 ->beforeNormalization()
                     ->ifString()
-                    ->then(function ($v) {
+                    ->then(function($v) {
                         if (is_file($v) && is_readable($v)) {
                             return array('path' => $v);
                         }
@@ -51,7 +51,7 @@ 
                 ->end()
                 ->validate()
                 ->ifArray()
-                    ->then(function ($v) {
+                    ->then(function($v) {
                         $path = $v['path'];
                         $key = $v['key'];
 

Indentation +2 added lines, -2 removed lines

@@ -29,7 +29,7 @@ 
         $rootNode = $treeBuilder->root('mes_crypto');
 
         $rootNode
-          ->children()
+            ->children()
             ->arrayNode('key')
                 ->addDefaultsIfNotSet()
                 ->children()
@@ -101,7 +101,7 @@ 
                 ->info('your_loader_service_id. Disabled by default. To enabled: loader: ~')
                 ->canBeEnabled()
             ->end()
-          ->end()
+            ->end()
         ;
 
         return $treeBuilder;

Tests/KeyStorage/KeyStorageTest.php

Indentation +1 added lines, -1 removed lines

@@ -34,7 +34,7 @@
         $this->keyStorage->setKey($key);
 
         $this->assertInstanceOf('Defuse\Crypto\KeyProtectedByPassword', $this->keyStorage->getKey()
-                                                                                         ->getRawKey());
+                                                                                            ->getRawKey());
         $this->assertSame($secret, $this->keyStorage->getKey()
                                                     ->getSecret());
     }

Encryption.php

Indentation +1 added lines, -1 removed lines

@@ -49,6 +49,6 @@
     private function unlockKey(Key $key)
     {
         return $key->unlock()
-                   ->getRawKey();
+                    ->getRawKey();
     }
 }

Doc Comments +1 added lines, -1 removed lines

@@ -158,7 +158,7 @@
     /**
      * @param Key|KeyInterface $key The KeyInterface instance to unlock used for Defuse encryption system
      *
-     * @return \Defuse\Crypto\Key|\Defuse\Crypto\KeyProtectedByPassword The Defuse key
+     * @return \Defuse\Crypto\Key The Defuse key
      */
     private function unlockKey(Key $key)
     {

Tests/EncryptionWrapperTest.php

Spacing +4 added lines, -4 removed lines

@@ -118,7 +118,7 @@ 
     {
         $this->encryption->expects($this->once())
                          ->method('encryptFileWithKey')
-                         ->will($this->returnCallback(function ($input, $output) {
+                         ->will($this->returnCallback(function($input, $output) {
                              $fs = new Filesystem();
                              $fs->dumpFile($output, '');
                          }));
@@ -137,7 +137,7 @@ 
     {
         $this->encryption->expects($this->once())
                          ->method('decryptFileWithKey')
-                         ->will($this->returnCallback(function ($input, $output) {
+                         ->will($this->returnCallback(function($input, $output) {
                              $fs = new Filesystem();
                              $fs->dumpFile($output, 'Plain text');
                          }));
@@ -244,7 +244,7 @@ 
     {
         $this->encryption->expects($this->once())
                          ->method('encryptFileWithPassword')
-                         ->will($this->returnCallback(function ($input, $output, $password) {
+                         ->will($this->returnCallback(function($input, $output, $password) {
                              $fs = new Filesystem();
                              $fs->dumpFile($output, '');
                          }));
@@ -276,7 +276,7 @@ 
     {
         $this->encryption->expects($this->once())
                          ->method('decryptFileWithPassword')
-                         ->will($this->returnCallback(function ($input, $output, $password) {
+                         ->will($this->returnCallback(function($input, $output, $password) {
                              $fs = new Filesystem();
                              $fs->dumpFile($output, 'Plain text');
                          }));

Indentation +63 added lines, -63 removed lines

@@ -36,7 +36,7 @@ 
     protected function setUp()
     {
         $this->encryption = $this->getMockBuilder('Mes\Security\CryptoBundle\EncryptionInterface')
-                                 ->getMock();
+                                    ->getMock();
         $this->wrapper = new EncryptionWrapper($this->encryption);
     }
 
@@ -59,13 +59,13 @@ 
     public function testEncryptWithKeyEncryptsPlaintext()
     {
         $this->encryption->expects($this->once())
-                         ->method('encryptWithKey')
-                         ->with('The quick brown fox jumps over the lazy dog', $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
+                            ->method('encryptWithKey')
+                            ->with('The quick brown fox jumps over the lazy dog', $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
                                                                                     ->getMock())
-                         ->will($this->returnValue('ThisIsACipherText'));
+                            ->will($this->returnValue('ThisIsACipherText'));
 
         $ciphertext = $this->wrapper->encryptWithKey('The quick brown fox jumps over the lazy dog', $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
-                                                                                                         ->getMock());
+                                                                                                            ->getMock());
 
         $this->assertTrue(ctype_print($ciphertext), 'is printable');
     }
@@ -77,16 +77,16 @@ 
     {
         try {
             $this->encryption->expects($this->once())
-                             ->method('encryptWithKey')
-                             ->with('The quick brown fox jumps over the lazy dog', $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
+                                ->method('encryptWithKey')
+                                ->with('The quick brown fox jumps over the lazy dog', $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
                                                                                         ->getMock())
-                             ->will($this->throwException(new EnvironmentIsBrokenException()));
+                                ->will($this->throwException(new EnvironmentIsBrokenException()));
         } catch (EnvironmentIsBrokenException $e) {
             $this->throwException(new CryptoException());
         }
 
         $this->wrapper->encryptWithKey('The quick brown fox jumps over the lazy dog', $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
-                                                                                           ->getMock());
+                                                                                            ->getMock());
     }
 
     /**
@@ -95,13 +95,13 @@ 
     public function testDecryptWithKeyDecryptsCiphertext()
     {
         $this->encryption->expects($this->once())
-                         ->method('decryptWithKey')
-                         ->with('ThisIsACipherText', $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
-                                                          ->getMock())
-                         ->will($this->returnValue('The quick brown fox jumps over the lazy dog'));
+                            ->method('decryptWithKey')
+                            ->with('ThisIsACipherText', $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
+                                                            ->getMock())
+                            ->will($this->returnValue('The quick brown fox jumps over the lazy dog'));
 
         $decryptedText = $this->wrapper->decryptWithKey('ThisIsACipherText', $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
-                                                                                  ->getMock());
+                                                                                    ->getMock());
 
         $this->assertSame('The quick brown fox jumps over the lazy dog', $decryptedText);
     }
@@ -113,16 +113,16 @@ 
     {
         try {
             $this->encryption->expects($this->once())
-                             ->method('decryptWithKey')
-                             ->with('ThisIsACipherText', $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
-                                                              ->getMock())
-                             ->will($this->throwException(new BaseCryptoException()));
+                                ->method('decryptWithKey')
+                                ->with('ThisIsACipherText', $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
+                                                                ->getMock())
+                                ->will($this->throwException(new BaseCryptoException()));
         } catch (BaseCryptoException $e) {
             $this->throwException(new CryptoException());
         }
 
         $this->wrapper->decryptWithKey('ThisIsACipherText', $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
-                                                                 ->getMock());
+                                                                    ->getMock());
     }
 
     /* =======================================
@@ -138,14 +138,14 @@ 
     public function testEncryptFileWithKeyEncryptsFile()
     {
         $this->encryption->expects($this->once())
-                         ->method('encryptFileWithKey')
-                         ->will($this->returnCallback(function ($input, $output) {
-                             $fs = new Filesystem();
-                             $fs->dumpFile($output, '');
-                         }));
+                            ->method('encryptFileWithKey')
+                            ->will($this->returnCallback(function ($input, $output) {
+                                $fs = new Filesystem();
+                                $fs->dumpFile($output, '');
+                            }));
 
         $this->wrapper->encryptFileWithKey(__DIR__.'/file.txt', __DIR__.'/file.crypto', $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
-                                                                                                 ->getMock());
+                                                                                                    ->getMock());
 
         $this->assertFileExists(__DIR__.'/file.crypto');
 
@@ -158,14 +158,14 @@ 
     public function testDecryptFileWithKeyDecryptsEncryptedFile()
     {
         $this->encryption->expects($this->once())
-                         ->method('decryptFileWithKey')
-                         ->will($this->returnCallback(function ($input, $output) {
-                             $fs = new Filesystem();
-                             $fs->dumpFile($output, 'Plain text');
-                         }));
+                            ->method('decryptFileWithKey')
+                            ->will($this->returnCallback(function ($input, $output) {
+                                $fs = new Filesystem();
+                                $fs->dumpFile($output, 'Plain text');
+                            }));
 
         $this->wrapper->decryptFileWithKey(__DIR__.'/file.crypto', __DIR__.'/file.txt', $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
-                                                                                                 ->getMock());
+                                                                                                    ->getMock());
 
         $this->assertFileExists(__DIR__.'/file.txt');
         $this->assertContains('Plain text', file_get_contents(__DIR__.'/file.txt'));
@@ -180,14 +180,14 @@ 
     {
         try {
             $this->encryption->expects($this->once())
-                             ->method('encryptFileWithKey')
-                             ->will($this->throwException(new BaseCryptoException()));
+                                ->method('encryptFileWithKey')
+                                ->will($this->throwException(new BaseCryptoException()));
         } catch (BaseCryptoException $e) {
             $this->throwException(new CryptoException());
         }
 
         $this->wrapper->encryptFileWithKey(__DIR__.'/file.txt', __DIR__.'/file.crypto', $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
-                                                                                                 ->getMock());
+                                                                                                    ->getMock());
     }
 
     /**
@@ -197,14 +197,14 @@ 
     {
         try {
             $this->encryption->expects($this->once())
-                             ->method('decryptFileWithKey')
-                             ->will($this->throwException(new BaseCryptoException()));
+                                ->method('decryptFileWithKey')
+                                ->will($this->throwException(new BaseCryptoException()));
         } catch (BaseCryptoException $e) {
             $this->throwException(new CryptoException());
         }
 
         $this->wrapper->decryptFileWithKey(__DIR__.'/file.crypto', __DIR__.'/file.txt', $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
-                                                                                                 ->getMock());
+                                                                                                    ->getMock());
     }
 
     /* ========================================
@@ -217,9 +217,9 @@ 
     public function testEncryptWithPasswordEncryptsPlaintext()
     {
         $this->encryption->expects($this->once())
-                         ->method('encryptWithPassword')
-                         ->with('The quick brown fox jumps over the lazy dog', 'SuperSecretPa$$word')
-                         ->will($this->returnValue('ThisIsACipherText'));
+                            ->method('encryptWithPassword')
+                            ->with('The quick brown fox jumps over the lazy dog', 'SuperSecretPa$$word')
+                            ->will($this->returnValue('ThisIsACipherText'));
 
         $ciphertext = $this->wrapper->encryptWithPassword('The quick brown fox jumps over the lazy dog', 'SuperSecretPa$$word');
 
@@ -233,9 +233,9 @@ 
     {
         try {
             $this->encryption->expects($this->once())
-                             ->method('encryptWithPassword')
-                             ->with('The quick brown fox jumps over the lazy dog', 'SuperSecretPa$$word')
-                             ->will($this->throwException(new EnvironmentIsBrokenException()));
+                                ->method('encryptWithPassword')
+                                ->with('The quick brown fox jumps over the lazy dog', 'SuperSecretPa$$word')
+                                ->will($this->throwException(new EnvironmentIsBrokenException()));
         } catch (EnvironmentIsBrokenException $e) {
             $this->throwException(new CryptoException());
         }
@@ -246,9 +246,9 @@ 
     public function testDecryptWithPasswordDecryptsCiphertext()
     {
         $this->encryption->expects($this->once())
-                         ->method('decryptWithPassword')
-                         ->with('ThisIsACipherText', 'SuperSecretPa$$word')
-                         ->will($this->returnValue('The quick brown fox jumps over the lazy dog'));
+                            ->method('decryptWithPassword')
+                            ->with('ThisIsACipherText', 'SuperSecretPa$$word')
+                            ->will($this->returnValue('The quick brown fox jumps over the lazy dog'));
 
         $decryptedText = $this->wrapper->decryptWithPassword('ThisIsACipherText', 'SuperSecretPa$$word');
 
@@ -262,9 +262,9 @@ 
     {
         try {
             $this->encryption->expects($this->once())
-                             ->method('decryptWithPassword')
-                             ->with('ThisIsACipherText', 'SuperSecretPa$$word')
-                             ->will($this->throwException(new WrongKeyOrModifiedCiphertextException()));
+                                ->method('decryptWithPassword')
+                                ->with('ThisIsACipherText', 'SuperSecretPa$$word')
+                                ->will($this->throwException(new WrongKeyOrModifiedCiphertextException()));
         } catch (BaseCryptoException $e) {
             $this->throwException(new CryptoException());
         }
@@ -282,11 +282,11 @@ 
     public function testEncryptFileWithPasswordEncryptsFile()
     {
         $this->encryption->expects($this->once())
-                         ->method('encryptFileWithPassword')
-                         ->will($this->returnCallback(function ($input, $output, $password) {
-                             $fs = new Filesystem();
-                             $fs->dumpFile($output, '');
-                         }));
+                            ->method('encryptFileWithPassword')
+                            ->will($this->returnCallback(function ($input, $output, $password) {
+                                $fs = new Filesystem();
+                                $fs->dumpFile($output, '');
+                            }));
 
         $this->wrapper->encryptFileWithPassword(__DIR__.'/file.txt', __DIR__.'/file.crypto', 'SuperSecretPa$$word');
 
@@ -302,8 +302,8 @@ 
     {
         try {
             $this->encryption->expects($this->once())
-                             ->method('encryptFileWithPassword')
-                             ->will($this->throwException(new EnvironmentIsBrokenException()));
+                                ->method('encryptFileWithPassword')
+                                ->will($this->throwException(new EnvironmentIsBrokenException()));
         } catch (EnvironmentIsBrokenException $e) {
             $this->throwException(new CryptoException());
         }
@@ -314,11 +314,11 @@ 
     public function testDecryptFileWithPasswordDecryptsEncryptedFile()
     {
         $this->encryption->expects($this->once())
-                         ->method('decryptFileWithPassword')
-                         ->will($this->returnCallback(function ($input, $output, $password) {
-                             $fs = new Filesystem();
-                             $fs->dumpFile($output, 'Plain text');
-                         }));
+                            ->method('decryptFileWithPassword')
+                            ->will($this->returnCallback(function ($input, $output, $password) {
+                                $fs = new Filesystem();
+                                $fs->dumpFile($output, 'Plain text');
+                            }));
 
         $this->wrapper->decryptFileWithPassword(__DIR__.'/file.crypto', __DIR__.'/file.txt', 'SuperSecretPa$$word');
 
@@ -335,8 +335,8 @@ 
     {
         try {
             $this->encryption->expects($this->once())
-                             ->method('decryptFileWithPassword')
-                             ->will($this->throwException(new WrongKeyOrModifiedCiphertextException()));
+                                ->method('decryptFileWithPassword')
+                                ->will($this->throwException(new WrongKeyOrModifiedCiphertextException()));
         } catch (BaseCryptoException $e) {
             $this->throwException(new CryptoException());
         }

Tests/bootstrap.php

Spacing +1 added lines, -1 removed lines

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-register_shutdown_function(function () {
+register_shutdown_function(function() {
     if (file_exists(__DIR__.'/key.crypto')) {
         unlink(__DIR__.'/key.crypto');
     }

Tests/EncryptionResourceWrapperTest.php

Indentation +13 added lines, -13 removed lines

@@ -33,7 +33,7 @@ 
     protected function setUp()
     {
         $this->encryption = $this->getMockBuilder('Mes\Security\CryptoBundle\EncryptionInterface')
-                                 ->getMock();
+                                    ->getMock();
         $this->wrapper = new EncryptionWrapper($this->encryption);
     }
 
@@ -56,7 +56,7 @@ 
     public function testEncryptResourceWithKeyEncryptsHandle()
     {
         $this->encryption->expects($this->once())
-                         ->method('encryptResourceWithKey');
+                            ->method('encryptResourceWithKey');
 
         $this->wrapper->encryptResourceWithKey(fopen('php://stdin', 'r'), fopen('php://memory', 'wb'), $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
                                                                                                             ->getMock());
@@ -68,7 +68,7 @@ 
     public function testDecryptResourceWithKeyDecryptsEncryptedHandle()
     {
         $this->encryption->expects($this->once())
-                         ->method('decryptResourceWithKey');
+                            ->method('decryptResourceWithKey');
 
         $this->wrapper->decryptResourceWithKey(fopen('php://stdin', 'r'), fopen('php://memory', 'wb'), $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
                                                                                                             ->getMock());
@@ -81,8 +81,8 @@ 
     {
         try {
             $this->encryption->expects($this->once())
-                             ->method('encryptResourceWithKey')
-                             ->will($this->throwException(new BaseCryptoException()));
+                                ->method('encryptResourceWithKey')
+                                ->will($this->throwException(new BaseCryptoException()));
         } catch (BaseCryptoException $e) {
             $this->throwException(new CryptoException());
         }
@@ -98,8 +98,8 @@ 
     {
         try {
             $this->encryption->expects($this->once())
-                             ->method('decryptResourceWithKey')
-                             ->will($this->throwException(new BaseCryptoException()));
+                                ->method('decryptResourceWithKey')
+                                ->will($this->throwException(new BaseCryptoException()));
         } catch (BaseCryptoException $e) {
             $this->throwException(new CryptoException());
         }
@@ -121,7 +121,7 @@ 
     public function testEncryptResourceWithPasswordEncryptsHandle()
     {
         $this->encryption->expects($this->once())
-                         ->method('encryptResourceWithPassword');
+                            ->method('encryptResourceWithPassword');
 
         $this->wrapper->encryptResourceWithPassword(fopen('php://stdin', 'r'), fopen('php://memory', 'wb'), 'SecretPa$$word');
     }
@@ -132,7 +132,7 @@ 
     public function testDecryptResourceWithPasswordDecryptsEncryptedHandle()
     {
         $this->encryption->expects($this->once())
-                         ->method('decryptResourceWithPassword');
+                            ->method('decryptResourceWithPassword');
 
         $this->wrapper->decryptResourceWithPassword(fopen('php://stdin', 'r'), fopen('php://memory', 'wb'), 'SecretPa$$word');
     }
@@ -144,8 +144,8 @@ 
     {
         try {
             $this->encryption->expects($this->once())
-                             ->method('encryptResourceWithPassword')
-                             ->will($this->throwException(new BaseCryptoException()));
+                                ->method('encryptResourceWithPassword')
+                                ->will($this->throwException(new BaseCryptoException()));
         } catch (BaseCryptoException $e) {
             $this->throwException(new CryptoException());
         }
@@ -160,8 +160,8 @@ 
     {
         try {
             $this->encryption->expects($this->once())
-                             ->method('decryptResourceWithPassword')
-                             ->will($this->throwException(new BaseCryptoException()));
+                                ->method('decryptResourceWithPassword')
+                                ->will($this->throwException(new BaseCryptoException()));
         } catch (BaseCryptoException $e) {
             $this->throwException(new CryptoException());
         }