Crypt: keys of an invalid length weren't being resized

terrafrost · terrafrost · commit b2a73d608ea4 · 2023-12-16T09:51:08.000-06:00
diff --git a/src/Crypt/AES.php b/src/Crypt/AES.php
@@ -59,27 +59,21 @@
 class AES extends Base
 {
     /**
-     * Sets the key length
+     * Turns key lengths, be they valid or invalid, to valid key lengths
      *
-     * Valid key lengths are 128, 192, and 256.  If the length is less than 128, it will be rounded up to
-     * 128.  If the length is greater than 128 and invalid, it will be rounded down to the closest valid amount.
-     *
-     * @see \phpseclib\Crypt\Rijndael:setKeyLength()
-     * @access public
      * @param int $length
+     * @access private
+     * @return int
      */
-    public function setKeyLength($length)
+    protected function calculateNewKeyLength($length)
     {
         switch (true) {
             case $length <= 128:
-                $length = 128;
-                break;
+                return 128;
             case $length <= 192:
-                $length = 192;
-                break;
+                return 192;
             default:
-                $length = 256;
+                return 256;
         }
-        parent::setKeyLength($length);
     }
 }
diff --git a/src/Crypt/Base.php b/src/Crypt/Base.php
@@ -263,7 +263,7 @@ public function setKeyLength($length)
     {
         // algorithms that have a fixed key length should override this with a method that does nothing
         $this->changed = true;
-        $this->key_length = $length;
+        $this->key_length = static::calculateNewKeyLength($length);
         $this->explicit_key_length = true;
     }
 
@@ -307,7 +307,7 @@ public function setKey($key)
     {
         $this->key = $key;
         if (!$this->explicit_key_length) {
-            $this->key_length = strlen($key) << 3;
+            $this->key_length = static::calculateNewKeyLength(strlen($key) << 3);
         }
         $this->changed = true;
     }
diff --git a/src/Crypt/Blowfish.php b/src/Crypt/Blowfish.php
@@ -47,20 +47,20 @@
 class Blowfish extends Base
 {
     /**
-     * Sets the key length.
+     * Turns key lengths, be they valid or invalid, to valid key lengths
      *
-     * Key lengths can be between 32 and 448 bits.
-     *
-     * @access public
      * @param int $length
+     * @access private
+     * @return int
      */
-    public function setKeyLength($length)
+    protected function calculateNewKeyLength($length)
     {
-        if ($length < 32) {
-            $length = 32;
-        } elseif ($length > 448) {
-            $length = 448;
+        switch (true) {
+            case $length < 32:
+                return 32;
+            case $length > 448:
+                return 448;
         }
-        parent::setKeyLength($length);
+        return $length;
     }
 }
diff --git a/src/Crypt/DES.php b/src/Crypt/DES.php
@@ -52,13 +52,14 @@
 class DES extends Base
 {
     /**
-     * Dummy method
+     * Turns key lengths, be they valid or invalid, to valid key lengths
      *
-     * @access public
      * @param int $length
+     * @access private
+     * @return int
      */
-    public function setKeyLength($length)
+    protected function calculateNewKeyLength($length)
     {
-        parent::setKeyLength(64);
+        return 64;
     }
 }
diff --git a/src/Crypt/RC2.php b/src/Crypt/RC2.php
@@ -73,23 +73,22 @@ public function __construct($mode = self::MODE_CBC)
     }
 
     /**
-     * Sets the key length.
+     * Turns key lengths, be they valid or invalid, to valid key lengths
      *
-     * Valid key lengths are 8 to 1024.
-     * Calling this function after setting the key has no effect until the next
-     *  \phpseclib\Crypt\RC2::setKey() call.
-     *
-     * @access public
-     * @param int $length in bits
+     * @param int $length
+     * @access private
+     * @return int
      */
