FalsifyTwlBackup:改ざん項目の追加。

Category 関数で書きだしたかどうかを返すようにした。

git-svn-id: file:///Volumes/Transfer/gigaleak_20231201/2020-09-30%20-%20paladin.7z/paladin/ctr_test_tools@41 6b0af911-cb57-b745-895f-eec5701120e1

TwlBkpCheck/Windows/FalsifyTwlBackup/Category1xx.cs

@@ -8,7 +8,7 @@ namespace FalsifyTwlBackup
 {
 partial class Program
 {
-    static void FalsifyingDataCategory1xx(int improperNo, Properties prop, byte[] improperData)
+    static bool FalsifyingDataCategory1xx(int improperNo, Properties prop, byte[] improperData)
     {
         Blocks blocksForFalsifying = (Blocks)prop.decryptedBlocks.Clone();
 
@@ -130,10 +130,51 @@ partial class Program
                 OutputFalsifiedData(improperNo, prop.outFolderPath, outData);
                 break;
 
+            // WPS Only : private セーブデータの前に不正なデータを入れる
+            case 119:
+                if (prop.bkpType == BkpType.WITH_PRIVATE_SAVE)
+                {
+                    outData = MergeEncryptBody(blocksForFalsifying, prop, improperData, FRONT_PRIVATE_SAVE, NC_MAC_AND_HASHSET);
+                    OutputFalsifiedData(improperNo, prop.outFolderPath, outData);
+                }
+                else
+                {
+                    return false;
+                }
+                break;
+
+            // WPS Only : private セーブデータの一部を不正なデータを差し替える
+            case 120:
+                if (prop.bkpType == BkpType.WITH_PRIVATE_SAVE)
+                {
+                    ReplaceImproperData(blocksForFalsifying[SECTION_PRIVATE_SAVE].body, improperData);
+                    outData = MergeEncryptBody(blocksForFalsifying, prop, improperData, NONE, NC_MAC_AND_HASHSET);
+                    OutputFalsifiedData(improperNo, prop.outFolderPath, outData);
+                }
+                else
+                {
+                    return false;
+                }
+                break;
+
+            // WPS Only : private セーブデータの後ろに不正なデータを入れる
+            case 121:
+                if (prop.bkpType == BkpType.WITH_PRIVATE_SAVE)
+                {
+                    outData = MergeEncryptBody(blocksForFalsifying, prop, improperData, REAR_PRIVATE_SAVE, NC_MAC_AND_HASHSET);
+                    OutputFalsifiedData(improperNo, prop.outFolderPath, outData);
+                }
+                else
+                {
+                    return false;
+                }
+                break;
+
             // ありえない
             default:
                 throw new InvalidOperationException();
         }
+        return true;
     }
 }
 }

TwlBkpCheck/Windows/FalsifyTwlBackup/Category2xx.cs

