【PHP8.x】unserialize()関数の使い方

Copy
1<?php
2
3/**
4 * unserialize 関数を使用してデータを復元し、エラーハンドリングをデモンストレーションします。
5 *
6 * PHP 8 環境では、不正なシリアライズデータが入力された場合、unserialize は false を返し、
7 * E_NOTICE (または E_WARNING) が発生することがあります。
8 * したがって、関数の戻り値を適切にチェックし、エラー発生時に対処することが重要です。
9 *
10 * @param string $serializedData unserializeする文字列
11 * @return mixed unserializeされたデータ、またはエラーを通知する文字列
12 */
13function safeUnserialize(string $serializedData): mixed
14{
15    // @演算子を使用して、unserializeが発行する可能性のあるE_NOTICEやE_WARNINGを抑制します。
16    // その後、戻り値のfalseをチェックしてエラーを判定します。
17    $unserializedResult = @unserialize($serializedData);
18
19    // unserialize が false を返した場合にエラーと判定します。
20    // ただし、boolean型の false をシリアライズした 'b:0;' は正常な値なので、この場合はエラーとみなしません。
21    if ($unserializedResult === false && $serializedData !== 'b:0;') {
22        // エラー発生時の処理 (例: ログへの記録、ユーザーへの通知)
23        error_log("Unserialize error: Malformed or invalid data encountered. Input: " . substr($serializedData, 0, 100) . "...");
24        return "エラー: データの復元に失敗しました。不正なシリアライズデータが入力された可能性があります。";
25    }
26
27    return $unserializedResult;
28}
29
30// --- サンプルコードの実行 ---
31
32// 1. 正常なデータの例
33$validArray = ['id' => 1, 'name' => 'Alice', 'roles' => ['admin', 'user']];
34$serializedValidData = serialize($validArray);
35echo "--- 正常なデータの復元 ---\n";
36echo "シリアライズされたデータ: " . $serializedValidData . "\n";
37$restoredValidData = safeUnserialize($serializedValidData);
38if (is_string($restoredValidData)) {
39    echo $restoredValidData . "\n"; // エラーメッセージの場合
40} else {
41    echo "復元されたデータ: ";
42    print_r($restoredValidData);
43}
44echo "\n";
45
46// 2. 不正な形式のデータの例 (途中で途切れた文字列)
47$malformedString = 'a:2:{s:4:"name";s:5:"Alice";s:3:"age";i:30'; // 不完全なシリアライズデータ
48echo "--- 不正なデータの復元 (途中で途切れた文字列) ---\n";
49echo "シリアライズされたデータ: " . $malformedString . "\n";
50$restoredMalformedData = safeUnserialize($malformedString);
51if (is_string($restoredMalformedData)) {
52    echo $restoredMalformedData . "\n"; // エラーメッセージが返される
53} else {
54    echo "復元されたデータ: ";
55    print_r($restoredMalformedData);
56}
57echo "\n";
58
59// 3. 無効なクラスを参照するデータの例 (定義されていないクラス)
60// PHPは、不明なクラスを参照するシリアライズデータをunserializeしようとすると、
61// `__PHP_Incomplete_Class`オブジェクトを返すか、falseを返すことがあります。
62// この例ではfalseを返すケースを想定。
63$undefinedClassData = 'O:15:"UndefinedMyClass":2:{s:3:"foo";s:3:"bar";s:3:"baz";s:6:"quxphp";}';
64echo "--- 無効なクラスを参照するデータの復元 ---\n";
65echo "シリアライズされたデータ: " . $undefinedClassData . "\n";
66$restoredUndefinedClassData = safeUnserialize($undefinedClassData);
67if (is_string($restoredUndefinedClassData)) {
68    echo $restoredUndefinedClassData . "\n"; // エラーメッセージが返される
69} else {
70    echo "復元されたデータ: ";
71    print_r($restoredUndefinedClassData);
72}
73echo "\n";
74
75// 4. boolean `false` の正常なシリアライズデータ
76$serializedBooleanFalse = serialize(false); // これは 'b:0;' となる
77echo "--- 論理値 false の復元 ---\n";
78echo "シリアライズされたデータ: " . $serializedBooleanFalse . "\n";
79$restoredBooleanFalse = safeUnserialize($serializedBooleanFalse);
80if (is_string($restoredBooleanFalse)) {
81    echo $restoredBooleanFalse . "\n"; // エラーメッセージの場合
82} else {
83    echo "復元されたデータ (型を維持): ";
84    var_dump($restoredBooleanFalse); // false (boolean) が正常に復元される
85}
86echo "\n";
87
88?>

