PHP-Las declaraciones de clase no pueden anidarse

cakephp aes

Question

Tengo un proyecto en cakephp, cuando llamo a un proveedor para descifrar una cadena usando AES, obtengo el error:

Fatal error: Class declarations may not be nested in /var/www/html/myproject/cake/libs/log/file_log.php on line 30

Este es el código en mi controlador:

App::import(''vendor'', ''aes'', array(''file'' => ''AES/AES.php''));
$aes = new AesCtr();
$decrypted = $aes->decrypt($encrypted, "mykey", 128);

Y esto es parte del proveedor (un solo archivo llamado AES.php):

class Aes {
//....Methods
}

class AesCtr extends Aes {

  public static function decrypt($ciphertext, $password, $nBits) {
  //....Method Logic
  }

  //....Other methods

}

He leído la explicación aquí: las clases PHP anidadas funcionan ... ¿algo así como? pero no tengo mucha experiencia en PHP y no pude resolver este problema por la "forma hacky" que mostraron.

Cualquier ayuda es apreciada. Si se necesita más información, por favor dígame.

ACTUALIZACIÓN Las clases Aes y AesCtr (ambas están en el archivo AES.php).

<?php
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */
/*  AES implementation in PHP                                                                     */
/*    (c) Chris Veness 2005-2011 www.movable-type.co.uk/scripts                                   */
/*    Right of free use is granted for all commercial or non-commercial use providing this        */
/*    copyright notice is retainded. No warranty of any form is offered.                          */
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */

class Aes {

  /**
   * AES Cipher function: encrypt ''input'' with Rijndael algorithm
   *
   * @param input message as byte-array (16 bytes)
   * @param w     key schedule as 2D byte-array (Nr+1 x Nb bytes) - 
   *              generated from the cipher key by keyExpansion()
   * @return      ciphertext as byte-array (16 bytes)
   */
  public static function cipher($input, $w) {    // main cipher function [§5.1]
    $Nb = 4;                 // block size (in words): no of columns in state (fixed at 4 for AES)
    $Nr = count($w)/$Nb - 1; // no of rounds: 10/12/14 for 128/192/256-bit keys

    $state = array();  // initialise 4xNb byte-array ''state'' with input [§3.4]
    for ($i=0; $i<4*$Nb; $i++) $state[$i%4][floor($i/4)] = $input[$i];

    $state = self::addRoundKey($state, $w, 0, $Nb);

    for ($round=1; $round<$Nr; $round++) {  // apply Nr rounds
      $state = self::subBytes($state, $Nb);
      $state = self::shiftRows($state, $Nb);
      $state = self::mixColumns($state, $Nb);
      $state = self::addRoundKey($state, $w, $round, $Nb);
    }

    $state = self::subBytes($state, $Nb);
    $state = self::shiftRows($state, $Nb);
    $state = self::addRoundKey($state, $w, $Nr, $Nb);

    $output = array(4*$Nb);  // convert state to 1-d array before returning [§3.4]
    for ($i=0; $i<4*$Nb; $i++) $output[$i] = $state[$i%4][floor($i/4)];
    return $output;
  }


  private static function addRoundKey($state, $w, $rnd, $Nb) {  // xor Round Key into state S [§5.1.4]
    for ($r=0; $r<4; $r++) {
      for ($c=0; $c<$Nb; $c++) $state[$r][$c] ^= $w[$rnd*4+$c][$r];
    }
    return $state;
  }

  private static function subBytes($s, $Nb) {    // apply SBox to state S [§5.1.1]
    for ($r=0; $r<4; $r++) {
      for ($c=0; $c<$Nb; $c++) $s[$r][$c] = self::$sBox[$s[$r][$c]];
    }
    return $s;
  }

  private static function shiftRows($s, $Nb) {    // shift row r of state S left by r bytes [§5.1.2]
    $t = array(4);
    for ($r=1; $r<4; $r++) {
      for ($c=0; $c<4; $c++) $t[$c] = $s[$r][($c+$r)%$Nb];  // shift into temp copy
      for ($c=0; $c<4; $c++) $s[$r][$c] = $t[$c];           // and copy back
    }          // note that this will work for Nb=4,5,6, but not 7,8 (always 4 for AES):
    return $s;  // see fp.gladman.plus.com/cryptography_technology/rijndael/aes.spec.311.pdf 
  }