@@ -8,7 +8,7 @@ namespace FalsifyTwlBackup
 {
 partial class Program
 {
-    static void FalsifyingDataCategory2xx(int improperNo, Properties prop, byte[] improperData)
+    static bool FalsifyingDataCategory2xx(int improperNo, Properties prop, byte[] improperData)
     {
         Blocks blocksForFalsifying = (Blocks)prop.decryptedBlocks.Clone();
 
@@ -79,9 +79,19 @@ partial class Program
                 OutputFalsifiedData(improperNo, prop.outFolderPath, outData);
                 break;
 
-            // コンテンツ[0] の fileSize を変更
+            // コンテンツの fileSize を変更
             case 208:
+                if (prop.bkpType != BkpType.LEGACY)
+                {
+                    for (int i = 0; i < MAX_CONTENTS; i++)
+                    {
+                        header.fileSizes[(int)Utility.SectionIndex.CONTENT + i]++;
+                    }
+                }
+                else
+                {
                     header.fileSizes[(int)Utility.SectionIndex.CONTENT]++;
+                }
                 outData = MergeEncryptBody(blocksForFalsifying, prop, improperData, NONE, NC_MAC_AND_HASHSET);
                 OutputFalsifiedData(improperNo, prop.outFolderPath, outData);
                 break;
@@ -117,30 +127,91 @@ partial class Program
                 OutputFalsifiedData(improperNo, prop.outFolderPath, outData);
                 break;
 
+            // コンテンツ Index を変更
             case 212:
-                header.tmdReserved.publicSaveSize++;
+                if (prop.bkpType != BkpType.LEGACY)
+                {
+                    for (int i = 0; i < header.contentIndex.Length; i++)
+                    {
+                        header.contentIndex[i]++;
+                    }
+                }
+                else
+                {
+                    header.contentIndexForLegacy++;
+                }
                 outData = MergeEncryptBody(blocksForFalsifying, prop, improperData, NONE, NC_MAC_AND_HASHSET);
                 OutputFalsifiedData(improperNo, prop.outFolderPath, outData);
                 break;
 
             case 213:
+                header.tmdReserved.publicSaveSize++;
+                outData = MergeEncryptBody(blocksForFalsifying, prop, improperData, NONE, NC_MAC_AND_HASHSET);
+                OutputFalsifiedData(improperNo, prop.outFolderPath, outData);
+                break;
+
+            case 214:
                 header.tmdReserved.privateSaveSize++;
                 outData = MergeEncryptBody(blocksForFalsifying, prop, improperData, NONE, NC_MAC_AND_HASHSET);
                 OutputFalsifiedData(improperNo, prop.outFolderPath, outData);
                 break;
 
             // public save の fileSize, TMD Reserved の publicSaveSize を変更
-            case 214:
+            case 215:
                 header.fileSizes[prop.indexPublicSave]++;
                 header.tmdReserved.publicSaveSize++;
                 outData = MergeEncryptBody(blocksForFalsifying, prop, improperData, NONE, NC_MAC_AND_HASHSET);
                 OutputFalsifiedData(improperNo, prop.outFolderPath, outData);
                 break;
 
+            // Normal, WPS Only : headerVersion を変更
+            case 216 :
+                if (prop.bkpType != BkpType.LEGACY)
+                {
+                    header.headerVersion++;
+                    outData = MergeEncryptBody(blocksForFalsifying, prop, improperData, NONE, NC_MAC_AND_HASHSET);
+                    OutputFalsifiedData(improperNo, prop.outFolderPath, outData);
+                }
+                else
+                {
+                    return false;
+                }
+                break;
+
+            // WPS Only : ヘッダの privateSaveSize を変更
+            case 217 :
+                if (prop.bkpType == BkpType.WITH_PRIVATE_SAVE)
+                {
+                    header.privateSaveForWPS++;
+                    outData = MergeEncryptBody(blocksForFalsifying, prop, improperData, NONE, NC_MAC_AND_HASHSET);
+                    OutputFalsifiedData(improperNo, prop.outFolderPath, outData);
+                }
+                else
+                {
+                    return false;
+                }
+                break;
+
+            // WPS Only : ヘッダの privateSaveSize, TMD Reserved の privateSaveSize を変更
+            case 218 :
+                if (prop.bkpType == BkpType.WITH_PRIVATE_SAVE)
+                {
+                    header.privateSaveForWPS++;
+                    header.tmdReserved.privateSaveSize++;
+                    outData = MergeEncryptBody(blocksForFalsifying, prop, improperData, NONE, NC_MAC_AND_HASHSET);
+                    OutputFalsifiedData(improperNo, prop.outFolderPath, outData);
+                }
+                else
+                {
+                    return false;
+                }
+                break;
+
             // ありえない
             default:
                 throw new InvalidOperationException();
         }
+        return true;
     }
 }
 }

TwlBkpCheck/Windows/FalsifyTwlBackup/Category3xx.cs

@@ -8,7 +8,7 @@ namespace FalsifyTwlBackup
 {
 partial class Program
 {
-    static void FalsifyingDataCategory3xx(int improperNo, Properties prop, byte[] improperData)
+    static bool FalsifyingDataCategory3xx(int improperNo, Properties prop, byte[] improperData)
     {
         Blocks blocksForFalsifying = (Blocks)prop.decryptedBlocks.Clone();
 
@@ -60,6 +60,7 @@ partial class Program
             default:
                 throw new InvalidOperationException();
         }
+        return true;
     }
 }
 }

TwlBkpCheck/Windows/FalsifyTwlBackup/Category4xx.cs