PHPのunserialize関数は、serialize関数によって文字列形式に変換（シリアライズ）されたデータを、元のPHPの値（配列、オブジェクト、数値など）に復元するために利用されます。引数$dataにはシリアライズされた文字列を指定し、戻り値として元のデータ型で復元された値が返されます。

PHP 8では、入力されたシリアライズデータが不正な形式であった場合、unserialize関数はfalseを返し、同時にE_NOTICEなどの警告を発することがあります。そのため、この関数の利用時には戻り値を適切にチェックし、エラー発生時に対処することが極めて重要です。

提供されたサンプルコードのsafeUnserialize関数は、このエラーハンドリングの例を示しています。この関数では、unserializeが発行する可能性のある警告を@演算子で抑制しつつ、戻り値がfalseである場合にエラーと判断しています。ただし、PHPで論理値のfalseをシリアライズすると'b:0;'という文字列になるため、この特定のケースは正常なデータとして扱い、それ以外のfalseが返された場合を不正なデータによるエラーと識別しています。これにより、途中で途切れた文字列や、定義されていないクラスを参照するデータのような不正な入力を安全に検出し、復元失敗のメッセージを返すことができる堅牢な処理が実現されています。

Copy
1<?php
2
3/**
4 * unserialize() function demonstration.
5 *
6 * This function illustrates how `unserialize` handles a numeric value
7 * that exceeds the maximum integer limit (PHP_INT_MAX) for the system.
8 * Instead of a classical integer overflow (where the value wraps around),
9 * PHP converts such a value to a floating-point number. This demonstrates
10 * a potential implicit type change that system engineers should be aware of
11 * when processing serialized data, especially from untrusted sources.
12 */
13function demonstrateUnserializeLargeNumberHandling(): void
14{
15    // Display the maximum integer value for the current PHP environment.
16    echo "System's PHP_INT_MAX: " . PHP_INT_MAX . "\n";
17    echo "System's integer size: " . (PHP_INT_SIZE * 8) . "-bit\n\n";
18
19    // --- Scenario 1: A number within PHP_INT_MAX ---
20    // We create a serialized string for an integer that is well within the system's limit.
21    $safeNumber = PHP_INT_MAX > 1000 ? PHP_INT_MAX - 100 : 100; // Ensure it's a reasonable safe number
22    $serializedSafeInt = 'i:' . $safeNumber . ';';
23
24    echo "Input (integer within limits): '" . $serializedSafeInt . "'\n";
25    $unserializedSafe = unserialize($serializedSafeInt);
26    echo "Unserialized value: " . $unserializedSafe . "\n";
27    echo "Output type: " . gettype($unserializedSafe) . "\n\n";
28
29    // --- Scenario 2: A number exceeding PHP_INT_MAX ---
30    // Craft a string representing a number that is guaranteed to be larger than PHP_INT_MAX.
31    // By appending '1' to the string representation of PHP_INT_MAX, we create such a number.
32    // Example: if PHP_INT_MAX is 9223372036854775807, this creates "92233720368547758071".
33    $overflowCandidateString = (string)PHP_INT_MAX . '1';
34
35    // We manually construct a serialized string using the 'i:' (integer) prefix
36    // even though the value itself exceeds the integer limit.
37    $serializedOverflowInt = 'i:' . $overflowCandidateString . ';';
38
39    echo "Input (integer string exceeding limits): '" . $serializedOverflowInt . "'\n";
40    $unserializedOverflow = unserialize($serializedOverflowInt);
41    echo "Unserialized value: " . $unserializedOverflow . "\n";
42    echo "Output type: " . gettype($unserializedOverflow) . "\n\n";
43
44    echo "Observation:\n";
45    echo "When the integer value in the serialized string ('i:...') exceeds PHP_INT_MAX,\n";
46    echo "PHP's `unserialize` function automatically converts it to a 'float' type.\n";
47    echo "This is PHP's mechanism to prevent a hard integer overflow for very large numbers.\n";
48    echo "System engineers should be aware of such implicit type conversions, as they\n";
49    echo "can lead to unexpected behavior if strict integer types are assumed.\n";
50}
51
52// Execute the demonstration function.
53demonstrateUnserializeLargeNumberHandling();

unserialize関数は、PHPのserialize関数などで文字列化（シリアライズ）されたデータを、元のPHPのデータ型と値に戻すための関数です。引数には復元したいシリアライズ済みのstringデータを指定し、オプションで挙動を変更するarrayを渡すこともできます。戻り値は復元されたmixed型の値となります。

