unserialize () [función.unserialize]: Error en el desplazamiento

No tengo suficiente reputación para comentar, así que espero que esto sea visto por las personas que usan la respuesta "correcta" anterior:

Desde php 5.5 el modificador /e en preg_replace() ha sido obsoleto completamente y el preg_match anterior se producirá un error. La documentación de php recomienda usar preg_match_callback en su lugar.

Por favor, encuentre la siguiente solución como alternativa a la anterior propuesta preg_match.

$fixed_data = preg_replace_callback ( '!s:(\d+):"(.*?)";!', function($match) {      
    return ($match[1] == strlen($match[2])) ? $match[0] : 's:' . strlen($match[2]) . ':"' . $match[2] . '";';
},$bad_data );

Hay otra razón por la que unserialize() falló porque puso incorrectamente datos serializados en la base de datos ver Explicación Oficial aquí. Dado que serialize() devuelve datos binarios y a las variables php no les importan los métodos de codificación, por lo que ponerlos en TEXTO, VARCHAR() causará este error.

Solución: almacene los datos serializados en BLOB en su tabla.

Solución rápida

Recalculando la longitud de los elementos en el array serializado - pero no use (preg_replace) está obsoleto - mejor use preg_replace_callback:

$data = preg_replace_callback('!s:(\d+):"(.*?)";!', function($m) { return 's:'.mb_strlen($m[2]).':"'.$m[2].'";'; }, $data);

Este error se debe a que su conjunto de caracteres es incorrecto.

Establecer charset después de abrir etiqueta:

header('Content-Type: text/html; charset=utf-8');

Y establecer charset utf8 en su base de datos :

mysql_query("SET NAMES 'utf8'");

Función pública unserializeKeySkills (string string) {

    $output = array();
    $string = trim(preg_replace('/\s\s+/', ' ',$string));
    $string = preg_replace_callback('!s:(\d+):"(.*?)";!', function($m) { return 's:'.strlen($m[2]).':"'.$m[2].'";'; }, utf8_encode( trim(preg_replace('/\s\s+/', ' ',$string)) ));
    try {
        $output =  unserialize($string);
    } catch (\Exception $e) {
        \Log::error("unserialize Data : " .print_r($string,true));
    }
    return $output;
}

Puede arreglar la cadena serializada rota usando la siguiente función, con el manejo del carácter multibyte.

function repairSerializeString($value)
{

    $regex = '/s:([0-9]+):"(.*?)"/';

    return preg_replace_callback(
        $regex, function($match) {
            return "s:".mb_strlen($match[2]).":\"".$match[2]."\""; 
        },
        $value
    );
}

$badData = 'a:2:{i:0;s:16:"as:45:"d";
Is \n";i:1;s:19:"as:45:"d";
Is \r\n";}';

No se puede arreglar una cadena de serialización rota usando las expresiones regulares propuestas:

$data = preg_replace('!s:(\d+):"(.*?)";!e', "'s:'.strlen('$2').':\"$2\";'", $badData);
var_dump(@unserialize($data)); // Output: bool(false)

// or

$data = preg_replace_callback(
    '/s:(\d+):"(.*?)";/',
    function($m){
        return 's:' . mb_strlen($m[2]) . ':"' . $m[2] . '";';
    },
    $badData
);
var_dump(@unserialize($data)); // Output: bool(false)

Puede arreglar la cadena serializada rota usando la siguiente expresión regular:

$data = preg_replace_callback(
    '/(?<=^|\{|;)s:(\d+):\"(.*?)\";(?=[asbdiO]\:\d|N;|\}|$)/s',
    function($m){
        return 's:' . mb_strlen($m[2]) . ':"' . $m[2] . '";';
    },
    $badData
);

var_dump(@unserialize($data));

Salida

array(2) {
  [0] =>
  string(17) "as:45:"d";
Is \n"
  [1] =>
  string(19) "as:45:"d";
Is \r\n"
}

O

array(2) {
  [0] =>
  string(16) "as:45:"d";
Is \n"
  [1] =>
  string(18) "as:45:"d";
Is \r\n"
}

Los documentos oficiales dicen que debe devolver false y establecer E_NOTICE

Pero ya que tiene error, el informe de errores está configurado para ser activado por E_NOTICE

Aquí hay una solución que le permite detectar false devuelto por unserialize

$old_err=error_reporting(); 
error_reporting($old_err & ~E_NOTICE);
$object = unserialize($serialized_data);
error_reporting($old_err);

Es posible que desee considerar el uso base64 codificar / decodificar

$string=base64_encode(serialize($obj));
unserialize(base64_decode($string));

En mi caso, estaba almacenando datos serializados en el campo BLOB de la base de datos MySQL que aparentemente no era lo suficientemente grande como para contener todo el valor y truncarlo. Obviamente, tal cadena no podía ser sin serializada.
Una vez convertido ese campo a MEDIUMBLOB el problema se disipó. También puede ser necesario cambiar las opciones de la tabla ROW_FORMAT a DYNAMIC o COMPRESSED.

Después de haber probado algunas cosas en esta página sin éxito, eché un vistazo a la fuente de la página y remarcé que todas las comillas en la cadena serializada han sido reemplazadas por entidades html. Decodificar estas entidades ayuda a evitar mucho dolor de cabeza:

$myVar = html_entity_decode($myVar);

Tendrá que cambiar el tipo de intercalación a utf8_unicode_ci y el problema se solucionará.

Otra razón de este problema puede ser el tipo de columna de la tabla de sesiones "payload". Si tiene grandes datos en la sesión, una columna de texto no sería suficiente. Necesitarás MEDIUMTEXT o incluso LONGTEXT.

Me enfrenté al mismo problema al no serializar datos. Descubrió que si hay un",',:, or ; en cualquiera de los valores de la matriz, la serialización se corrompe. Tenía un: en mi matriz, así que lo quité y se arregló.

Espero que ayude a alguien.