@@ -8,7 +8,7 @@ namespace FalsifyTwlBackup
 {
 partial class Program
 {
-    static void FalsifyingDataCategory4xx(int improperNo, Properties prop, byte[] improperData)
+    static bool FalsifyingDataCategory4xx(int improperNo, Properties prop, byte[] improperData)
     {
         Blocks blocksForFalsifying = (Blocks)prop.decryptedBlocks.Clone();
 
@@ -110,7 +110,7 @@ partial class Program
                 OutputFalsifiedData(improperNo, prop.outFolderPath, outData);
                 break;
 
-            // public save の fileSize, TMD Reserved の publicSave を変更し、public save の前にデータを入れる
+            // public save の fileSize, TMD Reserved の publicSaveSize を変更し、public save の前にデータを入れる
             case 412:
                 header.fileSizes[prop.indexPublicSave] += IMPROPER_DATA_SIZE;
                 header.tmdReserved.publicSaveSize += IMPROPER_DATA_SIZE;
@@ -118,7 +118,7 @@ partial class Program
                 OutputFalsifiedData(improperNo, prop.outFolderPath, outData);
                 break;
 
-            // public save の fileSize, TMD Reserved の publicSave を変更し、public save の後ろにデータを入れる
+            // public save の fileSize, TMD Reserved の publicSaveSize を変更し、public save の後ろにデータを入れる
             case 413:
                 header.fileSizes[prop.indexPublicSave] += IMPROPER_DATA_SIZE;
                 header.tmdReserved.publicSaveSize += IMPROPER_DATA_SIZE;
@@ -126,22 +126,97 @@ partial class Program
                 OutputFalsifiedData(improperNo, prop.outFolderPath, outData);
                 break;
 
+            // WPS Only : private save の fileSize を変更し、private save の前にデータを入れる
             case 414:
-                header.tmdReserved.privateSaveSize += IMPROPER_DATA_SIZE;
-                outData = MergeEncryptBody(blocksForFalsifying, prop, improperData, FRONT_PUBLIC_SAVE, NC_MAC_AND_HASHSET);
+                if (prop.bkpType == BkpType.WITH_PRIVATE_SAVE)
+                {
+                    header.privateSaveForWPS += IMPROPER_DATA_SIZE;
+                    outData = MergeEncryptBody(blocksForFalsifying, prop, improperData, FRONT_PRIVATE_SAVE, NC_MAC_AND_HASHSET);
                     OutputFalsifiedData(improperNo, prop.outFolderPath, outData);
+                }
+                else
+                {
+                    return false;
+                }
                 break;
 
+            // WPS Only : private save の fileSize を変更し、private save の後ろにデータを入れる
             case 415:
-                header.tmdReserved.privateSaveSize += IMPROPER_DATA_SIZE;
-                outData = MergeEncryptBody(blocksForFalsifying, prop, improperData, REAR_PUBLIC_SAVE, NC_MAC_AND_HASHSET);
+                if (prop.bkpType == BkpType.WITH_PRIVATE_SAVE)
+                {
+                    header.privateSaveForWPS += IMPROPER_DATA_SIZE;
+                    outData = MergeEncryptBody(blocksForFalsifying, prop, improperData, REAR_PRIVATE_SAVE, NC_MAC_AND_HASHSET);
                     OutputFalsifiedData(improperNo, prop.outFolderPath, outData);
+                }
+                else
+                {
+                    return false;
+                }
+                break;
+
+            // WPS Only : TMD Reserved の privateSaveSize を大きくした上で、private セーブデータの前に不正なデータを入れる
+            case 416:
+                if (prop.bkpType == BkpType.WITH_PRIVATE_SAVE)
+                {
+                    header.tmdReserved.privateSaveSize += IMPROPER_DATA_SIZE;
+                    outData = MergeEncryptBody(blocksForFalsifying, prop, improperData, FRONT_PRIVATE_SAVE, NC_MAC_AND_HASHSET);
+                    OutputFalsifiedData(improperNo, prop.outFolderPath, outData);
+                }
+                else
+                {
+                    return false;
+                }
+                break;
+
+            // WPS Only : TMD Reserved の privateSaveSize を大きくした上で、private セーブデータの後ろに不正なデータを入れる
+            case 417:
+                if (prop.bkpType == BkpType.WITH_PRIVATE_SAVE)
+                {
+                    header.tmdReserved.privateSaveSize += IMPROPER_DATA_SIZE;
+                    outData = MergeEncryptBody(blocksForFalsifying, prop, improperData, REAR_PRIVATE_SAVE, NC_MAC_AND_HASHSET);
+                    OutputFalsifiedData(improperNo, prop.outFolderPath, outData);
+                }
+                else
+                {
+                    return false;
+                }
+                break;
+
+            // WPS Only : ヘッダの privateSaveSize, TMD Reserved の privateSaveSize を変更し、private save の前にデータを入れる
+            case 418:
+                if (prop.bkpType == BkpType.WITH_PRIVATE_SAVE)
+                {
+                    header.privateSaveForWPS += IMPROPER_DATA_SIZE;
+                    header.tmdReserved.privateSaveSize += IMPROPER_DATA_SIZE;
+                    outData = MergeEncryptBody(blocksForFalsifying, prop, improperData, FRONT_PRIVATE_SAVE, NC_MAC_AND_HASHSET);
+                    OutputFalsifiedData(improperNo, prop.outFolderPath, outData);
+                }
+                else
+                {
+                    return false;
+                }
+                break;
+
+            // WPS Only : ヘッダの privateSaveSize, TMD Reserved の privateSaveSize を変更し、private save の後ろにデータを入れる
+            case 419:
+                if (prop.bkpType == BkpType.WITH_PRIVATE_SAVE)
+                {
+                    header.privateSaveForWPS += IMPROPER_DATA_SIZE;
+                    header.tmdReserved.privateSaveSize += IMPROPER_DATA_SIZE;
+                    outData = MergeEncryptBody(blocksForFalsifying, prop, improperData, REAR_PRIVATE_SAVE, NC_MAC_AND_HASHSET);
+                    OutputFalsifiedData(improperNo, prop.outFolderPath, outData);
+                }
+                else
+                {
+                    return false;
+                }
                 break;
 
             // ありえない
             default:
                 throw new InvalidOperationException();
         }
+        return true;
     }
 }
 }