このサンプルコードは、unserialize関数がPHPの最大整数値（PHP_INT_MAX）を超える数値をどのように扱うかを示しています。通常の整数範囲内の数値をシリアライズしてunserializeすると、期待通りint型として復元されます。しかし、シリアライズされたデータの中で整数型（i:プレフィックス）として表現されていても、その値がPHP_INT_MAXを超過している場合、unserialize関数はそれを自動的にfloat型へと変換して復元します。

これは、PHPが非常に大きな整数値を扱う際に、従来の整数オーバーフロー（値が一周する現象）を避け、精度は失われる可能性がありますが、より広い範囲の数値を保持するために浮動小数点数に型を変換する挙動です。システムエンジニアを目指す方々は、特に外部からのデータを処理する際に、このような暗黙の型変換が発生しうることを認識し、予期せぬ挙動やデータの不整合を防ぐための注意が必要です。

Copy
1<?php
2
3/**
4 * unserialize関数の基本的な使い方と、PHP 8におけるセキュリティオプションの例を示します。
5 * システムエンジニアを目指す初心者が、データのシリアライズとデシリアライズの概念、
6 * およびセキュリティ上の考慮事項を理解するのに役立ちます。
7 */
8function demonstrateUnserializeUsage(): void
9{
10    echo "--- unserialize関数の基本とセキュリティ対策 ---\n\n";
11
12    // ----------------------------------------------------
13    // 1. スカラ値と配列の基本的なシリアライズとデシリアライズ
14    // ----------------------------------------------------
15
16    // 元の配列データ
17    $originalData = [
18        'user_id' => 101,
19        'username' => 'sample_user',
20        'is_active' => true,
21        'preferences' => ['theme' => 'dark', 'lang' => 'ja'],
22    ];
23    echo "【元のデータ (配列)】:\n";
24    print_r($originalData);
25
26    // データをシリアライズ (文字列に変換)
27    $serializedString = serialize($originalData);
28    echo "\n【シリアライズされた文字列】:\n";
29    echo $serializedString . "\n";
30
31    // シリアライズされた文字列をデシリアライズ (元のデータに戻す)
32    $unserializedData = unserialize($serializedString);
33    echo "\n【デシリアライズされたデータ (配列)】:\n";
34    print_r($unserializedData);
35
36    echo "\n----------------------------------------\n\n";
37
38    // ----------------------------------------------------
39    // 2. オブジェクトのシリアライズとデシリアライズ (allowed_classesオプションの活用)
40    // ----------------------------------------------------
41
42    // デシリアライズ対象となり得るカスタムクラスを定義
43    class UserAccount
44    {
45        public int $id;
46        public string $name;
47        // protectedプロパティはシリアライズに含まれない (特定の目的がない限りprivate/protectedは避ける)
48        protected string $passwordHash;
49
50        public function __construct(int $id, string $name, string $password)
51        {
52            $this->id = $id;
53            $this->name = $name;
54            $this->passwordHash = password_hash($password, PASSWORD_DEFAULT);
55        }
56
57        public function getInfo(): string
58        {
59            return "ID: {$this->id}, Name: {$this->name}";
60        }
61    }
62
63    // 別に定義された、デシリアライズ時に想定されないクラス (セキュリティテスト用)
64    class SystemLogger
65    {
66        public string $logPath;
67
68        public function __construct(string $path)
69        {
70            $this->logPath = $path;
71        }
72    }
73
74    // UserAccountオブジェクトをシリアライズ
75    $userObject = new UserAccount(202, 'dev_admin', 'secure_pass_123');
76    echo "【元のオブジェクト (UserAccount)】:\n";
77    print_r($userObject);
78
79    $serializedUserObject = serialize($userObject);
80    echo "\n【シリアライズされたオブジェクト文字列】:\n";
81    echo $serializedUserObject . "\n";
82
83    echo "\n--- allowed_classesオプションによるセキュリティ対策 ---\n\n";
84
85    // (A) `allowed_classes`オプションを省略した場合 (PHP 8では`true`相当の挙動)
86    // 信頼できないデータからのオブジェクトデシリアライズはオブジェクトインジェクションのリスクがあるため、
87    // 明示的なオプション指定が強く推奨されます。
88    echo "【allowed_classesオプションなしでデシリアライズ (推奨されない)】:\n";
89    $unserializedNoOptions = unserialize($serializedUserObject);
90    if ($unserializedNoOptions instanceof UserAccount) {
91        echo "  -> 成功: " . $unserializedNoOptions->getInfo() . "\n";
92    } else {
93        echo "  -> 失敗、または不明なオブジェクト: " . get_class($unserializedNoOptions) . "\n";
94    }
95    echo "\n";
96
97    // (B) `allowed_classes`オプションで特定のクラスのみを許可してデシリアライズ (推奨)
98    // 許可されたクラスのみがインスタンス化されます。
99    echo "【allowed_classesを['UserAccount']に指定してデシリアライズ (推奨)】:\n";
100    $unserializedAllowed = unserialize($serializedUserObject, ['allowed_classes' => ['UserAccount']]);
101    if ($unserializedAllowed instanceof UserAccount) {
102        echo "  -> 成功: " . $unserializedAllowed->getInfo() . "\n";
103    } else {
104        echo "  -> 失敗、または不明なオブジェクト: " . get_class($unserializedAllowed) . "\n";
105    }
106    echo "\n";
107
108    // (C) `allowed_classes`オプションで許可されていないクラスを指定した場合
109    // 許可されていないクラスのオブジェクトは`__PHP_Incomplete_Class`として復元されます。
110    // このオブジェクトは、元のクラスのプロパティは持つものの、メソッドは呼び出せません。
111    echo "【allowed_classesを['SystemLogger'] (許可されていないクラス) に指定してデシリアライズ】:\n";
112    $unserializedDisallowed = unserialize($serializedUserObject, ['allowed_classes' => ['SystemLogger']]);
113    if ($unserializedDisallowed instanceof UserAccount) {
114        echo "  -> 成功: " . $unserializedDisallowed->getInfo() . "\n";
115    } else {
116        echo "  -> 失敗。復元された型: " . get_class($unserializedDisallowed) . "\n";
117        echo "     (__PHP_Incomplete_Classオブジェクトとして復元されました)\n";
118    }
119    echo "\n";
120
121    // (D) `allowed_classes`オプションを`false`に指定して、全てのオブジェクトのインスタンス化を禁止
122    // オブジェクトの復元を完全に避けたい場合に利用します。
123    echo "【allowed_classesをfalse (全てのオブジェクト禁止) に指定してデシリアライズ】:\n";
124    $unserializedNoObjects = unserialize($serializedUserObject, ['allowed_classes' => false]);
125    if (is_object($unserializedNoObjects)) {
126        echo "  -> 失敗。復元された型: " . get_class($unserializedNoObjects) . "\n";
127        echo "     (この場合も__PHP_Incomplete_Classオブジェクトになります)\n";
128    } else {
129        echo "  -> 成功 (オブジェクトではない型として): " . gettype($unserializedNoObjects) . "\n";
130    }
131}
132
133// サンプル関数を実行
134demonstrateUnserializeUsage();