-    public function setKeyLength($length)
+    protected function calculateNewKeyLength($length)
     {
-        if ($length < 8) {
-            $length = 8;
-        } elseif ($length > 1024) {
-            $length = 1024;
+        switch (true) {
+            case $length < 8:
+                return 8;
+            case $length > 1024:
+                return 1024;
         }
-        parent::setKeyLength($length);
+
+        return $length;
     }
 
     /**
diff --git a/src/Crypt/RC4.php b/src/Crypt/RC4.php
@@ -54,20 +54,21 @@
 class RC4 extends Base
 {
     /**
-     * Sets the key length
+     * Turns key lengths, be they valid or invalid, to valid key lengths
      *
-     * Keys can be between 1 and 256 bytes long.
-     *
-     * @access public
      * @param int $length
+     * @access private
+     * @return int
      */
-    public function setKeyLength($length)
+    protected function calculateNewKeyLength($length)
     {
-        if ($length < 8) {
-            $length = 8;
-        } elseif ($length > 2048) {
-            $length = 2048;
+        switch (true) {
+            case $length < 8:
+                return 8;
+            case $length > 2048:
+                return 2048;
         }
-        parent::setKeyLength($length);
+
+        return $length;
     }
 }
diff --git a/src/Crypt/Rijndael.php b/src/Crypt/Rijndael.php
@@ -63,47 +63,6 @@
  */
 class Rijndael extends Base
 {
-    /**
-     * Sets the key length.
-     *
-     * Valid key lengths are 128, 160, 192, 224, and 256.  If the length is less than 128, it will be rounded up to
-     * 128.  If the length is greater than 128 and invalid, it will be rounded down to the closest valid amount.
-     *
-     * Note: phpseclib extends Rijndael (and AES) for using 160- and 224-bit keys but they are officially not defined
-     *       and the most (if not all) implementations are not able using 160/224-bit keys but round/pad them up to
-     *       192/256 bits as, for example, mcrypt will do.
-     *
-     *       That said, if you want be compatible with other Rijndael and AES implementations,
-     *       you should not setKeyLength(160) or setKeyLength(224).
-     *
-     * Additional: In case of 160- and 224-bit keys, phpseclib will/can, for that reason, not use
-     *             the mcrypt php extension, even if available.
-     *             This results then in slower encryption.
-     *
-     * @access public
-     * @param int $length
-     */
-    public function setKeyLength($length)
-    {
-        switch (true) {
-            case $length <= 128:
-                $length = 128;
-                break;
-            case $length <= 160:
-                $length = 160;
-                break;
-            case $length <= 192:
-                $length = 192;
-                break;
-            case $length <= 224:
-                $length = 224;
-                break;
-            default:
-                $length = 256;
-        }
-        parent::setKeyLength($length);
-    }
-
     /**
      * Sets the block length
      *
@@ -123,4 +82,27 @@ public function setBlockLength($length)
         }
         $this->cipher->setBlockLength($length);
     }
+
+    /**
+     * Turns key lengths, be they valid or invalid, to valid key lengths
+     *
+     * @param int $length
+     * @access private
+     * @return int
+     */
+    protected function calculateNewKeyLength($length)
+    {
+        switch (true) {
+            case $length <= 128:
+                return 128;
+            case $length <= 160:
+                return 160;
+            case $length <= 192:
+                return 192;
+            case $length <= 224:
+                return 224;
+            default:
+                return 256;
+        }
+    }
 }
diff --git a/src/Crypt/TripleDES.php b/src/Crypt/TripleDES.php
@@ -96,26 +96,21 @@ public function __construct($mode = self::MODE_CBC)
     }
 
     /**
-     * Sets the key length
+     * Turns key lengths, be they valid or invalid, to valid key lengths
      *
-     * Keys can be between 1 and 256 bytes long.
-     *
-     * @access public
      * @param int $length
+     * @access private
+     * @return int
      */
-    public function setKeyLength($length)
+    protected function calculateNewKeyLength($length)
     {
         switch (true) {
             case $length <= 64:
-                $length = 64;
-                break;
+                return 64;
             case $length <= 128:
-                $length = 128;
-                break;
+                return 128;
             default:
-                $length = 192;
+                return 192;
         }
-
-        parent::setKeyLength($length);
     }
 }