TwlBkpCheck/Windows/FalsifyTwlBackup/Category5xx.cs

@@ -8,7 +8,7 @@ namespace FalsifyTwlBackup
 {
 partial class Program
 {
-    static void FalsifyingDataCategory5xx(int improperNo, Properties prop, byte[] improperData)
+    static bool FalsifyingDataCategory5xx(int improperNo, Properties prop, byte[] improperData)
     {
         Blocks blocksForFalsifying = (Blocks)prop.decryptedBlocks.Clone();
 
@@ -118,7 +118,7 @@ partial class Program
                 OutputFalsifiedData(improperNo, prop.outFolderPath, outData);
                 break;
 
-            // public save の fileSize, TMD Reserved の publicSave を変更し、public save の前にデータを入れる
+            // public save の fileSize, TMD Reserved の publicSaveSize を変更し、public save の前にデータを入れる
             // public save ブロックの MAC を更新し、署名ブロック内ハッシュも更新する
             case 512:
                 header.fileSizes[prop.indexPublicSave] += IMPROPER_DATA_SIZE;
@@ -127,7 +127,7 @@ partial class Program
                 OutputFalsifiedData(improperNo, prop.outFolderPath, outData);
                 break;
 
-            // public save の fileSize, TMD Reserved の publicSave を変更し、public save の後ろにデータを入れる
+            // public save の fileSize, TMD Reserved の publicSaveSize を変更し、public save の後ろにデータを入れる
             // public save ブロックの MAC を更新し、署名ブロック内ハッシュも更新する
             case 513:
                 header.fileSizes[prop.indexPublicSave] += IMPROPER_DATA_SIZE;
@@ -136,22 +136,103 @@ partial class Program
                 OutputFalsifiedData(improperNo, prop.outFolderPath, outData);
                 break;
 
+            // WPS Only : private save の fileSize を変更し、private save の前にデータを入れる
+            // private save ブロックの MAC を更新し、署名ブロック内ハッシュも更新する
             case 514:
-                header.tmdReserved.privateSaveSize += IMPROPER_DATA_SIZE;
-                outData = MergeEncryptBody(blocksForFalsifying, prop, improperData, FRONT_PUBLIC_SAVE, CHG_MAC_AND_HASHSET);
+                if (prop.bkpType == BkpType.WITH_PRIVATE_SAVE)
+                {
+                    header.privateSaveForWPS += IMPROPER_DATA_SIZE;
+                    outData = MergeEncryptBody(blocksForFalsifying, prop, improperData, FRONT_PRIVATE_SAVE, CHG_MAC_AND_HASHSET);
                     OutputFalsifiedData(improperNo, prop.outFolderPath, outData);
+                }
+                else
+                {
+                    return false;
+                }
                 break;
 
+            // WPS Only : private save の fileSize を変更し、private save の後ろにデータを入れる
+            // private save ブロックの MAC を更新し、署名ブロック内ハッシュも更新する
             case 515:
-                header.tmdReserved.privateSaveSize += IMPROPER_DATA_SIZE;
-                outData = MergeEncryptBody(blocksForFalsifying, prop, improperData, REAR_PUBLIC_SAVE, CHG_MAC_AND_HASHSET);
+                if (prop.bkpType == BkpType.WITH_PRIVATE_SAVE)
+                {
+                    header.privateSaveForWPS += IMPROPER_DATA_SIZE;
+                    outData = MergeEncryptBody(blocksForFalsifying, prop, improperData, REAR_PRIVATE_SAVE, CHG_MAC_AND_HASHSET);
                     OutputFalsifiedData(improperNo, prop.outFolderPath, outData);
+                }
+                else
+                {
+                    return false;
+                }
+                break;
+
+            // WPS Only : TMD Reserved の privateSaveSize を大きくした上で、private セーブデータの前に不正なデータを入れる
+            // private save ブロックの MAC を更新し、署名ブロック内ハッシュも更新する
+            case 516:
+                if (prop.bkpType == BkpType.WITH_PRIVATE_SAVE)
+                {
+                    header.tmdReserved.privateSaveSize += IMPROPER_DATA_SIZE;
+                    outData = MergeEncryptBody(blocksForFalsifying, prop, improperData, FRONT_PRIVATE_SAVE, CHG_MAC_AND_HASHSET);
+                    OutputFalsifiedData(improperNo, prop.outFolderPath, outData);
+                }
+                else
+                {
+                    return false;
+                }
+                break;
+
+            // WPS Only : TMD Reserved の privateSaveSize を大きくした上で、private セーブデータの後ろに不正なデータを入れる
+            // private save ブロックの MAC を更新し、署名ブロック内ハッシュも更新する
+            case 517:
+                if (prop.bkpType == BkpType.WITH_PRIVATE_SAVE)
+                {
+                    header.tmdReserved.privateSaveSize += IMPROPER_DATA_SIZE;
+                    outData = MergeEncryptBody(blocksForFalsifying, prop, improperData, REAR_PRIVATE_SAVE, CHG_MAC_AND_HASHSET);
+                    OutputFalsifiedData(improperNo, prop.outFolderPath, outData);
+                }
+                else
+                {
+                    return false;
+                }
+                break;
+
+            // WPS Only : ヘッダの privateSaveSize, TMD Reserved の privateSaveSize を変更し、private save の前にデータを入れる
+            // private save ブロックの MAC を更新し、署名ブロック内ハッシュも更新する
+            case 518:
+                if (prop.bkpType == BkpType.WITH_PRIVATE_SAVE)
+                {
+                    header.privateSaveForWPS += IMPROPER_DATA_SIZE;
+                    header.tmdReserved.privateSaveSize += IMPROPER_DATA_SIZE;
+                    outData = MergeEncryptBody(blocksForFalsifying, prop, improperData, FRONT_PRIVATE_SAVE, CHG_MAC_AND_HASHSET);
+                    OutputFalsifiedData(improperNo, prop.outFolderPath, outData);
+                }
+                else
+                {
+                    return false;
+                }
+                break;
+
+            // WPS Only : ヘッダの privateSaveSize, TMD Reserved の privateSaveSize を変更し、private save の後ろにデータを入れる
+            // private save ブロックの MAC を更新し、署名ブロック内ハッシュも更新する
+            case 519:
+                if (prop.bkpType == BkpType.WITH_PRIVATE_SAVE)
+                {
+                    header.privateSaveForWPS += IMPROPER_DATA_SIZE;
+                    header.tmdReserved.privateSaveSize += IMPROPER_DATA_SIZE;
+                    outData = MergeEncryptBody(blocksForFalsifying, prop, improperData, REAR_PRIVATE_SAVE, CHG_MAC_AND_HASHSET);
+                    OutputFalsifiedData(improperNo, prop.outFolderPath, outData);
+                }
+                else
+                {
+                    return false;
+                }
                 break;
 
             // ありえない
             default:
                 throw new InvalidOperationException();
         }
+        return true;
     }
 }
 }