PHP 8のunserialize関数は、serialize関数によって文字列化されたPHPの値を、元のデータ型（配列、オブジェクト、スカラ値など）に戻すために使用されます。第一引数$dataには、デシリアライズしたいシリアライズ済みの文字列を渡します。戻り値はmixed型で、元のデータがそのまま復元されますが、デシリアライズに失敗した場合はfalseを返します。

特に、外部からの信頼できないデータをデシリアライズする際には、セキュリティ上の注意が必要です。悪意のあるシリアライズデータがオブジェクトとして復元されることで、システムに脆弱性を生じさせる「オブジェクトインジェクション」という攻撃のリスクがあります。

PHP 8以降では、第二引数$optionsを使用してセキュリティ対策を強化できます。この引数に配列で['allowed_classes' => ...]を指定することで、デシリアライズを許可するクラスを厳密に制御できます。例えば、['allowed_classes' => ['UserAccount']]と指定すれば、UserAccountクラスのオブジェクトのみが復元され、それ以外のクラスは不完全なオブジェクトとして扱われます。また、['allowed_classes' => false]と指定することで、全てのオブジェクトのインスタンス化を完全に禁止することも可能です。システムセキュリティのため、信頼できないデータソースからのデシリアライズでは、このallowed_classesオプションを適切に利用することが強く推奨されます。