  private static function mixColumns($s, $Nb) {   // combine bytes of each col of state S [§5.1.3]
    for ($c=0; $c<4; $c++) {
      $a = array(4);  // ''a'' is a copy of the current column from ''s''
      $b = array(4);  // ''b'' is a•{02} in GF(2^8)
      for ($i=0; $i<4; $i++) {
        $a[$i] = $s[$i][$c];
        $b[$i] = $s[$i][$c]&0x80 ? $s[$i][$c]<<1 ^ 0x011b : $s[$i][$c]<<1;
      }
      // a[n] ^ b[n] is a•{03} in GF(2^8)
      $s[0][$c] = $b[0] ^ $a[1] ^ $b[1] ^ $a[2] ^ $a[3]; // 2*a0 + 3*a1 + a2 + a3
      $s[1][$c] = $a[0] ^ $b[1] ^ $a[2] ^ $b[2] ^ $a[3]; // a0 * 2*a1 + 3*a2 + a3
      $s[2][$c] = $a[0] ^ $a[1] ^ $b[2] ^ $a[3] ^ $b[3]; // a0 + a1 + 2*a2 + 3*a3
      $s[3][$c] = $a[0] ^ $b[0] ^ $a[1] ^ $a[2] ^ $b[3]; // 3*a0 + a1 + a2 + 2*a3
    }
    return $s;
  }

  /**
   * Key expansion for Rijndael cipher(): performs key expansion on cipher key
   * to generate a key schedule
   *
   * @param key cipher key byte-array (16 bytes)
   * @return    key schedule as 2D byte-array (Nr+1 x Nb bytes)
   */
  public static function keyExpansion($key) {  // generate Key Schedule from Cipher Key [§5.2]
    $Nb = 4;              // block size (in words): no of columns in state (fixed at 4 for AES)
    $Nk = count($key)/4;  // key length (in words): 4/6/8 for 128/192/256-bit keys
    $Nr = $Nk + 6;        // no of rounds: 10/12/14 for 128/192/256-bit keys

    $w = array();
    $temp = array();

    for ($i=0; $i<$Nk; $i++) {
      $r = array($key[4*$i], $key[4*$i+1], $key[4*$i+2], $key[4*$i+3]);
      $w[$i] = $r;
    }

    for ($i=$Nk; $i<($Nb*($Nr+1)); $i++) {
      $w[$i] = array();
      for ($t=0; $t<4; $t++) $temp[$t] = $w[$i-1][$t];
      if ($i % $Nk == 0) {
        $temp = self::subWord(self::rotWord($temp));
        for ($t=0; $t<4; $t++) $temp[$t] ^= self::$rCon[$i/$Nk][$t];
      } else if ($Nk > 6 && $i%$Nk == 4) {
        $temp = self::subWord($temp);
      }
      for ($t=0; $t<4; $t++) $w[$i][$t] = $w[$i-$Nk][$t] ^ $temp[$t];
    }
    return $w;
  }

  private static function subWord($w) {    // apply SBox to 4-byte word w
    for ($i=0; $i<4; $i++) $w[$i] = self::$sBox[$w[$i]];
    return $w;
  }

  private static function rotWord($w) {    // rotate 4-byte word w left by one byte
    $tmp = $w[0];
    for ($i=0; $i<3; $i++) $w[$i] = $w[$i+1];
    $w[3] = $tmp;
    return $w;
  }