TwlBkpCheck/Windows/FalsifyTwlBackup/Category9xx.cs

@@ -8,7 +8,7 @@ namespace FalsifyTwlBackup
 {
 partial class Program
 {
-    static void FalsifyingDataCategory9xx(int improperNo, Properties prop, byte[] improperData)
+    static bool FalsifyingDataCategory9xx(int improperNo, Properties prop, byte[] improperData)
     {
         Blocks blocksForFalsifying = (Blocks)prop.decryptedBlocks.Clone();
 
@@ -33,6 +33,7 @@ partial class Program
             default:
                 throw new InvalidOperationException();
         }
+        return true;
     }
 }
 }

TwlBkpCheck/Windows/FalsifyTwlBackup/Falsify.cs

@@ -171,7 +171,7 @@ partial class Program
         byte[] encryptedBlock = new byte[0];
 
         // (データ本体の前に不正データ挿入)
-        if (insertPos >= FRONT_BANNER && insertPos <= FRONT_SUB_BANNER)
+        if (insertPos >= FRONT_BANNER && insertPos <= FRONT_PRIVATE_SAVE)
         {
             if (section == insertPos - FRONT_BANNER)
             {
@@ -183,7 +183,7 @@ partial class Program
         encryptedBlock = MergeByteArray(encryptedBlock, dataBlocks[section].body.GetBytes()); // bodyを暗号化
 
         // (データ本体の後に不正データ挿入)
-        if (insertPos >= REAR_BANNER && insertPos <= REAR_SUB_BANNER)
+        if (insertPos >= REAR_BANNER && insertPos <= REAR_PRIVATE_SAVE)
         {
             if (section == insertPos - REAR_BANNER)
             {
@@ -203,10 +203,20 @@ partial class Program
         encryptedBlock = MergeByteArray(encryptedBlock, dataBlocks[section].iv); // IVを結合
 
         // (データブロックの後に不正データ挿入)
+        if (prop.bkpType != BkpType.WITH_PRIVATE_SAVE)
+        {
             if (section == SECTION_SUB_BANNER && insertPos == REAR_DATA)
             {
                 encryptedBlock = MergeByteArray(encryptedBlock, impData);
             }
+        }
+        else
+        {
+            if (section == SECTION_PRIVATE_SAVE && insertPos == REAR_DATA)
+            {
+                encryptedBlock = MergeByteArray(encryptedBlock, impData);
+            }
+        }
 
         return encryptedBlock;
     }
@@ -296,31 +306,32 @@ partial class Program
     /// <param name="improperNo"></param>
     /// <param name="prop"></param>
     /// <param name="improperData"></param>
-    static void FalsifyingData(int improperNo, Properties prop, byte[] improperData)
+    /// <returns>改ざんファイルを生成したかどうか</returns>
+    static bool FalsifyingData(int improperNo, Properties prop, byte[] improperData)
     {
         if (MIN_OF_CAT100 <= improperNo && improperNo <= MAX_OF_CAT100)
         {
-            FalsifyingDataCategory1xx(improperNo, prop, improperData);
+            return FalsifyingDataCategory1xx(improperNo, prop, improperData);
         }
         else if (MIN_OF_CAT200 <= improperNo && improperNo <= MAX_OF_CAT200)
         {
-            FalsifyingDataCategory2xx(improperNo, prop, improperData);
+            return FalsifyingDataCategory2xx(improperNo, prop, improperData);
         }
         else if (MIN_OF_CAT300 <= improperNo && improperNo <= MAX_OF_CAT300)
         {
-            FalsifyingDataCategory3xx(improperNo, prop, improperData);
+            return FalsifyingDataCategory3xx(improperNo, prop, improperData);
         }
         else if (MIN_OF_CAT400 <= improperNo && improperNo <= MAX_OF_CAT400)
         {
-            FalsifyingDataCategory4xx(improperNo, prop, improperData);
+            return FalsifyingDataCategory4xx(improperNo, prop, improperData);
         }
         else if (MIN_OF_CAT500 <= improperNo && improperNo <= MAX_OF_CAT500)
         {
-            FalsifyingDataCategory5xx(improperNo, prop, improperData);
+            return FalsifyingDataCategory5xx(improperNo, prop, improperData);
         }
         else
         {
-            FalsifyingDataCategory9xx(improperNo, prop, improperData);
+            return FalsifyingDataCategory9xx(improperNo, prop, improperData);
         }
     }
 
@@ -349,9 +360,11 @@ partial class Program
                 {
                     for (int j = NUM_OF_PATTERN[i, 0]; j <= NUM_OF_PATTERN[i, 1]; j++)
                     {
-                        FalsifyingData(j, prop, improperData);
+                        if (FalsifyingData(j, prop, improperData))
+                        {
                             Console.WriteLine("  Complete falsifying No.{0}.", j);
                         }
+                    }
                     Console.WriteLine("   Complete falsifying Cat.{0}.\n", NUM_OF_PATTERN[i, 0]);
                 }
                 break;
@@ -360,9 +373,11 @@ partial class Program
                 Console.WriteLine(" Falsifying category No.{0}.", NUM_OF_PATTERN[MODE_CAT100 - 1, 0]);
                 for (int i = 100; i <= MAX_OF_CAT100; i++)
                 {
-                    FalsifyingData(i, prop, improperData);
+                    if (FalsifyingData(i, prop, improperData))
+                    {
                         Console.WriteLine("  Complete falsifying No.{0}.", i);
                     }
+                }
                 Console.WriteLine("   Complete falsifying Cat.{0}.\n", NUM_OF_PATTERN[MODE_CAT100 - 1, 0]);
                 break;
 
@@ -370,9 +385,11 @@ partial class Program
                 Console.WriteLine(" Falsifying category No.{0}.", NUM_OF_PATTERN[MODE_CAT200 - 1, 0]);
                 for (int i = 200; i <= MAX_OF_CAT200; i++)
                 {
-                    FalsifyingData(i, prop, improperData);
+                    if (FalsifyingData(i, prop, improperData))
+                    {
                         Console.WriteLine("  Complete falsifying No.{0}.", i);
                     }
+                }
                 Console.WriteLine("   Complete falsifying Cat.{0}.\n", NUM_OF_PATTERN[MODE_CAT200 - 1, 0]);
                 break;
 
@@ -380,9 +397,11 @@ partial class Program
                 Console.WriteLine(" Falsifying category No.{0}.", NUM_OF_PATTERN[MODE_CAT300 - 1, 0]);
                 for (int i = 300; i <= MAX_OF_CAT300; i++)
                 {
-                    FalsifyingData(i, prop, improperData);
+                    if (FalsifyingData(i, prop, improperData))
+                    {
                         Console.WriteLine("  Complete falsifying No.{0}.", i);
                     }
+                }
                 Console.WriteLine("   Complete falsifying Cat.{0}.\n", NUM_OF_PATTERN[MODE_CAT300 - 1, 0]);
                 break;
 
@@ -390,9 +409,11 @@ partial class Program
                 Console.WriteLine(" Falsifying category No.{0}.", NUM_OF_PATTERN[MODE_CAT400 - 1, 0]);
                 for (int i = 400; i <= MAX_OF_CAT400; i++)
                 {
-                    FalsifyingData(i, prop, improperData);
+                    if (FalsifyingData(i, prop, improperData))
+                    {
                         Console.WriteLine("  Complete falsifying No.{0}.", i);
                     }
+                }
                 Console.WriteLine("   Complete falsifying Cat.{0}.\n", NUM_OF_PATTERN[MODE_CAT400 - 1, 0]);
                 break;
 
@@ -400,16 +421,24 @@ partial class Program
                 Console.WriteLine(" Falsifying category No.{0}.", NUM_OF_PATTERN[MODE_CAT500 - 1, 0]);
                 for (int i = 500; i <= MAX_OF_CAT500; i++)
                 {
-                    FalsifyingData(i, prop, improperData);
+                    if (FalsifyingData(i, prop, improperData))
+                    {
                         Console.WriteLine("  Complete falsifying No.{0}.", i);
                     }
+                }
                 Console.WriteLine("   Complete falsifying Cat.{0}.\n", NUM_OF_PATTERN[MODE_CAT500 - 1, 0]);
                 break;
 
             default: // １パターンのみを個別指定
                 Console.WriteLine(" Falsifying pattern No.{0}.", falsifyingMode);
-                FalsifyingData(falsifyingMode, prop, improperData);
+                if (FalsifyingData(falsifyingMode, prop, improperData))
+                {
                     Console.WriteLine("  Complete falsifying No.{0}.\n", falsifyingMode);
+                }
+                else
+                {
+                    Console.WriteLine("  No.{0} isn't support by specified type.\n", falsifyingMode);
+                }                   
                 break;
         }
     }

TwlBkpCheck/Windows/FalsifyTwlBackup/main.cs

@@ -34,6 +34,7 @@ partial class Program
     private const int FRONT_CONTENT = 104;
     private const int FRONT_PUBLIC_SAVE = FRONT_CONTENT + MAX_CONTENTS;
     private const int FRONT_SUB_BANNER = FRONT_PUBLIC_SAVE + 1;
+    private const int FRONT_PRIVATE_SAVE = FRONT_SUB_BANNER + 1;
 
     private const int REAR_BANNER = 200; // ブロック内データ本体の後
     private const int REAR_HEADER = 201;
@@ -42,6 +43,7 @@ partial class Program
     private const int REAR_CONTENT = 204;
     private const int REAR_PUBLIC_SAVE = REAR_CONTENT + MAX_CONTENTS;
     private const int REAR_SUB_BANNER = REAR_PUBLIC_SAVE + 1;
+    private const int REAR_PRIVATE_SAVE = REAR_SUB_BANNER + 1;
 
     private const int REAR_DATA = 99; // データ全体の後
 
@@ -62,11 +64,11 @@ partial class Program
     private const int MIN_OF_CAT500 = 500;
 
     // 各カテゴリでの最大番号
-    private const int MAX_OF_CAT100 = 118;
-    private const int MAX_OF_CAT200 = 214;
+    private const int MAX_OF_CAT100 = 121;
+    private const int MAX_OF_CAT200 = 218;
     private const int MAX_OF_CAT300 = 303;
-    private const int MAX_OF_CAT400 = 415;
-    private const int MAX_OF_CAT500 = 515;
+    private const int MAX_OF_CAT400 = 419;
+    private const int MAX_OF_CAT500 = 519;
 
     private static readonly int[,] NUM_OF_PATTERN = new int[,]
     {
@@ -97,7 +99,8 @@ partial class Program
         Console.WriteLine("./FalsifyingTwlBackup.exe BACKUP_FILE ENC_KEY_FILE MAC_KEY_FILE [-mode MODE] [-type TYPE]");
         Console.WriteLine("  BACKUP_FILE  : *.bin");
         Console.WriteLine("  ENC_KEY_FILE : *.txt");
-        Console.WriteLine("  MAC_KEY_FILE : *.txt\n");
+        Console.WriteLine("  MAC_KEY_FILE : *.txt");
+        Console.WriteLine();
         Console.WriteLine("  MODE");
         Console.WriteLine("   all (default) : output all falsifying pattern");
         Console.WriteLine("   cat:CAT_NUM   : output all pattern of CAT_NUM category");
@@ -105,6 +108,12 @@ partial class Program
         Console.WriteLine("   each:PAT_NUM  : output PAT_NUM pattern");
         Console.WriteLine("                     ex) -mode each:204 -> falsifying 204 only");
         Console.WriteLine("   verify        : verify backup file");
+        Console.WriteLine();
+        Console.WriteLine("  TYPE");
+        Console.WriteLine("   normal (default) : normal bkp type");
+        Console.WriteLine("   wps              : bkp with private save type");
+        Console.WriteLine("   legacy           : legacy bkp type");
+
         Environment.Exit(-1);
     }