Copy
1<?php
2
3/**
4 * PHPのunserialize()関数が不正なデータに対してどのように振る舞い、
5 * 失敗時にfalseを返すかを示すサンプルコードです。
6 *
7 * unserialize()は、与えられた文字列が有効なシリアライズデータでない場合に、
8 * 復元に失敗し、bool(false)を返します。
9 * この挙動は、特にユーザー入力や外部システムからのデータを取り扱う際に、
10 * セキュリティと堅牢性を確保するために適切に処理する必要があります。
11 */
12function demonstrateUnserializeFailure(): void
13{
14    echo "--- unserialize() の失敗（falseを返すケース）のデモンストレーション ---\n\n";
15
16    // 1. 有効なシリアライズデータの場合
17    $originalData = ['id' => 101, 'name' => 'Sample Product', 'price' => 19.99];
18    $validSerializedData = serialize($originalData);
19
20    echo "【有効なデータ】\n";
21    echo "元のデータ: ";
22    var_dump($originalData);
23    echo "シリアライズされたデータ: " . $validSerializedData . "\n";
24
25    $unserializedResult = unserialize($validSerializedData);
26
27    if ($unserializedResult !== false) { // 厳密な比較 (=== false) が重要
28        echo "アンシリアライズ成功:\n";
29        var_dump($unserializedResult);
30    } else {
31        echo "エラー: 有効なデータのはずがアンシリアライズに失敗しました。\n";
32        var_dump($unserializedResult);
33    }
34    echo "\n------------------------------------------------\n\n";
35
36    // 2. 無効な（シリアライズされていない）文字列の場合
37    $invalidDataString = "これはシリアライズされた文字列ではありません。";
38
39    echo "【無効なデータ（シリアライズされていない文字列）】\n";
40    echo "アンシリアライズを試みるデータ: '" . $invalidDataString . "'\n";
41
42    // 無効な文字列をunserialize()すると、通常は失敗してfalseが返されます。
43    // PHPはE_NOTICEまたはE_WARNINGを発行する場合もあります。
44    $unserializedResult = unserialize($invalidDataString);
45
46    // unserialize()がfalseを返したかどうかを厳密にチェックします。
47    // (=== false) を使うのは、元のデータがブーリアンのfalseであった場合と区別するためです。
48    if ($unserializedResult === false) {
49        echo "アンシリアライズ失敗（期待通り）: unserialize() は false を返しました。\n";
50        echo "戻り値: ";
51        var_dump($unserializedResult); // false が出力される
52    } else {
53        echo "エラー: 無効なデータが予期せずアンシリアライズされました。\n";
54        echo "戻り値: ";
55        var_dump($unserializedResult);
56    }
57    echo "\n------------------------------------------------\n\n";
58
59    // 3. 部分的に破損したシリアライズデータの場合
60    // 有効なシリアライズデータの一部を切り取って破損させる
61    $corruptedSerializedData = substr($validSerializedData, 0, strlen($validSerializedData) - 5);
62
63    echo "【破損したシリアライズデータ】\n";
64    echo "アンシリアライズを試みるデータ: '" . $corruptedSerializedData . "'\n";
65
66    $unserializedResult = unserialize($corruptedSerializedData);
67
68    if ($unserializedResult === false) {
69        echo "アンシリアライズ失敗（期待通り）: unserialize() は false を返しました。\n";
70        echo "戻り値: ";
71        var_dump($unserializedResult); // false が出力される
72    } else {
73        echo "エラー: 破損したデータが予期せずアンシリアライズされました。\n";
74        echo "戻り値: ";
75        var_dump($unserializedResult);
76    }
77    echo "\n------------------------------------------------\n";
78}
79
80// デモンストレーション関数を実行
81demonstrateUnserializeFailure();

PHPのunserialize()関数は、serialize()関数によって文字列化されたPHPのデータ（配列やオブジェクトなど）を、元のデータ形式に復元するために利用されます。この関数は、最初の引数$dataにシリアライズされた文字列を受け取ります。復元が成功した場合、元のPHPのデータ（mixed型）が戻り値として返されます。

しかし、この関数は、渡された文字列が有効なシリアライズデータではない場合や、データが破損している場合には、データ復元に失敗します。その際、unserialize()関数はブーリアン値のfalseを戻り値として返します。

このサンプルコードは、unserialize()関数が不正なデータや破損した文字列に対してfalseを返す具体的な例を示しています。例えば、単なるテキスト文字列や、一部が欠けたシリアライズデータを処理しようとすると、期待通りfalseが返されることが確認できます。システム開発において、特にユーザー入力や外部システムからのデータを取り扱う際には、このfalseという戻り値を正確に（=== falseとして）チェックし、データの正当性を検証することが極めて重要です。これにより、不正なデータによる予期せぬ挙動を防ぎ、アプリケーションの堅牢性とセキュリティを確保することができます。