  // sBox is pre-computed multiplicative inverse in GF(2^8) used in subBytes and keyExpansion [§5.1.1]
  private static $sBox = array(
    0x63,0x7c,0x77,0x7b,0xf2,0x6b,0x6f,0xc5,0x30,0x01,0x67,0x2b,0xfe,0xd7,0xab,0x76,
    0xca,0x82,0xc9,0x7d,0xfa,0x59,0x47,0xf0,0xad,0xd4,0xa2,0xaf,0x9c,0xa4,0x72,0xc0,
    0xb7,0xfd,0x93,0x26,0x36,0x3f,0xf7,0xcc,0x34,0xa5,0xe5,0xf1,0x71,0xd8,0x31,0x15,
    0x04,0xc7,0x23,0xc3,0x18,0x96,0x05,0x9a,0x07,0x12,0x80,0xe2,0xeb,0x27,0xb2,0x75,
    0x09,0x83,0x2c,0x1a,0x1b,0x6e,0x5a,0xa0,0x52,0x3b,0xd6,0xb3,0x29,0xe3,0x2f,0x84,
    0x53,0xd1,0x00,0xed,0x20,0xfc,0xb1,0x5b,0x6a,0xcb,0xbe,0x39,0x4a,0x4c,0x58,0xcf,
    0xd0,0xef,0xaa,0xfb,0x43,0x4d,0x33,0x85,0x45,0xf9,0x02,0x7f,0x50,0x3c,0x9f,0xa8,
    0x51,0xa3,0x40,0x8f,0x92,0x9d,0x38,0xf5,0xbc,0xb6,0xda,0x21,0x10,0xff,0xf3,0xd2,
    0xcd,0x0c,0x13,0xec,0x5f,0x97,0x44,0x17,0xc4,0xa7,0x7e,0x3d,0x64,0x5d,0x19,0x73,
    0x60,0x81,0x4f,0xdc,0x22,0x2a,0x90,0x88,0x46,0xee,0xb8,0x14,0xde,0x5e,0x0b,0xdb,
    0xe0,0x32,0x3a,0x0a,0x49,0x06,0x24,0x5c,0xc2,0xd3,0xac,0x62,0x91,0x95,0xe4,0x79,
    0xe7,0xc8,0x37,0x6d,0x8d,0xd5,0x4e,0xa9,0x6c,0x56,0xf4,0xea,0x65,0x7a,0xae,0x08,
    0xba,0x78,0x25,0x2e,0x1c,0xa6,0xb4,0xc6,0xe8,0xdd,0x74,0x1f,0x4b,0xbd,0x8b,0x8a,
    0x70,0x3e,0xb5,0x66,0x48,0x03,0xf6,0x0e,0x61,0x35,0x57,0xb9,0x86,0xc1,0x1d,0x9e,
    0xe1,0xf8,0x98,0x11,0x69,0xd9,0x8e,0x94,0x9b,0x1e,0x87,0xe9,0xce,0x55,0x28,0xdf,
    0x8c,0xa1,0x89,0x0d,0xbf,0xe6,0x42,0x68,0x41,0x99,0x2d,0x0f,0xb0,0x54,0xbb,0x16);

  // rCon is Round Constant used for the Key Expansion [1st col is 2^(r-1) in GF(2^8)] [§5.2]
  private static $rCon = array( 
    array(0x00, 0x00, 0x00, 0x00),
    array(0x01, 0x00, 0x00, 0x00),
    array(0x02, 0x00, 0x00, 0x00),
    array(0x04, 0x00, 0x00, 0x00),
    array(0x08, 0x00, 0x00, 0x00),
    array(0x10, 0x00, 0x00, 0x00),
    array(0x20, 0x00, 0x00, 0x00),
    array(0x40, 0x00, 0x00, 0x00),
    array(0x80, 0x00, 0x00, 0x00),
    array(0x1b, 0x00, 0x00, 0x00),
    array(0x36, 0x00, 0x00, 0x00) ); 

} 

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */
?>

<?php
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */
/*  AES counter (CTR) mode implementation in PHP                                                  */
/*    (c) Chris Veness 2005-2011 www.movable-type.co.uk/scripts                                   */
/*    Right of free use is granted for all commercial or non-commercial use providing this        */
/*    copyright notice is retainded. No warranty of any form is offered.                          */
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */

class AesCtr extends Aes {