diff --git a/src/Crypt/Twofish.php b/src/Crypt/Twofish.php
@@ -47,26 +47,21 @@
 class Twofish extends Base
 {
     /**
-     * Sets the key length
+     * Turns key lengths, be they valid or invalid, to valid key lengths
      *
-     * Keys can be between 1 and 256 bytes long.
-     *
-     * @access public
      * @param int $length
+     * @access private
+     * @return int
      */
-    public function setKeyLength($length)
+    protected function calculateNewKeyLength($length)
     {
         switch (true) {
             case $length <= 128:
-                $length = 128;
-                break;
+                return 128;
             case $length <= 192:
-                $length = 192;
-                break;
+                return 192;
             default:
-                $length = 256;
+                return 256;
         }
-
-        parent::setKeyLength($length);
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -263,7 +263,7 @@ public function setKeyLength($length)`
`263`	`263`	`{`
`264`	`264`	`// algorithms that have a fixed key length should override this with a method that does nothing`
`265`	`265`	`$this->changed = true;`
`266`		`- $this->key_length = $length;`
	`266`	`+ $this->key_length = static::calculateNewKeyLength($length);`
`267`	`267`	`$this->explicit_key_length = true;`
`268`	`268`	`}`
`269`	`269`
`@@ -307,7 +307,7 @@ public function setKey($key)`
`307`	`307`	`{`
`308`	`308`	`$this->key = $key;`
`309`	`309`	`if (!$this->explicit_key_length) {`
`310`		`- $this->key_length = strlen($key) << 3;`
	`310`	`+ $this->key_length = static::calculateNewKeyLength(strlen($key) << 3);`
`311`	`311`	`}`
`312`	`312`	`$this->changed = true;`
`313`	`313`	`}`
Original file line number	Diff line number	Diff line change
`@@ -47,20 +47,20 @@`
`47`	`47`	`class Blowfish extends Base`
`48`	`48`	`{`
`49`	`49`	`/**`
`50`		`- * Sets the key length.`
	`50`	`+ * Turns key lengths, be they valid or invalid, to valid key lengths`
`51`	`51`	`*`
`52`		`- * Key lengths can be between 32 and 448 bits.`
`53`		`- *`
`54`		`- * @access public`
`55`	`52`	`* @param int $length`
	`53`	`+ * @access private`
	`54`	`+ * @return int`
`56`	`55`	`*/`
`57`		`- public function setKeyLength($length)`
	`56`	`+ protected function calculateNewKeyLength($length)`
`58`	`57`	`{`
`59`		`- if ($length < 32) {`
`60`		`- $length = 32;`
`61`		`- } elseif ($length > 448) {`
`62`		`- $length = 448;`
	`58`	`+ switch (true) {`
	`59`	`+ case $length < 32:`
	`60`	`+ return 32;`
	`61`	`+ case $length > 448:`
	`62`	`+ return 448;`
`63`	`63`	`}`
`64`		`- parent::setKeyLength($length);`
	`64`	`+ return $length;`
`65`	`65`	`}`
`66`	`66`	`}`
Original file line number	Diff line number	Diff line change
`@@ -52,13 +52,14 @@`
`52`	`52`	`class DES extends Base`
`53`	`53`	`{`
`54`	`54`	`/**`
`55`		`- * Dummy method`
	`55`	`+ * Turns key lengths, be they valid or invalid, to valid key lengths`
`56`	`56`	`*`
`57`		`- * @access public`
`58`	`57`	`* @param int $length`
	`58`	`+ * @access private`
	`59`	`+ * @return int`
`59`	`60`	`*/`
`60`		`- public function setKeyLength($length)`
	`61`	`+ protected function calculateNewKeyLength($length)`
`61`	`62`	`{`
`62`		`- parent::setKeyLength(64);`
	`63`	`+ return 64;`
`63`	`64`	`}`
`64`	`65`	`}`
Original file line number	Diff line number	Diff line change
`@@ -54,20 +54,21 @@`
`54`	`54`	`class RC4 extends Base`
`55`	`55`	`{`
`56`	`56`	`/**`
`57`		`- * Sets the key length`
	`57`	`+ * Turns key lengths, be they valid or invalid, to valid key lengths`
`58`	`58`	`*`
`59`		`- * Keys can be between 1 and 256 bytes long.`
`60`		`- *`
`61`		`- * @access public`
`62`	`59`	`* @param int $length`
	`60`	`+ * @access private`
	`61`	`+ * @return int`
`63`	`62`	`*/`
`64`		`- public function setKeyLength($length)`
	`63`	`+ protected function calculateNewKeyLength($length)`
`65`	`64`	`{`
`66`		`- if ($length < 8) {`
`67`		`- $length = 8;`
`68`		`- } elseif ($length > 2048) {`
`69`		`- $length = 2048;`
	`65`	`+ switch (true) {`
	`66`	`+ case $length < 8:`
	`67`	`+ return 8;`
	`68`	`+ case $length > 2048:`
	`69`	`+ return 2048;`
`70`	`70`	`}`
`71`		`- parent::setKeyLength($length);`
	`71`	`+`
	`72`	`+ return $length;`
`72`	`73`	`}`
`73`	`74`	`}`
Original file line number	Diff line number	Diff line change
`@@ -96,26 +96,21 @@ public function __construct($mode = self::MODE_CBC)`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`/**`
`99`		`- * Sets the key length`
	`99`	`+ * Turns key lengths, be they valid or invalid, to valid key lengths`
`100`	`100`	`*`
`101`		`- * Keys can be between 1 and 256 bytes long.`
`102`		`- *`
`103`		`- * @access public`
`104`	`101`	`* @param int $length`
	`102`	`+ * @access private`
	`103`	`+ * @return int`
`105`	`104`	`*/`
`106`		`- public function setKeyLength($length)`
	`105`	`+ protected function calculateNewKeyLength($length)`
`107`	`106`	`{`
`108`	`107`	`switch (true) {`
`109`	`108`	`case $length <= 64:`
`110`		`- $length = 64;`
`111`		`- break;`
	`109`	`+ return 64;`
`112`	`110`	`case $length <= 128:`
`113`		`- $length = 128;`
`114`		`- break;`
	`111`	`+ return 128;`
`115`	`112`	`default:`
`116`		`- $length = 192;`
	`113`	`+ return 192;`
`117`	`114`	`}`
`118`		`-`
`119`		`- parent::setKeyLength($length);`
`120`	`115`	`}`
`121`	`116`	`}`
Original file line number	Diff line number	Diff line change
`@@ -47,26 +47,21 @@`
`47`	`47`	`class Twofish extends Base`
`48`	`48`	`{`
`49`	`49`	`/**`
`50`		`- * Sets the key length`
	`50`	`+ * Turns key lengths, be they valid or invalid, to valid key lengths`
`51`	`51`	`*`
`52`		`- * Keys can be between 1 and 256 bytes long.`
`53`		`- *`
`54`		`- * @access public`
`55`	`52`	`* @param int $length`
	`53`	`+ * @access private`
	`54`	`+ * @return int`
`56`	`55`	`*/`
`57`		`- public function setKeyLength($length)`
	`56`	`+ protected function calculateNewKeyLength($length)`
`58`	`57`	`{`
`59`	`58`	`switch (true) {`
`60`	`59`	`case $length <= 128:`
`61`		`- $length = 128;`
`62`		`- break;`
	`60`	`+ return 128;`
`63`	`61`	`case $length <= 192:`
`64`		`- $length = 192;`
`65`		`- break;`
	`62`	`+ return 192;`
`66`	`63`	`default:`
`67`		`- $length = 256;`
	`64`	`+ return 256;`
`68`	`65`	`}`
`69`		`-`
`70`		`- parent::setKeyLength($length);`
`71`	`66`	`}`
`72`	`67`	`}`