Handle empty PDisk's mainKey correctly, KIKIMR-19578

Handle empty main key properly

21 files changed, 120 insertions, 73 deletions

diff --git a/ydb/core/blobstorage/backpressure/queue_backpressure_client_ut.cpp b/ydb/core/blobstorage/backpressure/queue_backpressure_client_ut.cpp
index 164d2bf172..f207e730a0 100644
--- a/ydb/core/blobstorage/backpressure/queue_backpressure_client_ut.cpp
+++ b/ydb/core/blobstorage/backpressure/queue_backpressure_client_ut.cpp
@@ -161,8 +161,8 @@ public:
         DiskSize = SectorMap->DeviceSize;
         PDiskGuid = 1;
         PDiskKey = 1;
-        MainKey = {1};
-        FormatPDisk(Path, DiskSize, 4096, ChunkSize, PDiskGuid, PDiskKey, PDiskKey, PDiskKey, MainKey.back(), "queue_test",
+        MainKey = NPDisk::TMainKey{ .Keys = { 1 } };
+        FormatPDisk(Path, DiskSize, 4096, ChunkSize, PDiskGuid, PDiskKey, PDiskKey, PDiskKey, MainKey.Keys.back(), "queue_test",
                 false, false, SectorMap, false);
 
         PDiskId = MakeBlobStoragePDiskID(1, 1);
diff --git a/ydb/core/blobstorage/dsproxy/ut_fat/dsproxy_ut.cpp b/ydb/core/blobstorage/dsproxy/ut_fat/dsproxy_ut.cpp
index 04fea4b01c..a374e6df87 100644
--- a/ydb/core/blobstorage/dsproxy/ut_fat/dsproxy_ut.cpp
+++ b/ydb/core/blobstorage/dsproxy/ut_fat/dsproxy_ut.cpp
@@ -4227,7 +4227,7 @@ public:
                 pDiskConfig->SectorMap = SectorMapByPath[filePath];
                 pDiskConfig->EnableSectorEncryption = !pDiskConfig->SectorMap;
 
-                NPDisk::TMainKey mainKeys = { mainKey };
+                NPDisk::TMainKey mainKeys = NPDisk::TMainKey{ .Keys = { mainKey }, .IsInitialized = true };
                 TActorSetupCmd pDiskSetup(
                     CreatePDisk(pDiskConfig.Get(), mainKeys, counters),
                     TMailboxType::Revolving, 0);
diff --git a/ydb/core/blobstorage/incrhuge/ut/incrhuge_basic_ut.cpp b/ydb/core/blobstorage/incrhuge/ut/incrhuge_basic_ut.cpp
index f76bfdb157..083d15f89e 100644
--- a/ydb/core/blobstorage/incrhuge/ut/incrhuge_basic_ut.cpp
+++ b/ydb/core/blobstorage/incrhuge/ut/incrhuge_basic_ut.cpp
@@ -58,8 +58,8 @@ public:
             DiskSize = (ui64)ChunkSize * numChunks;
             PDiskGuid = Now().GetValue();
             PDiskKey = 1;
-            MainKey = {1};
-            FormatPDisk(Path, DiskSize, 4096, ChunkSize, PDiskGuid, PDiskKey, PDiskKey, PDiskKey, MainKey.back(), "incrhuge",
+            MainKey = NPDisk::TMainKey{ .Keys = { 1 }, .IsInitialized = true };
+            FormatPDisk(Path, DiskSize, 4096, ChunkSize, PDiskGuid, PDiskKey, PDiskKey, PDiskKey, MainKey.Keys.back(), "incrhuge",
                 false, false, nullptr, false);
         }
 
diff --git a/ydb/core/blobstorage/nodewarden/distconf_persistent_storage.cpp b/ydb/core/blobstorage/nodewarden/distconf_persistent_storage.cpp
index ed7ff96152..35699774c0 100644
--- a/ydb/core/blobstorage/nodewarden/distconf_persistent_storage.cpp
+++ b/ydb/core/blobstorage/nodewarden/distconf_persistent_storage.cpp
@@ -7,7 +7,7 @@ namespace NKikimr::NStorage {
         auto ev = std::make_unique<TEvPrivate::TEvStorageConfigLoaded>();
         for (const TString& path : drives) {
             TRcBuf metadata;
-            switch (ReadPDiskMetadata(path, cfg->CreatePDiskKey(), metadata)) {
+            switch (ReadPDiskMetadata(path, cfg->PDiskKey, metadata)) {
                 case NPDisk::EPDiskMetadataOutcome::OK:
                     if (NKikimrBlobStorage::TPDiskMetadataRecord m; m.ParseFromString(metadata.ExtractUnderlyingContainerOrCopy<TString>())) {
                         auto& [p, config] = ev->MetadataPerPath.emplace_back();
@@ -32,7 +32,7 @@ namespace NKikimr::NStorage {
             TString data;
             const bool success = record.SerializeToString(&data);
             Y_ABORT_UNLESS(success);
-            switch (WritePDiskMetadata(path, cfg->CreatePDiskKey(), TRcBuf(std::move(data)))) {
+            switch (WritePDiskMetadata(path, cfg->PDiskKey, TRcBuf(std::move(data)))) {
                 case NPDisk::EPDiskMetadataOutcome::OK:
                     ev->StatusPerPath.emplace_back(path, true);
                     break;
@@ -272,7 +272,7 @@ namespace NKikimr {
         }
 
         if (it && it->GetPDiskGuid() == info.DiskGuid && it->GetTimestamp() == info.Timestamp.GetValue() &&
-                std::find(key.begin(), key.end(), it->GetKey()) != key.end()) {
+                std::find(key.Keys.begin(), key.Keys.end(), it->GetKey()) != key.Keys.end()) {
             TString s;
             const bool success = it->GetMeta().SerializeToString(&s);
             Y_ABORT_UNLESS(success);
@@ -317,7 +317,7 @@ namespace NKikimr {
 
         it->SetPDiskGuid(info.DiskGuid);
         it->SetTimestamp(info.Timestamp.GetValue());
-        it->SetKey(key.back());
+        it->SetKey(key.Keys.back());
         bool success = it->MutableMeta()->ParseFromString(metadata.ExtractUnderlyingContainerOrCopy<TString>());
         Y_ABORT_UNLESS(success);
 
diff --git a/ydb/core/blobstorage/nodewarden/node_warden.h b/ydb/core/blobstorage/nodewarden/node_warden.h
index 72b4d8c79c..e0e15a0263 100644
--- a/ydb/core/blobstorage/nodewarden/node_warden.h
+++ b/ydb/core/blobstorage/nodewarden/node_warden.h
@@ -29,7 +29,7 @@ namespace NKikimr {
         std::unique_ptr<ICacheAccessor> CacheAccessor;
         TEncryptionKey TenantKey;
         TEncryptionKey StaticKey;
-        TVector<TEncryptionKey> PDiskKey;
+        NPDisk::TMainKey PDiskKey;
         bool CachePDisks = false;
         bool CacheVDisks = false;
         bool EnableVDiskCooldownTimeout = false;
@@ -43,21 +43,6 @@ namespace NKikimr {
             , AllDriveModels(new NPDisk::TDriveModelDb)
         {}
 
-        NPDisk::TMainKey CreatePDiskKey() const {
-            if (PDiskKey.size() > 0) {
-                NPDisk::TMainKey mainKey;
-                for (ui32 i = 0; i < PDiskKey.size(); ++i) {
-                    const ui8 *key;
-                    ui32 keySize;
-                    PDiskKey[i].Key.GetKeyBytes(&key, &keySize);
-                    mainKey.push_back(*(ui64*)key);
-                }
-                return mainKey;
-            } else {
-                return { NPDisk::YdbDefaultPDiskSequence };
-            }
-        }
-
         bool IsCacheEnabled() const {
             return static_cast<bool>(CacheAccessor);
         }
@@ -67,7 +52,7 @@ namespace NKikimr {
 
     bool ObtainTenantKey(TEncryptionKey *key, const NKikimrProto::TKeyConfig& keyConfig);
     bool ObtainStaticKey(TEncryptionKey *key);
-    bool ObtainPDiskKey(TVector<TEncryptionKey> *key, const NKikimrProto::TKeyConfig& keyConfig);
+    bool ObtainPDiskKey(NPDisk::TMainKey *key, const NKikimrProto::TKeyConfig& keyConfig);
 
     std::unique_ptr<ICacheAccessor> CreateFileCacheAccessor(const TString& templ, const std::unordered_map<char, TString>& vars);
 
diff --git a/ydb/core/blobstorage/nodewarden/node_warden_impl.cpp b/ydb/core/blobstorage/nodewarden/node_warden_impl.cpp
index 12bf4781fb..285cee2ad6 100644
--- a/ydb/core/blobstorage/nodewarden/node_warden_impl.cpp
+++ b/ydb/core/blobstorage/nodewarden/node_warden_impl.cpp
@@ -619,37 +619,55 @@ bool NKikimr::ObtainTenantKey(TEncryptionKey *key, const NKikimrProto::TKeyConfi
     }
 }
 
-bool NKikimr::ObtainPDiskKey(TVector<TEncryptionKey> *keys, const NKikimrProto::TKeyConfig& keyConfig) {
+bool NKikimr::ObtainPDiskKey(NPDisk::TMainKey *mainKey, const NKikimrProto::TKeyConfig& keyConfig) {
+    Y_ABORT_UNLESS(mainKey);
+    *mainKey = NPDisk::TMainKey{};
+
     ui32 keysSize = keyConfig.KeysSize();
     if (!keysSize) {
         Cerr << "No Keys in PDiskKeyConfig! Encrypted pdisks will not start" << Endl;
+        mainKey->ErrorReason = "Empty PDiskKeyConfig";
+        mainKey->Keys = { NPDisk::YdbDefaultPDiskSequence };
+        mainKey->IsInitialized = true;
         return false;
     }
 
-    keys->resize(keysSize);
+    TVector<TEncryptionKey> keys(keysSize);
     for (ui32 i = 0; i < keysSize; ++i) {
         auto &record = keyConfig.GetKeys(i);
         if (record.GetId() == "0" && record.GetContainerPath() == "") {
             // use default pdisk key
-            (*keys)[i].Id = "0";
-            (*keys)[i].Version = record.GetVersion();
+            keys[i].Id = "0";
+            keys[i].Version = record.GetVersion();
 
             ui8 *keyBytes = 0;
             ui32 keySize = 0;
-            (*keys)[i].Key.MutableKeyBytes(&keyBytes, &keySize);
+            keys[i].Key.MutableKeyBytes(&keyBytes, &keySize);
 
             ui64* p = (ui64*)keyBytes;
             p[0] = NPDisk::YdbDefaultPDiskSequence;
         } else {
-            if (!ObtainKey(&(*keys)[i], record)) {
+            if (!ObtainKey(&keys[i], record)) {
+                mainKey->Keys = {};
+                mainKey->ErrorReason = "Cannot obtain key, ContainerPath# " + record.GetContainerPath();
+                mainKey->IsInitialized = true;
                 return false;
             }
         }
     }
 
-    std::sort(keys->begin(), keys->end(), [&](const TEncryptionKey& l, const TEncryptionKey& r) {
+    std::sort(keys.begin(), keys.end(), [&](const TEncryptionKey& l, const TEncryptionKey& r) {
         return l.Version < r.Version;
     });
+
+    for (ui32 i = 0; i < keys.size(); ++i) {
+        const ui8 *key;
+        ui32 keySize;
+        keys[i].Key.GetKeyBytes(&key, &keySize);
+        Y_DEBUG_ABORT_UNLESS(keySize == sizeof(ui64));
+        mainKey->Keys.push_back(*(ui64*)key);
+    }
+    mainKey->IsInitialized = true;
     return true;
 }
 
diff --git a/ydb/core/blobstorage/nodewarden/node_warden_pdisk.cpp b/ydb/core/blobstorage/nodewarden/node_warden_pdisk.cpp
index 1de430a4fc..067305154d 100644
--- a/ydb/core/blobstorage/nodewarden/node_warden_pdisk.cpp
+++ b/ydb/core/blobstorage/nodewarden/node_warden_pdisk.cpp
@@ -111,13 +111,13 @@ namespace NKikimr::NStorage {
             pdiskConfig->EnableSectorEncryption = !pdiskConfig->SectorMap;
         }
 
-        NPDisk::TMainKey pdiskKey = Cfg->CreatePDiskKey();
+        const NPDisk::TMainKey& pdiskKey = Cfg->PDiskKey;
         TString keyPrintSalt = "@N2#_lW19)2-31!iifI@n1178349617";
-        pdiskConfig->HashedMainKey.resize(pdiskKey.size());
-        for (ui32 i = 0; i < pdiskKey.size(); ++i) {
+        pdiskConfig->HashedMainKey.resize(pdiskKey.Keys.size());
+        for (ui32 i = 0; i < pdiskKey.Keys.size(); ++i) {
             THashCalculator hasher;
             hasher.Hash(keyPrintSalt.Detach(), keyPrintSalt.Size());
-            hasher.Hash(&pdiskKey[i], sizeof(pdiskKey[i]));
+            hasher.Hash(&pdiskKey.Keys[i], sizeof(pdiskKey.Keys[i]));
             pdiskConfig->HashedMainKey[i] = TStringBuilder() << Hex(hasher.GetHashResult(), HF_ADDX);
         }
 
@@ -170,8 +170,8 @@ namespace NKikimr::NStorage {
         const TString& path = pdisk.GetPath();
         const ui64 pdiskGuid = pdisk.GetPDiskGuid();
         const ui64 pdiskCategory = pdisk.GetPDiskCategory();
-        Cfg->PDiskServiceFactory->Create(ActorContext(), pdiskID, pdiskConfig,
-            Cfg->CreatePDiskKey(), AppData()->SystemPoolId, LocalNodeId);
+        Cfg->PDiskKey.Initialize();
+        Cfg->PDiskServiceFactory->Create(ActorContext(), pdiskID, pdiskConfig, Cfg->PDiskKey, AppData()->SystemPoolId, LocalNodeId);
         Send(WhiteboardId, new NNodeWhiteboard::TEvWhiteboard::TEvPDiskStateUpdate(pdiskID, path, pdiskGuid, pdiskCategory));
         Send(WhiteboardId, new NNodeWhiteboard::TEvWhiteboard::TEvSystemStateAddRole("Storage"));
     }
@@ -208,7 +208,8 @@ namespace NKikimr::NStorage {
         }
 
         const TActorId actorId = MakeBlobStoragePDiskID(LocalNodeId, pdiskId);
-        Send(actorId, new TEvBlobStorage::TEvRestartPDisk(pdiskId, Cfg->CreatePDiskKey(), pdiskConfig));
+        Cfg->PDiskKey.Initialize();
+        Send(actorId, new TEvBlobStorage::TEvRestartPDisk(pdiskId, Cfg->PDiskKey, pdiskConfig));
         STLOG(PRI_NOTICE, BS_NODE, NW69, "RestartLocalPDisk is started", (PDiskId, pdiskId));
     }
 
diff --git a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_actor.cpp b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_actor.cpp
index 2fef1b449c..852e46ff55 100644
--- a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_actor.cpp
+++ b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_actor.cpp
@@ -203,11 +203,11 @@ public:
                 ->GetSubgroup("pdisk", Sprintf("%09" PRIu32, (ui32)cfg->PDiskId))
                 ->GetSubgroup("media", to_lower(cfg->PDiskCategory.TypeStrShort())))
     {
-        Y_ABORT_UNLESS(!MainKey.empty());
+        Y_ABORT_UNLESS(MainKey.IsInitialized);
     }
 
     ~TPDiskActor() {
-        SecureWipeBuffer((ui8*)MainKey.data(), sizeof(NPDisk::TKey) * MainKey.size());
+        SecureWipeBuffer((ui8*)MainKey.Keys.data(), sizeof(NPDisk::TKey) * MainKey.Keys.size());
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -244,7 +244,13 @@ public:
 
         bool isOk = PDisk->Initialize(TlsActivationContext->ActorSystem(), SelfId());
 
-        if (!isOk) {
+        if (!MainKey) {
+            TStringStream str;
+            str << "PDiskId# " << (ui32)PDisk->PDiskId
+                << " MainKey is invalid, ErrorReason# " << MainKey.ErrorReason;
+            InitError(str.Str());
+            LOG_CRIT_S(*TlsActivationContext, NKikimrServices::BS_PDISK, str.Str());
+        } else if (!isOk) {
             TStringStream str;
             str << "PDiskId# " << (ui32)PDisk->PDiskId
                 << " bootstrapped to the StateError, reason# " << PDisk->ErrorStr
@@ -364,12 +370,12 @@ public:
                         try {
                             try {
                                 FormatPDisk(cfg->GetDevicePath(), 0, cfg->SectorSize, cfg->ChunkSize,
-                                    cfg->PDiskGuid, chunkKey, logKey, sysLogKey, actor->MainKey.back(), TString(), false,
+                                    cfg->PDiskGuid, chunkKey, logKey, sysLogKey, actor->MainKey.Keys.back(), TString(), false,
                                     cfg->FeatureFlags.GetTrimEntireDeviceOnStartup(), cfg->SectorMap,
                                     cfg->FeatureFlags.GetEnableSmallDiskOptimization());
                             } catch (NPDisk::TPDiskFormatBigChunkException) {
                                 FormatPDisk(cfg->GetDevicePath(), 0, cfg->SectorSize, NPDisk::SmallDiskMaximumChunkSize,
-                                    cfg->PDiskGuid, chunkKey, logKey, sysLogKey, actor->MainKey.back(), TString(), false,
+                                    cfg->PDiskGuid, chunkKey, logKey, sysLogKey, actor->MainKey.Keys.back(), TString(), false,
                                     cfg->FeatureFlags.GetTrimEntireDeviceOnStartup(), cfg->SectorMap,
                                     cfg->FeatureFlags.GetEnableSmallDiskOptimization());
                             }
@@ -384,7 +390,7 @@ public:
 
             FormattingThread->Start();
         } else {
-            SecureWipeBuffer((ui8*)MainKey.data(), sizeof(NPDisk::TKey) * MainKey.size());
+            SecureWipeBuffer((ui8*)MainKey.Keys.data(), sizeof(NPDisk::TKey) * MainKey.Keys.size());
             *PDisk->Mon.PDiskState = NKikimrBlobStorage::TPDiskState::InitialFormatReadError;
             *PDisk->Mon.PDiskBriefState = TPDiskMon::TPDisk::Error;
             *PDisk->Mon.PDiskDetailedState = TPDiskMon::TPDisk::ErrorPDiskCannotBeInitialised;
@@ -486,12 +492,12 @@ public:
         } else {
             if (res.IsReencryptionRequired) {
                 // Format reencryption required
-                ReencryptDiskFormat(PDisk->Format, MainKey.back());
+                ReencryptDiskFormat(PDisk->Format, MainKey.Keys.back());
                 // We still need main key after restart
                 // SecureWipeBuffer((ui8*)MainKey.data(), sizeof(NPDisk::TKey) * MainKey.size());
             } else {
                 // Format is read OK
-                SecureWipeBuffer((ui8*)MainKey.data(), sizeof(NPDisk::TKey) * MainKey.size());
+                SecureWipeBuffer((ui8*)MainKey.Keys.data(), sizeof(NPDisk::TKey) * MainKey.Keys.size());
                 LOG_NOTICE_S(*TlsActivationContext, NKikimrServices::BS_PDISK, "PDiskId# " << PDisk->PDiskId
                         << " Successfully read format record# " << PDisk->Format.ToString());
                 TString info;
@@ -969,7 +975,7 @@ public:
         }
 
         MainKey = ev->Get()->MainKey;
-        SecureWipeBuffer((ui8*)ev->Get()->MainKey.data(), sizeof(NPDisk::TKey) * ev->Get()->MainKey.size());
+        SecureWipeBuffer((ui8*)ev->Get()->MainKey.Keys.data(), sizeof(NPDisk::TKey) * ev->Get()->MainKey.Keys.size());
         LOG_NOTICE_S(*TlsActivationContext, NKikimrServices::BS_PDISK, "PDiskId# " << PDisk->PDiskId
                 << " Going to restart PDisk since recieved TEvRestartPDisk");
         PDisk->Stop();
diff --git a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_defs.h b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_defs.h
index 929e61c840..7ab878a946 100644
--- a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_defs.h
+++ b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_defs.h
@@ -1,6 +1,7 @@
 #pragma once
 #include "defs.h"
 #include <ydb/core/base/blobstorage.h>
+#include <ydb/core/blobstorage/crypto/default.h>
 #include <ydb/core/protos/blobstorage.pb.h>
 
 #include "blobstorage_pdisk_signature.h"
@@ -46,7 +47,23 @@ namespace NKikimr {
         typedef ui32 TStatusFlags;
         typedef ui64 TKey;
         typedef ui64 THash;
-        typedef TStackVec<TKey, 2> TMainKey;
+
+        struct TMainKey {
+            TStackVec<TKey, 2> Keys;
+            TString ErrorReason = "";
+            bool IsInitialized = false;
+
+            operator bool() const {
+                return !Keys.empty();
+            }
+
+            void Initialize() {
+                if (!IsInitialized && Keys.empty()) {
+                    Keys = { NPDisk::YdbDefaultPDiskSequence };
+                }
+                IsInitialized = true;
+            }
+        };
 
         struct TOwnerToken {
             TOwner Owner = 0;
diff --git a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_impl.cpp b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_impl.cpp
index c824428185..3e6b402880 100644
--- a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_impl.cpp
+++ b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_impl.cpp
@@ -120,11 +120,11 @@ TCheckDiskFormatResult TPDisk::ReadChunk0Format(ui8* formatSectors, const NPDisk
     TGuard<TMutex> guard(StateMutex);
 
     Format.SectorSize = FormatSectorSize;
-    ui32 mainKeySize = mainKey.size();
+    ui32 mainKeySize = mainKey.Keys.size();
 
     for (ui32 k = 0; k < mainKeySize; ++k) {
         TPDiskStreamCypher cypher(true); // Format record is always encrypted
-        cypher.SetKey(mainKey[k]);
+        cypher.SetKey(mainKey.Keys[k]);
 
         ui32 lastGoodIdx = (ui32)-1;
         bool isBad[ReplicationFactor];
diff --git a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_tools.cpp b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_tools.cpp
index 7a41067785..f4eb255fb8 100644
--- a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_tools.cpp
+++ b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_tools.cpp
@@ -154,7 +154,7 @@ bool ReadPDiskFormatInfo(const TString &path, const NPDisk::TMainKey &mainKey, T
     blockDevice->PreadSync(formatRaw->Data(), formatSectorsSize, 0,
             NPDisk::TReqId(NPDisk::TReqId::ReadFormatInfo, 0), {});
 
-    for (auto& key : mainKey) { 
+    for (auto& key : mainKey.Keys) { 
         NPDisk::TPDiskStreamCypher cypher(true); // Format record is always encrypted
         cypher.SetKey(key);
         bool isOk = false;
diff --git a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut.cpp b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut.cpp
index 3730dc8cd4..b8e13e261b 100644
--- a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut.cpp
+++ b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut.cpp
@@ -737,7 +737,7 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
                 NKikimrProto::OK);
         round = evInitRes->PDiskParams->OwnerRound + 1;
 
-        testCtx.MainKey[0] += 123;
+        testCtx.MainKey.Keys[0] += 123;
         testCtx.UpdateConfigRecreatePDisk(testCtx.GetPDiskConfig());
 
         evInitRes = testCtx.TestResponse<NPDisk::TEvYardInitResult>(
@@ -775,27 +775,27 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
 
         readChunk();
 
-        testCtx.MainKey.push_back(0xFull);
+        testCtx.MainKey.Keys.push_back(0xFull);
         testCtx.RestartPDiskSync();
         mock.InitFull();
         readChunk();
 
-        testCtx.MainKey = { 0xFull };
+        testCtx.MainKey.Keys = { 0xFull };
         testCtx.RestartPDiskSync();
         mock.InitFull();
         readChunk();
 
-        testCtx.MainKey = { 0xFull, 0xA };
+        testCtx.MainKey.Keys = { 0xFull, 0xA };
         testCtx.RestartPDiskSync();
         mock.InitFull();
         readChunk();
 
-        testCtx.MainKey = { 0xFull, 0xA, 0xB, 0xC };
+        testCtx.MainKey.Keys = { 0xFull, 0xA, 0xB, 0xC };
         testCtx.RestartPDiskSync();
         mock.InitFull();
         readChunk();
 
-        testCtx.MainKey = { 0xC };
+        testCtx.MainKey.Keys = { 0xC };
         testCtx.RestartPDiskSync();
         mock.InitFull();
         readChunk();
@@ -826,7 +826,7 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
                         chunk, 0, data.size(), 0, nullptr),
                 NKikimrProto::OK);
 
-        testCtx.MainKey = { 0xABCDEF };
+        testCtx.MainKey.Keys = { 0xABCDEF };
         testCtx.TestResponse<NPDisk::TEvYardControlResult>(
                 new NPDisk::TEvYardControl(NPDisk::TEvYardControl::PDiskStop, nullptr),
                 NKikimrProto::OK);
@@ -836,6 +836,24 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
                 NKikimrProto::CORRUPTED);
     }
 
+    Y_UNIT_TEST(RecreateWithInvalidPDiskKey) {
+        TActorTestContext testCtx({ false });
+        int round = 2;
+        const TVDiskID vDiskID(0, 1, 0, 0, 0);
+
+        auto evInitRes = testCtx.TestResponse<NPDisk::TEvYardInitResult>(
+                new NPDisk::TEvYardInit(round, vDiskID, testCtx.TestCtx.PDiskGuid),
+                NKikimrProto::OK);
+        round = evInitRes->PDiskParams->OwnerRound + 1;
+
+        testCtx.MainKey.Keys = {};
+        testCtx.UpdateConfigRecreatePDisk(testCtx.GetPDiskConfig());
+
+        evInitRes = testCtx.TestResponse<NPDisk::TEvYardInitResult>(
+                new NPDisk::TEvYardInit(round, vDiskID, testCtx.TestCtx.PDiskGuid),
+                NKikimrProto::CORRUPTED);
+    }
+
     void SmallDisk(ui64 diskSizeGb) {
         ui64 diskSize = diskSizeGb << 30;
         TActorTestContext testCtx({
diff --git a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_env.h b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_env.h
index e8ac720ed3..f1b5d2b0c0 100644
--- a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_env.h
+++ b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_env.h
@@ -36,7 +36,7 @@ private:
 
 public:
     TActorId Sender;
-    NPDisk::TMainKey MainKey = { NPDisk::YdbDefaultPDiskSequence };
+    NPDisk::TMainKey MainKey{ .Keys = { NPDisk::YdbDefaultPDiskSequence }, .IsInitialized = true };
     TTestContext TestCtx;
     TSettings Settings;
 
diff --git a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_run.cpp b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_run.cpp
index 8eb13d2549..20ed9d50be 100644
--- a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_run.cpp
+++ b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_run.cpp
@@ -88,7 +88,7 @@ void Run(TVector<IActor*> tests, TTestRunConfig runCfg) {
         pDiskConfig->UseT1ha0HashInFooter = runCfg.UseT1ha0Hasher;
         pDiskConfig->FeatureFlags.SetEnableSmallDiskOptimization(false);
 
-        NPDisk::TMainKey mainKey = {NPDisk::YdbDefaultPDiskSequence};
+        NPDisk::TMainKey mainKey{ .Keys = {NPDisk::YdbDefaultPDiskSequence}, .IsInitialized = true };
         TActorSetupCmd pDiskSetup(CreatePDisk(pDiskConfig.Get(),
                     mainKey, mainCounters), TMailboxType::Revolving, 0);
         setup1->LocalServices.push_back(std::pair<TActorId, TActorSetupCmd>(pDiskId, std::move(pDiskSetup)));
diff --git a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_yard.cpp b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_yard.cpp
index 1f98f7a952..a408a9540c 100644
--- a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_yard.cpp
+++ b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_yard.cpp
@@ -534,7 +534,7 @@ YARD_UNIT_TEST(TestDamagedFirstRecordToKeep) {
         MakeDirIfNotExist(databaseDirectory.c_str());
     }
     TPDiskInfo info;
-    const NPDisk::TMainKey mainKey = {NPDisk::YdbDefaultPDiskSequence};
+    const NPDisk::TMainKey mainKey{ .Keys = { NPDisk::YdbDefaultPDiskSequence } };
     bool isOk = ReadPDiskFormatInfo(dataPath, mainKey, info, false, tc.SectorMap);
     UNIT_ASSERT_VALUES_EQUAL(isOk, true);
 
@@ -881,7 +881,7 @@ YARD_UNIT_TEST(TestFormatInfo) {
     FormatPDiskForTest(dataPath, tc.PDiskGuid, chunkSize, 1 << 30, false, tc.SectorMap);
 
     TPDiskInfo info;
-    const NPDisk::TMainKey mainKey = {NPDisk::YdbDefaultPDiskSequence};
+    const NPDisk::TMainKey mainKey{.Keys = { NPDisk::YdbDefaultPDiskSequence } };
     bool isOk = ReadPDiskFormatInfo(dataPath, mainKey, info, false, tc.SectorMap);
     UNIT_ASSERT_VALUES_EQUAL(isOk, true);
     UNIT_ASSERT_VALUES_EQUAL(info.TextMessage, "Info");
@@ -916,7 +916,7 @@ YARD_UNIT_TEST(TestRestartAtNonceJump) {
         MakeDirIfNotExist(databaseDirectory.c_str());
     }
     TPDiskInfo info;
-    const NPDisk::TMainKey mainKey = {NPDisk::YdbDefaultPDiskSequence};
+    const NPDisk::TMainKey mainKey{ .Keys = { NPDisk::YdbDefaultPDiskSequence } };
     bool isOk = ReadPDiskFormatInfo(dataPath, mainKey, info, false, tc.SectorMap);
     UNIT_ASSERT_VALUES_EQUAL(isOk, true);
     // Destroy data in chunks starting at# SystemChunkCount + 1
@@ -946,7 +946,7 @@ YARD_UNIT_TEST(TestRestartAtChunkEnd) {
         MakeDirIfNotExist(databaseDirectory.c_str());
     }
     TPDiskInfo info;
-    const NPDisk::TMainKey mainKey = {NPDisk::YdbDefaultPDiskSequence};
+    const NPDisk::TMainKey mainKey{ .Keys = { NPDisk::YdbDefaultPDiskSequence } };
     bool isOk = ReadPDiskFormatInfo(dataPath, mainKey, info, false, tc.SectorMap);
     UNIT_ASSERT_VALUES_EQUAL(isOk, true);
     // Destroy data in chunks starting at# SystemChunkCount + 1
diff --git a/ydb/core/blobstorage/ut_group/main.cpp b/ydb/core/blobstorage/ut_group/main.cpp
index 18cdc075bb..45b82919b8 100644
--- a/ydb/core/blobstorage/ut_group/main.cpp
+++ b/ydb/core/blobstorage/ut_group/main.cpp
@@ -161,7 +161,7 @@ public:
     };
 
     TIntrusivePtr<::NMonitoring::TDynamicCounters> Counters;
-    const NPDisk::TMainKey MainKey = { NPDisk::YdbDefaultPDiskSequence };
+    const NPDisk::TMainKey MainKey{ .Keys = { NPDisk::YdbDefaultPDiskSequence } };
     const ui32 NodeCount;
     const ui32 GroupId = 0;
     std::vector<TDiskRecord> Disks;
diff --git a/ydb/core/blobstorage/ut_pdiskfit/lib/basic_test.h b/ydb/core/blobstorage/ut_pdiskfit/lib/basic_test.h
index bc8a19775d..b4ea635aa8 100644
--- a/ydb/core/blobstorage/ut_pdiskfit/lib/basic_test.h
+++ b/ydb/core/blobstorage/ut_pdiskfit/lib/basic_test.h
@@ -85,7 +85,8 @@ public:
         Y_ABORT_UNLESS(ctx.ExecutorThread.ActorSystem);
         Y_ABORT_UNLESS(PDiskConfig);
         Y_ABORT_UNLESS(AppData(ctx));
-        std::unique_ptr<IActor> pdiskActor(CreatePDisk(PDiskConfig, {1}, Counters->GetSubgroup("subsystem", "pdisk")));
+        std::unique_ptr<IActor> pdiskActor(CreatePDisk(PDiskConfig, NPDisk::TMainKey{ .Keys = { 1 }, .IsInitialized = true },
+                Counters->GetSubgroup("subsystem", "pdisk")));
         const TActorId actorId = ctx.ExecutorThread.ActorSystem->Register(pdiskActor.release(), TMailboxType::Simple,
                 AppData(ctx)->SystemPoolId);
         PDiskServiceId = MakeBlobStoragePDiskID(ctx.ExecutorThread.ActorSystem->NodeId, PDiskConfig->PDiskId);
diff --git a/ydb/core/blobstorage/ut_vdisk/lib/prepare.cpp b/ydb/core/blobstorage/ut_vdisk/lib/prepare.cpp
index 2daaa9303d..ba36004d2e 100644
--- a/ydb/core/blobstorage/ut_vdisk/lib/prepare.cpp
+++ b/ydb/core/blobstorage/ut_vdisk/lib/prepare.cpp
@@ -161,7 +161,7 @@ void TAllPDisks::ActorSetupCmd(NActors::TActorSystemSetup *setup, ui32 node,
                                            TPDiskCategory(deviceType, 0).GetRaw()));
         pDiskConfig->GetDriveDataSwitch = NKikimrBlobStorage::TPDiskConfig::DoNotTouch;
         pDiskConfig->WriteCacheSwitch = NKikimrBlobStorage::TPDiskConfig::DoNotTouch;
-        const NPDisk::TMainKey mainKey = {NPDisk::YdbDefaultPDiskSequence};
+        const NPDisk::TMainKey mainKey{ .Keys = { NPDisk::YdbDefaultPDiskSequence }, .IsInitialized = true };
         TActorSetupCmd pDiskSetup(CreatePDisk(pDiskConfig.Get(),
                     mainKey, counters), TMailboxType::Revolving, 0);
         setup->LocalServices.push_back(std::pair<TActorId, TActorSetupCmd>(inst.PDiskActorID, std::move(pDiskSetup)));
diff --git a/ydb/core/blobstorage/vdisk/skeleton/blobstorage_monactors.h b/ydb/core/blobstorage/vdisk/skeleton/blobstorage_monactors.h
index b646db66bd..1ed0d4a36f 100644
--- a/ydb/core/blobstorage/vdisk/skeleton/blobstorage_monactors.h
+++ b/ydb/core/blobstorage/vdisk/skeleton/blobstorage_monactors.h
@@ -1,6 +1,7 @@
 #pragma once
 #include "defs.h"
 
+#include <ydb/core/blobstorage/vdisk/common/vdisk_mongroups.h>
 #include <ydb/core/blobstorage/vdisk/common/vdisk_events.h>
 #include <ydb/core/blobstorage/groupinfo/blobstorage_groupinfo.h>
 #include <ydb/core/protos/node_whiteboard.pb.h>
diff --git a/ydb/core/driver_lib/base_utils/format_info.cpp b/ydb/core/driver_lib/base_utils/format_info.cpp
index 03498da375..84daa51d6a 100644
--- a/ydb/core/driver_lib/base_utils/format_info.cpp
+++ b/ydb/core/driver_lib/base_utils/format_info.cpp
@@ -88,7 +88,7 @@ void TCmdFormatInfoConfig::Parse(int argc, char **argv) {
 
     MainKey = {};
     for (auto& key : MainKeyTmp) {
-        MainKey.push_back(key);
+        MainKey.Keys.push_back(key);
     }
 }
 
diff --git a/ydb/core/driver_lib/cli_utils/cli_cmds_disk.cpp b/ydb/core/driver_lib/cli_utils/cli_cmds_disk.cpp
index d7028ee5f4..eac2cd9893 100644
--- a/ydb/core/driver_lib/cli_utils/cli_cmds_disk.cpp
+++ b/ydb/core/driver_lib/cli_utils/cli_cmds_disk.cpp
@@ -47,7 +47,7 @@ public:
 
         MainKey = {};
         for (auto& key : MainKeyTmp) {
-            MainKey.push_back(key);
+            MainKey.Keys.push_back(key);
         }
     }
 
@@ -174,12 +174,12 @@ public:
             ythrow yexception() << "missing main-key param";
 
         for (auto& key : MainKeyTmp) {
-            MainKey.push_back(key);
+            MainKey.Keys.push_back(key);
         }
     }
 
     virtual int Run(TConfig&) override {
-        FormatPDisk(Path, DiskSize, SectorSize, ChunkSize, Guid, ChunkKey, LogKey, SysLogKey, MainKey.back(), TextMessage,
+        FormatPDisk(Path, DiskSize, SectorSize, ChunkSize, Guid, ChunkKey, LogKey, SysLogKey, MainKey.Keys.back(), TextMessage,
                 IsErasureEncode, false, nullptr, true);
         return 0;
     }