  /** 
   * Encrypt a text using AES encryption in Counter mode of operation
   *  - see http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
   *
   * Unicode multi-byte character safe
   *
   * @param plaintext source text to be encrypted
   * @param password  the password to use to generate a key
   * @param nBits     number of bits to be used in the key (128, 192, or 256)
   * @return          encrypted text
   */
  public static function encrypt($plaintext, $password, $nBits) {
    $blockSize = 16;  // block size fixed at 16 bytes / 128 bits (Nb=4) for AES
    if (!($nBits==128 || $nBits==192 || $nBits==256)) return '''';  // standard allows 128/192/256 bit keys
    // note PHP (5) gives us plaintext and password in UTF8 encoding!

    // use AES itself to encrypt password to get cipher key (using plain password as source for  
    // key expansion) - gives us well encrypted key
    $nBytes = $nBits/8;  // no bytes in key
    $pwBytes = array();
    for ($i=0; $i<$nBytes; $i++) $pwBytes[$i] = ord(substr($password,$i,1)) & 0xff;
    $key = Aes::cipher($pwBytes, Aes::keyExpansion($pwBytes));
    $key = array_merge($key, array_slice($key, 0, $nBytes-16));  // expand key to 16/24/32 bytes long 

    // initialise 1st 8 bytes of counter block with nonce (NIST SP800-38A §B.2): [0-1] = millisec, 
    // [2-3] = random, [4-7] = seconds, giving guaranteed sub-ms uniqueness up to Feb 2106
    $counterBlock = array();
    $nonce = floor(microtime(true)*1000);   // timestamp: milliseconds since 1-Jan-1970
    $nonceMs = $nonce%1000;
    $nonceSec = floor($nonce/1000);
    $nonceRnd = floor(rand(0, 0xffff));

    for ($i=0; $i<2; $i++) $counterBlock[$i]   = self::urs($nonceMs,  $i*8) & 0xff;
    for ($i=0; $i<2; $i++) $counterBlock[$i+2] = self::urs($nonceRnd, $i*8) & 0xff;
    for ($i=0; $i<4; $i++) $counterBlock[$i+4] = self::urs($nonceSec, $i*8) & 0xff;

    // and convert it to a string to go on the front of the ciphertext
    $ctrTxt = '''';
    for ($i=0; $i<8; $i++) $ctrTxt .= chr($counterBlock[$i]);

    // generate key schedule - an expansion of the key into distinct Key Rounds for each round
    $keySchedule = Aes::keyExpansion($key);
    //print_r($keySchedule);

    $blockCount = ceil(strlen($plaintext)/$blockSize);
    $ciphertxt = array();  // ciphertext as array of strings

    for ($b=0; $b<$blockCount; $b++) {
      // set counter (block #) in last 8 bytes of counter block (leaving nonce in 1st 8 bytes)
      // done in two stages for 32-bit ops: using two words allows us to go past 2^32 blocks (68GB)
      for ($c=0; $c<4; $c++) $counterBlock[15-$c] = self::urs($b, $c*8) & 0xff;
      for ($c=0; $c<4; $c++) $counterBlock[15-$c-4] = self::urs($b/0x100000000, $c*8);

      $cipherCntr = Aes::cipher($counterBlock, $keySchedule);  // -- encrypt counter block --

      // block size is reduced on final block
      $blockLength = $b<$blockCount-1 ? $blockSize : (strlen($plaintext)-1)%$blockSize+1;
      $cipherByte = array();

      for ($i=0; $i<$blockLength; $i++) {  // -- xor plaintext with ciphered counter byte-by-byte --
        $cipherByte[$i] = $cipherCntr[$i] ^ ord(substr($plaintext, $b*$blockSize+$i, 1));
        $cipherByte[$i] = chr($cipherByte[$i]);
      }
      $ciphertxt[$b] = implode('''', $cipherByte);  // escape troublesome characters in ciphertext
    }

    // implode is more efficient than repeated string concatenation
    $ciphertext = $ctrTxt . implode('''', $ciphertxt);
    $ciphertext = base64_encode($ciphertext);
    return $ciphertext;
  }


  /** 
   * Decrypt a text encrypted by AES in counter mode of operation
   *
   * @param ciphertext source text to be decrypted
   * @param password   the password to use to generate a key
   * @param nBits      number of bits to be used in the key (128, 192, or 256)
   * @return           decrypted text
   */
  public static function decrypt($ciphertext, $password, $nBits) {
    $blockSize = 16;  // block size fixed at 16 bytes / 128 bits (Nb=4) for AES
    if (!($nBits==128 || $nBits==192 || $nBits==256)) return '''';  // standard allows 128/192/256 bit keys
    //$ciphertext = AesCtr::hexToStr($ciphertext);
    $ciphertext = base64_decode($ciphertext);


    // use AES to encrypt password (mirroring encrypt routine)
    $nBytes = $nBits/8;  // no bytes in key
    $pwBytes = array();
    for ($i=0; $i<$nBytes; $i++) $pwBytes[$i] = ord(substr($password,$i,1)) & 0xff;
    $key = Aes::cipher($pwBytes, Aes::keyExpansion($pwBytes));
    $key = array_merge($key, array_slice($key, 0, $nBytes-16));  // expand key to 16/24/32 bytes long

    // recover nonce from 1st element of ciphertext
    $counterBlock = array();
    $ctrTxt = substr($ciphertext, 0, 8);
    for ($i=0; $i<8; $i++) $counterBlock[$i] = ord(substr($ctrTxt,$i,1));

    // generate key schedule
    $keySchedule = Aes::keyExpansion($key);

    // separate ciphertext into blocks (skipping past initial 8 bytes)
    $nBlocks = ceil((strlen($ciphertext)-8) / $blockSize);
    $ct = array();
    for ($b=0; $b<$nBlocks; $b++) $ct[$b] = substr($ciphertext, 8+$b*$blockSize, 16);
    $ciphertext = $ct;  // ciphertext is now array of block-length strings

    // plaintext will get generated block-by-block into array of block-length strings
    $plaintxt = array();

    for ($b=0; $b<$nBlocks; $b++) {
      // set counter (block #) in last 8 bytes of counter block (leaving nonce in 1st 8 bytes)
      for ($c=0; $c<4; $c++) $counterBlock[15-$c] = self::urs($b, $c*8) & 0xff;
      for ($c=0; $c<4; $c++) $counterBlock[15-$c-4] = self::urs(($b+1)/0x100000000-1, $c*8) & 0xff;

      $cipherCntr = Aes::cipher($counterBlock, $keySchedule);  // encrypt counter block

      $plaintxtByte = array();
      for ($i=0; $i<strlen($ciphertext[$b]); $i++) {
        // -- xor plaintext with ciphered counter byte-by-byte --
        $plaintxtByte[$i] = $cipherCntr[$i] ^ ord(substr($ciphertext[$b],$i,1));
        $plaintxtByte[$i] = chr($plaintxtByte[$i]);

      }
      $plaintxt[$b] = implode('''', $plaintxtByte); 
    }

    // join array of blocks into single plaintext string
    $plaintext = implode('''',$plaintxt);

    return $plaintext;
  }

  /* Decode Hexadecimal */
  public static function hexToStr($hex)
  {
    $string='''';
    for ($i=0; $i < strlen($hex)-1; $i+=2)
    {
        $string .= chr(hexdec($hex[$i].$hex[$i+1]));
    }
    return $string;
  }


  /*
   * Unsigned right shift function, since PHP has neither >>> operator nor unsigned ints
   *
   * @param a  number to be shifted (32-bit integer)
   * @param b  number of bits to shift a to the right (0..31)
   * @return   a right-shifted and zero-filled by b bits
   */
  private static function urs($a, $b) {
    $a &= 0xffffffff; $b &= 0x1f;  // (bounds check)
    if ($a&0x80000000 && $b>0) {   // if left-most bit set
      $a = ($a>>1) & 0x7fffffff;   //   right-shift one bit & clear left-most bit
      $a = $a >> ($b-1);           //   remaining right-shifts
    } else {                       // otherwise
      $a = ($a>>$b);               //   use normal right-shift
    } 
    return $a; 
  }

}  
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */
?>

Lo siento, debería haber mencionado esto, este código funciona bien en mi computadora, obtengo ese error cuando cargo el proyecto en un servidor, y el mensaje completo es:

Aviso (8): El número hexadecimal es demasiado grande: 0x100000000 [CORE / vendors / AES / AES.php, línea 230]

Error fatal: las declaraciones de clase no pueden anidarse en /var/www/html/myproject/cake/libs/log/file_log.php en la línea 30

Entonces no sé si el error está en el código anterior o no.

ACTUALIZACIÓN 2: file_log.php, donde se produce el error fatal (aquí hay una descripción del archivo )

<?php
/**
 * File Storage stream for Logging
 *
 * PHP versions 4 and 5
 *
 * CakePHP(tm) :  Rapid Development Framework (http://cakephp.org)
 * Copyright 2005-2010, Cake Software Foundation, Inc. (http://cakefoundation.org)
 *
 * Licensed under The MIT License
 * Redistributions of files must retain the above copyright notice.
 *
 * @copyright     Copyright 2005-2010, Cake Software Foundation, Inc. (http://cakefoundation.org)
 * @link          http://www.cakefoundation.org/projects/info/cakephp CakePHP(tm) Project
 * @package       cake
 * @subpackage    cake.cake.libs.log
 * @since         CakePHP(tm) v 1.3
 * @license       MIT License (http://www.opensource.org/licenses/mit-license.php)
 */
if (!class_exists(''File'')) {
    require LIBS . ''file.php'';
}
/**
 * File Storage stream for Logging.  Writes logs to different files
 * based on the type of log it is.
 *
 * @package cake
 * @subpackage cake.cake.libs.log
 */
class FileLog {

/**
 * Path to save log files on.
 *
 * @var string
 */
    var $_path = null;

/**
 * Constructs a new File Logger.
 * 
 * Options
 *
 * - `path` the path to save logs on.
 *
 * @param array $options Options for the FileLog, see above.
 * @return void
 */
    function FileLog($options = array()) {
        $options += array(''path'' => LOGS);
        $this->_path = $options[''path''];
    }

/**
 * Implements writing to log files.
 *
 * @param string $type The type of log you are making.
 * @param string $message The message you want to log.
 * @return boolean success of write.
 */
    function write($type, $message) {
        $debugTypes = array(''notice'', ''info'', ''debug'');

        if ($type == ''error'' || $type == ''warning'') {
            $filename = $this->_path  . ''error.log'';
        } elseif (in_array($type, $debugTypes)) {
            $filename = $this->_path . ''debug.log'';
        } else {
            $filename = $this->_path . $type . ''.log'';
        }
        $output = date(''Y-m-d H:i:s'') . '' '' . ucfirst($type) . '': '' . $message . "/n";
        $log = new File($filename, true);
        if ($log->writable()) {
            return $log->append($output);
        }
    }
}

Answer 1

Ok, esta vez me enfoqué mejor y aquí hay un posible problema / solución:

¿Puedes publicar este archivo también? /var/www/html/myproject/cake/libs/log/file_log.php ya que parece que el error ocurre aquí y no en AES.php:

Fatal error: Class declarations may not be nested in /var/www/html/myproject/cake/libs/log/file_log.php on line 30

Creo que Notice y Fatal Error son dos cosas diferentes que no deberían mezclarse. Hay un aviso sobre un valor entero demasiado grande (que se convierte en float) y otro error fatal sobre las clases de anidación dentro de cada uno.

Cómo deben usarse Aes y AesCtr:

Ambas Aes y AesCtr son clases totalmente estáticas por lo que no tiene sentido instanciarlas:

Cambio:

$aes = new AesCtr();
$decrypted = $aes->decrypt($encrypted, "mykey", 128); 

A:

$decrypted = AesCtr::decrypt($encrypted, "mykey", 128);

Sí, debería descartar $aes = new AesCtr(); ya que no es necesario cuando se llaman solo funciones estáticas.

Aquí hay un aviso, AES.php línea 230:

En AES.php en la línea 230 hay un número hexadecimal 0x100000000 que no es un entero de 32 bits firmado válido (de hecho, requiere al menos 33 bits, incluso si no está firmado), algunas versiones de PHP emitirán un error o aviso al respecto (mayormente ) Estoy usando PHP 5.3 y no notará nada incluso con error_reporting(E_ALL);

El valor máximo de entero con signo es 2147483647 o en hex 0x7FFFFFFF y AES.php intenta usar el valor de 4294967296 que se convierte en punto flotante.

Y, como language.types.integer.php dice: There is no integer division operator in PHP. por lo que el valor debe convertirse a flotar de todos modos.

Creo que el problema es que, como se indica en el mensaje de error, el Hex number is too big: 0x100000000 , ese php intenta usar ese valor hexadecimal como entero, pero es demasiado grande para que primero se convierta en flotante.

Algunas pruebas:

var_dump(0x100000000);
var_dump((int)0x100000000);

Salida en sistema de 32 bits:

float(4294967296)
int(0)

Y lo mismo con el sistema de 64 bits:

int(4294967296)
int(4294967296)

¿Cómo arreglarlo entonces?

Aquí hay una solución que puede funcionar o no:

Simplemente reemplace 0x100000000 con 4294967296.0 para que la línea 230 sea así:

for ($c=0; $c<4; $c++) $counterBlock[15-$c-4] = self::urs($b/4294967296.0, $c*8);

Tal vez también debería comprobar qué intenta hacer urs() y cómo intenta hacerlo. Sin embargo, ya debería esperar valores de coma flotante como argumentos, ver división de enteros .

Actualizar:

Comprueba que urs () parece esperar int como primer arg, sin embargo obtiene eso de la operación (x/y) que en PHP devuelve float si hay fracciones e int en caso contrario.

Para que vuelva a ser int es una conversión de tipo simple usando (int)(x/y) , no hay inconvenientes (o muy poco) en comparación con la forma anterior, esto es solo para convertirlo nuevamente.

Originalmente, antes de las modificaciones, existía la misma posibilidad y propagabilidad de la conversión a flotación que ahora ( urs() dice que la primera arg debe ser int) .

for ($c=0; $c<4; $c++) $counterBlock[15-$c-4] = self::urs((int)($b/4294967296.0), $c*8);

Actualización: file_log.php

Creo que no hay nada de malo con file_log.php , declara la class FileLog que se implementa correctamente y se cierra por lo que puedo ver.

Otra cosa sobre file_log.php es que parece que es la biblioteca interna de cakephp y está cargada por el framework cakephp. Y no sé nada sobre cakephp ...

Sin embargo, realmente debería probar su código sin AES.php o quizás intente incluir AES.php otra forma para comprobar si App::import() no funciona correctamente .

/* Remember to take into account that filenames are propably
 * case sensitive at server, but maybe case insensitive at
 * your workstation (if developing under windows). */

// If needed, change vendors/AES/AES.php to correct path:
require_once ''vendors/AES/AES.php'';
$decrypted = AesCtr::decrypt($encrypted, "mykey", 128);

o tal vez (del manual cakephp):

// Vendor not vendor and AES/AES not aes/AES or aes/aes just to be sure...
App::import(''Vendor'', ''AES/AES'');
$decrypted = AesCtr::decrypt($encrypted, "mykey", 128);

o tal vez soltarlo por completo:

$decrypted = ''dummytest'';

o tal vez incluir sin usarlo en absoluto:

App::import(''vendor'', ''aes'', array(''file'' => ''AES/AES.php''));
$decrypted = ''dummytest'';

en lugar de:

App::import(''vendor'', ''aes'', array(''file'' => ''AES/AES.php''));
$decrypted = AesCtr::decrypt($encrypted, "mykey", 128);

De esta forma el problema se reduce, si el mismo error sigue apareciendo, entonces el problema está en otra parte pero si el error desaparece después de esta prueba, entonces sabemos que el error está en App :: import () o en algún lugar en cakephp framework.

Answer 2

Empecé a tener este error después de una actualización de php. Cada vez que creé un nuevo php.ini , el error comenzó a aparecer. Traté de cambiar error_reporting , display_errors y otras configuraciones, y la clave del error fue la configuración short_open_tag. (Todavía uso bibliotecas antiguas sin una etiqueta abierta estricta, solo "

Entonces, la respuesta: establezca short_open_tag en "On" en php.ini, reinicie Apache y el error desaparezca.

FYI: me pasó después de actualizar a OSX Maverick

Answer 3

Una vez tuve este tipo de error porque añadí dos veces el nombre de un modelo, por ejemplo

class MyModel extends AppModel
{
 var $name =''MyModel'';
 ....
 var $name = ''Another Name'';
}

En general, es difícil encontrar la causa raíz del problema: a veces la causa puede ser en lugares distintos a los que podría sospechar. Por ejemplo, un error en el Modelo puede disparar ese tipo de error.