teqneers / shamir

src/Console/ShareCommand.php

Spacing +2 added lines, -2 removed lines

@@ -61,7 +61,7 @@ 
                 '<question>Number of shared secrets to create</question> <comment>[3]</comment>: ', 3
             );
             $question->setValidator(
-                function ($a) {
+                function($a) {
                     if (!is_int($a) && !ctype_digit($a)) {
                         throw new \Exception('The number of shared secrets must be an integer');
                     }
@@ -75,7 +75,7 @@ 
                 '<question>Number of shared secrets required</question> <comment>[2]</comment>: ', 2
             );
             $question->setValidator(
-                function ($a) {
+                function($a) {
                     if (!is_int($a) && !ctype_digit($a)) {
                         throw new \Exception('The number of shared secrets required must be an integer');
                     }

src/Algorithm/Shamir.php

Spacing +135 added lines, -135 removed lines

@@ -80,7 +80,7 @@ 
 	 */
 	public function getRandomGenerator() {
 
-		if( !$this->randomGenerator ) {
+		if (!$this->randomGenerator) {
 			$this->randomGenerator = new PhpGenerator();
 		}
 
@@ -92,7 +92,7 @@ 
 	 * @inheritdoc
 	 * @return  Shamir
 	 */
-	public function setRandomGenerator( Generator $generator ) {
+	public function setRandomGenerator(Generator $generator) {
 
 		$this->randomGenerator = $generator;
 
@@ -123,13 +123,13 @@ 
 	 * @return  Shamir
 	 * @throws  \OutOfRangeException
 	 */
-	public function setChunkSize( $chunkSize ) {
+	public function setChunkSize($chunkSize) {
 
 		$chunkSize = (int)$chunkSize;
-		$primeNumber = array( 1 => 257, 65537, 16777259, 4294967311, 1099511627791, 281474976710677, 72057594037928017 );
+		$primeNumber = array(1 => 257, 65537, 16777259, 4294967311, 1099511627791, 281474976710677, 72057594037928017);
 
-		if( $chunkSize > 7 ) {
-			throw new \OutOfRangeException( 'Chunk sizes with that many bytes are not implemented yet.' );
+		if ($chunkSize > 7) {
+			throw new \OutOfRangeException('Chunk sizes with that many bytes are not implemented yet.');
 		}
 
 		$this->chunkSize = $chunkSize;
@@ -154,7 +154,7 @@ 
 	 * @return  Shamir
 	 * @throws  \OutOfRangeException
 	 */
-	protected function setMaxShares( $max ) {
+	protected function setMaxShares($max) {
 
 		// the prime number has to be larger, than the maximum number
 		// representable by the number of bytes. so we always need one
@@ -165,25 +165,25 @@ 
 		// max possible number of shares is the maximum number of bytes
 		// possible to be represented with max integer, but we always need
 		// to save one byte for encryption.
-		$maxPossible = 1 << ( PHP_INT_SIZE - 1 ) * 8;
+		$maxPossible = 1 << (PHP_INT_SIZE - 1) * 8;
 
-		if( $max > $maxPossible ) {
+		if ($max > $maxPossible) {
 			// we are unable to provide more bytes-1 as supported by OS
 			// because the prime number need to be higher than that, but
 			// this would exceed OS int range.
 			throw new \OutOfRangeException(
-				'Number of required keys has to be below ' . number_format( $maxPossible ) . '.'
+				'Number of required keys has to be below '.number_format($maxPossible).'.'
 			);
 		}
 
 		// calculate how many bytes we need to represent number of shares.
 		// e.g. everything less than 256 needs only a single byte.
-		$chunkSize = (int)ceil( log( $max, 2 ) / 8 );
+		$chunkSize = (int)ceil(log($max, 2) / 8);
 		// if chunk size has been set already, we will only increase it, if necessary
-		$chunkSize = max( $chunkSize, $this->chunkSize );
+		$chunkSize = max($chunkSize, $this->chunkSize);
 
-		if( $chunkSize > $this->chunkSize ) {
-			$this->setChunkSize( $chunkSize );
+		if ($chunkSize > $this->chunkSize) {
+			$this->setChunkSize($chunkSize);
 		}
 
 		$this->maxShares = $max;
@@ -198,11 +198,11 @@ 
 	 * @param   integer     Number
 	 * @return  integer     Module of number
 	 */
-	protected function modulo( $number ) {
+	protected function modulo($number) {
 
-		$modulo = bcmod( $number, $this->prime );
+		$modulo = bcmod($number, $this->prime);
 
-		return ( $modulo < 0 ) ? bcadd( $modulo, $this->prime ) : $modulo;
+		return ($modulo < 0) ? bcadd($modulo, $this->prime) : $modulo;
 	}
 
 
@@ -213,15 +213,15 @@ 
 	 * @param int $b
 	 * @return array
 	 */
-	protected function gcdD( $a, $b ) {
+	protected function gcdD($a, $b) {
 
-		if( $b == 0 ) {
-			return array( $a, 1, 0 );
+		if ($b == 0) {
+			return array($a, 1, 0);
 		} else {
-			$div = floor( bcdiv( $a, $b ) );
-			$mod = bcmod( $a, $b );
-			$decomp = $this->gcdD( $b, $mod );
-			return array( $decomp[0], $decomp[2], $decomp[1] - $decomp[2] * $div );
+			$div = floor(bcdiv($a, $b));
+			$mod = bcmod($a, $b);
+			$decomp = $this->gcdD($b, $mod);
+			return array($decomp[0], $decomp[2], $decomp[1] - $decomp[2] * $div);
 		}
 	}
 
@@ -232,13 +232,13 @@ 
 	 * @param int $number
 	 * @return int
 	 */
-	protected function inverseModulo( $number ) {
+	protected function inverseModulo($number) {
 
-		$number = bcmod( $number, $this->prime );
-		$r = $this->gcdD( $this->prime, abs( $number ) );
-		$r = ( $number < 0 ) ? -$r[2] : $r[2];
+		$number = bcmod($number, $this->prime);
+		$r = $this->gcdD($this->prime, abs($number));
+		$r = ($number < 0) ? -$r[2] : $r[2];
 
-		return bcmod( bcadd( $this->prime, $r ), $this->prime );
+		return bcmod(bcadd($this->prime, $r), $this->prime);
 	}
 
 
@@ -250,23 +250,23 @@ 
 	 * @return  array
 	 * @throws  \RuntimeException
 	 */
-	protected function reverseCoefficients( array $keyX, $threshold ) {
+	protected function reverseCoefficients(array $keyX, $threshold) {
 
 		$coefficients = array();
 
-		for( $i = 0; $i < $threshold; $i++ ) {
+		for ($i = 0; $i < $threshold; $i++) {
 			$temp = 1;
-			for( $j = 0; $j < $threshold; $j++ ) {
-				if( $i != $j ) {
+			for ($j = 0; $j < $threshold; $j++) {
+				if ($i != $j) {
 					$temp = $this->modulo(
-								 bcmul( bcmul( -$temp, $keyX[$j] ), $this->inverseModulo( $keyX[$i] - $keyX[$j] ) )
+								 bcmul(bcmul( -$temp, $keyX[$j] ), $this->inverseModulo($keyX[$i] - $keyX[$j]))
 					);
 				}
 			}
 
-			if( $temp == 0 ) {
+			if ($temp == 0) {
 				/* Repeated share */
-				throw new \RuntimeException( 'Repeated share detected - cannot compute reverse-coefficients' );
+				throw new \RuntimeException('Repeated share detected - cannot compute reverse-coefficients');
 			}
 
 			$coefficients[] = $temp;
@@ -282,15 +282,15 @@ 
 	 * @param   integer $threshold Number of coefficients needed
 	 * @return  array
 	 */
-	protected function generateCoefficients( $threshold ) {
+	protected function generateCoefficients($threshold) {
 
 		$coefficients = array();
-		for( $i = 0; $i < $threshold - 1; $i++ ) {
+		for ($i = 0; $i < $threshold - 1; $i++) {
 			do {
 				// the random number has to be positive integer != 0
-				$random = abs( $this->getRandomGenerator()->getRandomInt() );
-			} while($random < 1);
-			$coefficients[] = $this->modulo( $random );
+				$random = abs($this->getRandomGenerator()->getRandomInt());
+			} while ($random < 1);
+			$coefficients[] = $this->modulo($random);
 		}
 
 		return $coefficients;
@@ -310,11 +310,11 @@ 
 	 * @param   array   $coefficients Polynomial coefficients
 	 * @return  integer                     Y coordinate
 	 */
-	protected function hornerMethod( $xCoordinate, array $coefficients ) {
+	protected function hornerMethod($xCoordinate, array $coefficients) {
 
 		$yCoordinate = 0;
-		foreach( $coefficients as $coefficient ) {
-			$yCoordinate = $this->modulo( $xCoordinate * $yCoordinate + $coefficient );
+		foreach ($coefficients as $coefficient) {
+			$yCoordinate = $this->modulo($xCoordinate * $yCoordinate + $coefficient);
 		}
 
 		return $yCoordinate;
@@ -329,40 +329,40 @@ 
 	 * @param   string $toBaseInput
 	 * @return  string
 	 */
-	protected static function convBase( $numberInput, $fromBaseInput, $toBaseInput ) {
+	protected static function convBase($numberInput, $fromBaseInput, $toBaseInput) {
 
-		if( $fromBaseInput == $toBaseInput ) {
+		if ($fromBaseInput == $toBaseInput) {
 			return $numberInput;
 		}
-		$fromBase = str_split( $fromBaseInput, 1 );
-		$toBase = str_split( $toBaseInput, 1 );
-		$number = str_split( $numberInput, 1 );
-		$fromLen = strlen( $fromBaseInput );
-		$toLen = strlen( $toBaseInput );
-		$numberLen = strlen( $numberInput );
+		$fromBase = str_split($fromBaseInput, 1);
+		$toBase = str_split($toBaseInput, 1);
+		$number = str_split($numberInput, 1);
+		$fromLen = strlen($fromBaseInput);
+		$toLen = strlen($toBaseInput);
+		$numberLen = strlen($numberInput);
 		$retVal = '';
-		if( $toBaseInput == '0123456789' ) {
+		if ($toBaseInput == '0123456789') {
 			$retVal = 0;
-			for( $i = 1; $i <= $numberLen; $i++ ) {
+			for ($i = 1; $i <= $numberLen; $i++) {
 				$retVal = bcadd(
 					$retVal,
-					bcmul( array_search( $number[$i - 1], $fromBase ), bcpow( $fromLen, $numberLen - $i ) )
+					bcmul(array_search($number[$i - 1], $fromBase), bcpow($fromLen, $numberLen - $i))
 				);
 			}
 
 			return $retVal;
 		}
-		if( $fromBaseInput != '0123456789' ) {
-			$base10 = self::convBase( $numberInput, $fromBaseInput, '0123456789' );
+		if ($fromBaseInput != '0123456789') {
+			$base10 = self::convBase($numberInput, $fromBaseInput, '0123456789');
 		} else {
 			$base10 = $numberInput;
 		}
-		if( $base10 < strlen( $toBaseInput ) ) {
+		if ($base10 < strlen($toBaseInput)) {
 			return $toBase[$base10];
 		}
-		while($base10 != '0') {
-			$retVal = $toBase[bcmod( $base10, $toLen )] . $retVal;
-			$base10 = bcdiv( $base10, $toLen, 0 );
+		while ($base10 != '0') {
+			$retVal = $toBase[bcmod($base10, $toLen)].$retVal;
+			$base10 = bcdiv($base10, $toLen, 0);
 		}
 
 		return $retVal;
@@ -377,20 +377,20 @@ 
 	 * @param   string $string Binary string
 	 * @return  array           Array with decimal converted numbers
 	 */
-	protected function unpack( $string ) {
+	protected function unpack($string) {
 
 		$chunk = 0;
 		$int = null;
 		$return = array();
-		foreach( unpack( 'C*', $string ) as $byte ) {
-			$int = bcadd( $int, bcmul( $byte, bcpow( 2, $chunk * 8 ) ) );
-			if( ++$chunk == $this->chunkSize ) {
+		foreach (unpack('C*', $string) as $byte) {
+			$int = bcadd($int, bcmul($byte, bcpow(2, $chunk * 8)));
+			if ( ++$chunk == $this->chunkSize ) {
 				$return[] = $int;
 				$chunk = 0;
 				$int = null;
 			}
 		}
-		if( $chunk > 0 ) {
+		if ($chunk > 0) {
 			$return[] = $int;
 		}
 
@@ -408,11 +408,11 @@ 
 	 * @param   integer $bytes Bytes used to represent a string
 	 * @return  integer Number of chars
 	 */
-	protected function maxKeyLength( $bytes ) {
+	protected function maxKeyLength($bytes) {
 
-		$maxInt = bcpow( 2, $bytes * 8 );
-		$converted = self::convBase( $maxInt, self::DECIMAL, self::CHARS );
-		return strlen( $converted );
+		$maxInt = bcpow(2, $bytes * 8);
+		$converted = self::convBase($maxInt, self::DECIMAL, self::CHARS);
+		return strlen($converted);
 	}
 
 
@@ -424,19 +424,19 @@ 
 	 * @param   integer $threshold Minimum number of shares required for decryption
 	 * @return  array
 	 */
-	protected function divideSecret( $secret, $shares, $threshold ) {
+	protected function divideSecret($secret, $shares, $threshold) {
 
 		// divide secret into chunks, which we encrypt one by one
 		$result = array();
 
-		foreach( $this->unpack( $secret ) as $bytes ) {
-			$coeffs = $this->generateCoefficients( $threshold );
+		foreach ($this->unpack($secret) as $bytes) {
+			$coeffs = $this->generateCoefficients($threshold);
 			$coeffs[] = $bytes;
 
 			// go through x coordinates and calculate y value
-			for( $x = 1; $x <= $shares; $x++ ) {
+			for ($x = 1; $x <= $shares; $x++) {
 				// use horner method to calculate y value
-				$result[] = $this->hornerMethod( $x, $coeffs );
+				$result[] = $this->hornerMethod($x, $coeffs);
 			}
 		}
 
@@ -447,61 +447,61 @@ 
 	/**
 	 * @inheritdoc
 	 */
-	public function share( $secret, $shares, $threshold = 2 ) {
+	public function share($secret, $shares, $threshold = 2) {
 
-		$this->setMaxShares( $shares );
+		$this->setMaxShares($shares);
 
 		// check if number of shares is less than our prime, otherwise we have a security problem
-		if( $shares >= $this->prime || $shares < 1 ) {
-			throw new \OutOfRangeException( 'Number of shares has to be between 1 and ' . $this->prime . '.' );
+		if ($shares >= $this->prime || $shares < 1) {
+			throw new \OutOfRangeException('Number of shares has to be between 1 and '.$this->prime.'.');
 		}
 
-		if( $shares < $threshold ) {
-			throw new \OutOfRangeException( 'Threshold has to be between 1 and ' . $shares . '.' );
+		if ($shares < $threshold) {
+			throw new \OutOfRangeException('Threshold has to be between 1 and '.$shares.'.');
 		}
 
-		if( strpos( self::CHARS, self::PAD_CHAR ) !== false ) {
-			throw new \OutOfRangeException( 'Padding character must not be part of possible encryption chars.' );
+		if (strpos(self::CHARS, self::PAD_CHAR) !== false) {
+			throw new \OutOfRangeException('Padding character must not be part of possible encryption chars.');
 		}
 
 		// divide secret into chunks, which we encrypt one by one
-		$result = $this->divideSecret( $secret, $shares, $threshold );
+		$result = $this->divideSecret($secret, $shares, $threshold);
 
 		// encode number of bytes and threshold
 
 		// calculate the maximum length of key sequence number and threshold
-		$maxBaseLength = $this->maxKeyLength( $this->chunkSize );
+		$maxBaseLength = $this->maxKeyLength($this->chunkSize);
 		// in order to do a correct padding to the converted base, we need to use the first char of the base
-		$paddingChar = substr( self::CHARS, 0, 1 );
+		$paddingChar = substr(self::CHARS, 0, 1);
 		// define prefix number using the number of bytes (hex), and a left padded string used for threshold (base converted)
-		$fixPrefixFormat = '%x%' . $paddingChar . $maxBaseLength . 's';
+		$fixPrefixFormat = '%x%'.$paddingChar.$maxBaseLength.'s';
 		// prefix is going to be the same for all keys
-		$prefix = sprintf( $fixPrefixFormat, $this->chunkSize, self::convBase( $threshold, self::DECIMAL, self::CHARS ) );
+		$prefix = sprintf($fixPrefixFormat, $this->chunkSize, self::convBase($threshold, self::DECIMAL, self::CHARS));
 
 		// convert y coordinates into hexadecimals shares
 		$passwords = array();
-		$secretLen = strlen( $secret );
+		$secretLen = strlen($secret);
 		// calculate how many bytes, we need to cut off during recovery
-		if( $secretLen % $this->chunkSize > 0 ) {
-			$tail = str_repeat( self::PAD_CHAR, $this->chunkSize - $secretLen % $this->chunkSize );
+		if ($secretLen % $this->chunkSize > 0) {
+			$tail = str_repeat(self::PAD_CHAR, $this->chunkSize - $secretLen % $this->chunkSize);
 		} else {
 			$tail = '';
 		}
 
-		$chunks = ceil( $secretLen / $this->chunkSize );
-		for( $i = 0; $i < $shares; ++$i ) {
-			$sequence = self::convBase( ( $i + 1 ), self::DECIMAL, self::CHARS );
-			$key = sprintf( $prefix . '%' . $paddingChar . $maxBaseLength . 's', $sequence );
+		$chunks = ceil($secretLen / $this->chunkSize);
+		for ($i = 0; $i < $shares; ++$i) {
+			$sequence = self::convBase(($i + 1), self::DECIMAL, self::CHARS);
+			$key = sprintf($prefix.'%'.$paddingChar.$maxBaseLength.'s', $sequence);
 
-			for( $j = 0; $j < $chunks; ++$j ) {
+			for ($j = 0; $j < $chunks; ++$j) {
 				$key .= str_pad(
-					self::convBase( $result[$j * $shares + $i], self::DECIMAL, self::CHARS ),
+					self::convBase($result[$j * $shares + $i], self::DECIMAL, self::CHARS),
 					$maxBaseLength,
 					$paddingChar,
 					STR_PAD_LEFT
 				);
 			}
-			$passwords[] = $key . $tail;
+			$passwords[] = $key.$tail;
 		}
 
 		return $passwords;
@@ -518,23 +518,23 @@ 
 	 * @param integer $threshold Minimum number of shares required for decryption
 	 * @return string
 	 */
-	protected function joinSecret( $keyX, $keyY, $bytes, $keyLen, $threshold ) {
+	protected function joinSecret($keyX, $keyY, $bytes, $keyLen, $threshold) {
 
-		$coefficients = $this->reverseCoefficients( $keyX, $threshold );
+		$coefficients = $this->reverseCoefficients($keyX, $threshold);
 
 		$secret = '';
-		for( $i = 0; $i < $keyLen; $i++ ) {
+		for ($i = 0; $i < $keyLen; $i++) {
 			$temp = 0;
-			for( $j = 0; $j < $threshold; $j++ ) {
+			for ($j = 0; $j < $threshold; $j++) {
 				$temp = $this->modulo(
-							 bcadd( $temp, bcmul( $keyY[$j * $keyLen + $i], $coefficients[$j] ) )
+							 bcadd($temp, bcmul($keyY[$j * $keyLen + $i], $coefficients[$j]))
 				);
 			}
 			// convert each byte back into char
-			for( $byte = 1; $byte <= $bytes; ++$byte ) {
-				$char = bcmod( $temp, 256 );
-				$secret .= chr( $char );
-				$temp = bcdiv( bcsub( $temp, $char ), 256 );
+			for ($byte = 1; $byte <= $bytes; ++$byte) {
+				$char = bcmod($temp, 256);
+				$secret .= chr($char);
+				$temp = bcdiv(bcsub($temp, $char), 256);
 			}
 		}
 
@@ -545,10 +545,10 @@ 
 	/**
 	 * @inheritdoc
 	 */
-	public function recover( array $keys ) {
+	public function recover(array $keys) {
 
-		if( !count( $keys ) ) {
-			throw new \RuntimeException( 'No keys given.' );
+		if (!count($keys)) {
+			throw new \RuntimeException('No keys given.');
 		}
 
 		$keyX = array();
@@ -557,53 +557,53 @@ 
 		$threshold = null;
 
 		// analyse first key
-		$key = reset( $keys );
+		$key = reset($keys);
 		// first we need to find out the bytes to predict threshold and sequence length
-		$bytes = hexdec( substr( $key, 0, 1 ) );
-		$this->setChunkSize( $bytes );
+		$bytes = hexdec(substr($key, 0, 1));
+		$this->setChunkSize($bytes);
 		// calculate the maximum length of key sequence number and threshold
-		$maxBaseLength = $this->maxKeyLength( $bytes );
+		$maxBaseLength = $this->maxKeyLength($bytes);
 		// define key format: bytes (hex), threshold, sequence, and key (except of bytes, all is base converted)
-		$keyFormat = '%1x%' . $maxBaseLength . 's%' . $maxBaseLength . 's%s';
+		$keyFormat = '%1x%'.$maxBaseLength.'s%'.$maxBaseLength.'s%s';
 
-		foreach( $keys as $key ) {
+		foreach ($keys as $key) {
 			// remove trailing padding characters
-			$key = str_replace( self::PAD_CHAR, '', $key );
+			$key = str_replace(self::PAD_CHAR, '', $key);
 
 			// extract "public" information of key: bytes, threshold, sequence
 
-			list( $keyBytes, $keyThreshold, $keySequence, $key ) = sscanf( $key, $keyFormat );
-			$keyThreshold = (int)self::convBase( $keyThreshold, self::CHARS, self::DECIMAL );
-			$keySequence = (int)self::convBase( $keySequence, self::CHARS, self::DECIMAL );
+			list($keyBytes, $keyThreshold, $keySequence, $key) = sscanf($key, $keyFormat);
+			$keyThreshold = (int)self::convBase($keyThreshold, self::CHARS, self::DECIMAL);
+			$keySequence = (int)self::convBase($keySequence, self::CHARS, self::DECIMAL);
 
-			if( $threshold === null ) {
+			if ($threshold === null) {
 				$threshold = $keyThreshold;
 
-				if( $threshold > count( $keys ) ) {
-					throw new \RuntimeException( 'Not enough keys to disclose secret.' );
+				if ($threshold > count($keys)) {
+					throw new \RuntimeException('Not enough keys to disclose secret.');
 				}
-			} elseif( $threshold != $keyThreshold || $bytes != hexdec( $keyBytes ) ) {
-				throw new \RuntimeException( 'Given keys are incompatible.' );
+			} elseif ($threshold != $keyThreshold || $bytes != hexdec($keyBytes)) {
+				throw new \RuntimeException('Given keys are incompatible.');
 			}
 
 			$keyX[] = $keySequence;
-			if( $keyLen === null ) {
-				$keyLen = strlen( $key );
-			} elseif( $keyLen != strlen( $key ) ) {
-				throw new \RuntimeException( 'Given keys vary in key length.' );
+			if ($keyLen === null) {
+				$keyLen = strlen($key);
+			} elseif ($keyLen != strlen($key)) {
+				throw new \RuntimeException('Given keys vary in key length.');
 			}
-			for( $i = 0; $i < $keyLen; $i += $maxBaseLength ) {
-				$keyY[] = self::convBase( substr( $key, $i, $maxBaseLength ), self::CHARS, self::DECIMAL );
+			for ($i = 0; $i < $keyLen; $i += $maxBaseLength) {
+				$keyY[] = self::convBase(substr($key, $i, $maxBaseLength), self::CHARS, self::DECIMAL);
 			}
 		}
 
 		$keyLen /= $maxBaseLength;
-		$secret = $this->joinSecret( $keyX, $keyY, $bytes, $keyLen, $threshold );
+		$secret = $this->joinSecret($keyX, $keyY, $bytes, $keyLen, $threshold);
 
 		// remove padding from secret (NULL bytes);
-		$padCount = substr_count( reset( $keys ), self::PAD_CHAR );
-		if( $padCount ) {
-			$secret = substr( $secret, 0, -1 * $padCount );
+		$padCount = substr_count(reset($keys), self::PAD_CHAR);
+		if ($padCount) {
+			$secret = substr($secret, 0, -1 * $padCount);
 		}
 
 		return $secret;