src/platform/silabs/EFR32/Efr32PsaOperationalKeystore.cpp - third_party/github/project-chip/connectedhomeip - Git at Google

 /*
  *    Copyright (c) 2022 Project CHIP Authors
  *    All rights reserved.
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
  *    You may obtain a copy of the License at
  *
  *        http://www.apache.org/licenses/LICENSE-2.0
  *
  *    Unless required by applicable law or agreed to in writing, software
  *    distributed under the License is distributed on an "AS IS" BASIS,
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */
 #include "Efr32PsaOperationalKeystore.h"

 #include <crypto/OperationalKeystore.h>
 #include <lib/core/CHIPError.h>
 #include <lib/core/CHIPTLV.h>
 #include <lib/core/DataModelTypes.h>
 #include <lib/support/CHIPMem.h>
 #include <lib/support/CodeUtils.h>
 #include <lib/support/SafeInt.h>

 #include "Efr32OpaqueKeypair.h"
 #include <platform/silabs/EFR32Config.h>

 namespace chip {
 namespace DeviceLayer {
 namespace Internal {

 static_assert((sizeof(FabricIndex) == 1), "Implementation is not prepared for large fabric indices");
 static_assert(SL_MATTER_MAX_STORED_OP_KEYS <= (kEFR32OpaqueKeyIdPersistentMax - kEFR32OpaqueKeyIdPersistentMin),
               "Not enough opaque keys available to cover all requested operational keys");
 static_assert((CHIP_CONFIG_MAX_FABRICS + 1) <= SL_MATTER_MAX_STORED_OP_KEYS,
               "Not enough operational keys requested to cover all potential fabrics (+1 staging for fabric update)");
 static_assert(SL_MATTER_MAX_STORED_OP_KEYS >= 1, "Minimum supported amount of operational keys is 1");

 using namespace chip::Crypto;

 using chip::Platform::MemoryCalloc;
 using chip::Platform::MemoryFree;

 Efr32PsaOperationalKeystore::~Efr32PsaOperationalKeystore()
 {
     Deinit();
 }

 CHIP_ERROR Efr32PsaOperationalKeystore::Init()
 {
     // Detect existing keymap size
     CHIP_ERROR error   = CHIP_NO_ERROR;
     size_t wantedLen   = SL_MATTER_MAX_STORED_OP_KEYS * sizeof(FabricIndex);
     size_t existingLen = 0;
     bool update_cache  = false;

     if (EFR32Config::ConfigValueExists(EFR32Config::kConfigKey_OpKeyMap, existingLen))
     {
         // There's a pre-existing key map on disk. Size the map to read it fully.
         size_t outLen = 0;

         if (existingLen > (kEFR32OpaqueKeyIdPersistentMax - kEFR32OpaqueKeyIdPersistentMin) * sizeof(FabricIndex))
         {
             return CHIP_ERROR_INTERNAL;
         }

         // Upsize the map if the config was changed
         if (existingLen < wantedLen)
         {
             existingLen = wantedLen;
         }

         mKeyMap = (FabricIndex *) MemoryCalloc(1, existingLen);
         VerifyOrExit(mKeyMap, error = CHIP_ERROR_NO_MEMORY);

         // Read the existing key map
         error = EFR32Config::ReadConfigValueBin(EFR32Config::kConfigKey_OpKeyMap, (uint8_t *) mKeyMap, existingLen, outLen);
         SuccessOrExit(error);

         // If upsizing, extend the map with undefined indices
         for (size_t i = (outLen / sizeof(FabricIndex)); i < (existingLen / sizeof(FabricIndex)); i++)
         {
             mKeyMap[i] = kUndefinedFabricIndex;
         }

         // If the config has changed, check whether it can be downsized fully or partially
         if (existingLen > wantedLen)
         {
             size_t highest_found_index = 0;
             for (size_t i = (wantedLen / sizeof(FabricIndex)); i < (existingLen / sizeof(FabricIndex)); i++)
             {
                 if (mKeyMap[i] != kUndefinedFabricIndex)
                 {
                     highest_found_index = i;
                 }
             }

             // set size to the smallest that will fit the upper opaque key ID in use
             if (highest_found_index > 0)
             {
                 existingLen  = (highest_found_index + 1) * sizeof(FabricIndex);
                 update_cache = true;
             }
         }

         // Set the key map size
         mKeyMapSize = existingLen;
     }
     else
     {
         // No key map on disk. Create and initialize a new one.
         mKeyMap = (FabricIndex *) MemoryCalloc(1, wantedLen);
         VerifyOrExit(mKeyMap, error = CHIP_ERROR_NO_MEMORY);

         for (size_t i = 0; i < (wantedLen / sizeof(FabricIndex)); i++)
         {
             mKeyMap[i] = kUndefinedFabricIndex;
         }

         mKeyMapSize = wantedLen;

         update_cache = true;
     }

     // Write-out keymap if needed
     if (update_cache)
     {
         error = EFR32Config::WriteConfigValueBin(EFR32Config::kConfigKey_OpKeyMap, mKeyMap, mKeyMapSize);
         SuccessOrExit(error);
     }

     // Initialize cache key
     mCachedKey = Platform::New<EFR32OpaqueP256Keypair>();
     VerifyOrExit(mCachedKey, error = CHIP_ERROR_NO_MEMORY);

 exit:
     if (error != CHIP_NO_ERROR)
     {
         Deinit();
         return error;
     }

     mIsInitialized = true;
     return CHIP_NO_ERROR;
 }

 EFR32OpaqueKeyId Efr32PsaOperationalKeystore::FindKeyIdForFabric(FabricIndex fabricIndex) const
 {
     // Search the map linearly to find a matching index slot
     for (size_t i = 0; i < (mKeyMapSize / sizeof(FabricIndex)); i++)
     {
         if (mKeyMap[i] == fabricIndex)
         {
             // Found a match
             return i + kEFR32OpaqueKeyIdPersistentMin;
         }
     }

     return kEFR32OpaqueKeyIdUnknown;
 }

 bool Efr32PsaOperationalKeystore::HasOpKeypairForFabric(FabricIndex fabricIndex) const
 {
     VerifyOrReturnError(mIsInitialized, false);
     VerifyOrReturnError(IsValidFabricIndex(fabricIndex), false);

     // If there was a pending keypair, then there's really a usable key
     if (mIsPendingKeypairActive && (fabricIndex == mPendingFabricIndex) && (mPendingKeypair != nullptr))
     {
         return true;
     }

     // Check whether we have a match in the map
     if (FindKeyIdForFabric(fabricIndex) != kEFR32OpaqueKeyIdUnknown)
     {
         return true;
     }

     return false;
 }

 CHIP_ERROR Efr32PsaOperationalKeystore::NewOpKeypairForFabric(FabricIndex fabricIndex,
                                                               MutableByteSpan & outCertificateSigningRequest)
 {
     CHIP_ERROR error = CHIP_NO_ERROR;
     VerifyOrReturnError(mIsInitialized, CHIP_ERROR_WELL_UNINITIALIZED);
     VerifyOrReturnError(IsValidFabricIndex(fabricIndex), CHIP_ERROR_INVALID_FABRIC_INDEX);

     // If a key is pending, we cannot generate for a different fabric index until we commit or revert.
     if ((mPendingFabricIndex != kUndefinedFabricIndex) && (fabricIndex != mPendingFabricIndex))
     {
         return CHIP_ERROR_INVALID_FABRIC_INDEX;
     }

     VerifyOrReturnError(outCertificateSigningRequest.size() >= Crypto::kMAX_CSR_Length, CHIP_ERROR_BUFFER_TOO_SMALL);

     // Generate new key
     EFR32OpaqueKeyId id = kEFR32OpaqueKeyIdUnknown;

     if (mPendingFabricIndex != kUndefinedFabricIndex)
     {
         // If we already have a pending key, delete it and put a new one in its place
         id = mPendingKeypair->GetKeyId();
         if (id == kEFR32OpaqueKeyIdUnknown)
         {
             ResetPendingKey();
         }
         else
         {
             mPendingKeypair->Delete();
             if (id == kEFR32OpaqueKeyIdVolatile)
             {
                 id = kEFR32OpaqueKeyIdUnknown;
             }
         }
     }

     if (id == kEFR32OpaqueKeyIdUnknown)
     {
         // Try to find an available opaque ID in the map
         id = FindKeyIdForFabric(kUndefinedFabricIndex);

         if (!mPendingKeypair)
         {
             mPendingKeypair = Platform::New<EFR32OpaqueP256Keypair>();
         }
     }

     if (id == kEFR32OpaqueKeyIdUnknown)
     {
         // Could not find a free spot in the map
         return CHIP_ERROR_NO_MEMORY;
     }

     // Create new key on the old or found key ID
     error = mPendingKeypair->Create(id, EFR32OpaqueKeyUsages::ECDSA_P256_SHA256);
     if (error != CHIP_NO_ERROR)
     {
         ResetPendingKey();
         return error;
     }

     // Set CSR and state
     size_t csrLength = outCertificateSigningRequest.size();
     error            = mPendingKeypair->NewCertificateSigningRequest(outCertificateSigningRequest.data(), csrLength);
     if (error != CHIP_NO_ERROR)
     {
         ResetPendingKey();
         return error;
     }

     outCertificateSigningRequest.reduce_size(csrLength);
     mPendingFabricIndex = fabricIndex;

     return CHIP_NO_ERROR;
 }

 CHIP_ERROR Efr32PsaOperationalKeystore::ActivateOpKeypairForFabric(FabricIndex fabricIndex,
                                                                    const Crypto::P256PublicKey & nocPublicKey)
 {
     VerifyOrReturnError(mIsInitialized, CHIP_ERROR_WELL_UNINITIALIZED);
     VerifyOrReturnError(mPendingKeypair != nullptr, CHIP_ERROR_INVALID_FABRIC_INDEX);
     VerifyOrReturnError(IsValidFabricIndex(fabricIndex) && (fabricIndex == mPendingFabricIndex), CHIP_ERROR_INVALID_FABRIC_INDEX);

     // Validate public key being activated matches last generated pending keypair
     VerifyOrReturnError(mPendingKeypair->Pubkey().Matches(nocPublicKey), CHIP_ERROR_INVALID_PUBLIC_KEY);

     mIsPendingKeypairActive = true;

     return CHIP_NO_ERROR;
 }

 CHIP_ERROR Efr32PsaOperationalKeystore::CommitOpKeypairForFabric(FabricIndex fabricIndex)
 {
     VerifyOrReturnError(mIsInitialized, CHIP_ERROR_WELL_UNINITIALIZED);
     VerifyOrReturnError(mPendingKeypair != nullptr, CHIP_ERROR_INVALID_FABRIC_INDEX);
     VerifyOrReturnError(IsValidFabricIndex(fabricIndex) && (fabricIndex == mPendingFabricIndex), CHIP_ERROR_INVALID_FABRIC_INDEX);
     VerifyOrReturnError(mIsPendingKeypairActive == true, CHIP_ERROR_INCORRECT_STATE);

     // Add key association to key map
     EFR32OpaqueKeyId id = mPendingKeypair->GetKeyId();

     if (id == kEFR32OpaqueKeyIdUnknown || id == kEFR32OpaqueKeyIdVolatile)
     {
         ResetPendingKey();
         return CHIP_ERROR_INTERNAL;
     }

     // Guard against array out-of-bounds (should not happen with correctly initialised keys)
     size_t keymap_index = id - kEFR32OpaqueKeyIdPersistentMin;
     if (keymap_index >= (mKeyMapSize / sizeof(FabricIndex)))
     {
         return CHIP_ERROR_INTERNAL;
     }

     if (mKeyMap[keymap_index] != kUndefinedFabricIndex)
     {
         ResetPendingKey();
         return CHIP_ERROR_INTERNAL;
     }

     mKeyMap[keymap_index] = fabricIndex;

     // Persist key map
     CHIP_ERROR error = EFR32Config::WriteConfigValueBin(EFR32Config::kConfigKey_OpKeyMap, mKeyMap, mKeyMapSize);
     if (error != CHIP_NO_ERROR)
     {
         return error;
     }

     // There's a good chance we'll need the key again soon
     mCachedKey->Load(id);

     mPendingKeypair         = nullptr;
     mIsPendingKeypairActive = false;
     mPendingFabricIndex     = kUndefinedFabricIndex;

     return CHIP_NO_ERROR;
 }

 CHIP_ERROR Efr32PsaOperationalKeystore::RemoveOpKeypairForFabric(FabricIndex fabricIndex)
 {
     VerifyOrReturnError(mIsInitialized, CHIP_ERROR_WELL_UNINITIALIZED);
     VerifyOrReturnError(IsValidFabricIndex(fabricIndex), CHIP_ERROR_INVALID_FABRIC_INDEX);

     // Remove pending keypair if we have it and the fabric ID matches
     if ((mPendingKeypair != nullptr) && (fabricIndex == mPendingFabricIndex))
     {
         RevertPendingKeypair();
     }

     EFR32OpaqueKeyId id = FindKeyIdForFabric(fabricIndex);
     if (id == kEFR32OpaqueKeyIdUnknown)
     {
         // Fabric is not in the map, so assume it's gone already
         return CHIP_NO_ERROR;
     }

     // Guard against array out-of-bounds (should not happen with correctly initialised keys)
     size_t keymap_index = id - kEFR32OpaqueKeyIdPersistentMin;
     if (keymap_index >= (mKeyMapSize / sizeof(FabricIndex)))
     {
         return CHIP_ERROR_INTERNAL;
     }

     // Reset the key mapping since we'll be deleting this key
     mKeyMap[keymap_index] = kUndefinedFabricIndex;

     // Persist key map
     CHIP_ERROR error = EFR32Config::WriteConfigValueBin(EFR32Config::kConfigKey_OpKeyMap, mKeyMap, mKeyMapSize);
     if (error != CHIP_NO_ERROR)
     {
         return error;
     }

     // Check if key is cached
     EFR32OpaqueKeyId cachedId = mCachedKey->GetKeyId();

     if (id == cachedId)
     {
         // Delete from persistent storage and unload
         mCachedKey->Delete();
         return CHIP_NO_ERROR;
     }

     // Load it for purposes of deletion
     error = mCachedKey->Load(id);
     if (error != CHIP_NO_ERROR && error != CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND)
     {
         return CHIP_ERROR_INTERNAL;
     }

     mCachedKey->Delete();

     return CHIP_NO_ERROR;
 }

 void Efr32PsaOperationalKeystore::RevertPendingKeypair()
 {
     if (mIsInitialized)
     {
         // Just delete the pending key from storage
         ResetPendingKey();
     }
 }

 CHIP_ERROR Efr32PsaOperationalKeystore::SignWithOpKeypair(FabricIndex fabricIndex, const ByteSpan & message,
                                                           Crypto::P256ECDSASignature & outSignature) const
 {
     VerifyOrReturnError(mIsInitialized, CHIP_ERROR_WELL_UNINITIALIZED);
     VerifyOrReturnError(IsValidFabricIndex(fabricIndex), CHIP_ERROR_INVALID_FABRIC_INDEX);

     // Check to see whether the key is an activated pending key
     if (mIsPendingKeypairActive && (fabricIndex == mPendingFabricIndex))
     {
         VerifyOrReturnError(mPendingKeypair != nullptr, CHIP_ERROR_INTERNAL);
         return mPendingKeypair->ECDSA_sign_msg(message.data(), message.size(), outSignature);
     }

     // Figure out which key ID we're looking for
     EFR32OpaqueKeyId id = FindKeyIdForFabric(fabricIndex);

     if (id == kEFR32OpaqueKeyIdUnknown)
     {
         // Fabric is not in the map, but the caller thinks it's there?
         return CHIP_ERROR_INTERNAL;
     }

     // Check whether we have the key in cache
     EFR32OpaqueKeyId cachedId = mCachedKey->GetKeyId();

     if (id == cachedId)
     {
         return mCachedKey->ECDSA_sign_msg(message.data(), message.size(), outSignature);
     }

     // If not, we need to recreate from the backend
     CHIP_ERROR error = mCachedKey->Load(id);
     if (error != CHIP_NO_ERROR)
     {
         return CHIP_ERROR_INTERNAL;
     }

     // Sign with retrieved key
     error = mCachedKey->ECDSA_sign_msg(message.data(), message.size(), outSignature);
     if (error != CHIP_NO_ERROR)
     {
         return CHIP_ERROR_INTERNAL;
     }

     return CHIP_NO_ERROR;
 }

 Crypto::P256Keypair * Efr32PsaOperationalKeystore::AllocateEphemeralKeypairForCASE()
 {
     EFR32OpaqueP256Keypair * new_key = Platform::New<EFR32OpaqueP256Keypair>();

     if (new_key != nullptr)
     {
         new_key->Create(kEFR32OpaqueKeyIdVolatile, EFR32OpaqueKeyUsages::ECDH_P256);
     }

     return new_key;
 }

 void Efr32PsaOperationalKeystore::ReleaseEphemeralKeypair(Crypto::P256Keypair * keypair)
 {
     Platform::Delete<EFR32OpaqueP256Keypair>((EFR32OpaqueP256Keypair *) keypair);
 }

 } // namespace Internal
 } // namespace DeviceLayer
 } // namespace chip
	/*
	* Copyright (c) 2022 Project CHIP Authors
	* All rights reserved.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	#include "Efr32PsaOperationalKeystore.h"

	#include <crypto/OperationalKeystore.h>
	#include <lib/core/CHIPError.h>
	#include <lib/core/CHIPTLV.h>
	#include <lib/core/DataModelTypes.h>
	#include <lib/support/CHIPMem.h>
	#include <lib/support/CodeUtils.h>
	#include <lib/support/SafeInt.h>

	#include "Efr32OpaqueKeypair.h"
	#include <platform/silabs/EFR32Config.h>

	namespace chip {
	namespace DeviceLayer {
	namespace Internal {

	static_assert((sizeof(FabricIndex) == 1), "Implementation is not prepared for large fabric indices");
	static_assert(SL_MATTER_MAX_STORED_OP_KEYS <= (kEFR32OpaqueKeyIdPersistentMax - kEFR32OpaqueKeyIdPersistentMin),
	"Not enough opaque keys available to cover all requested operational keys");
	static_assert((CHIP_CONFIG_MAX_FABRICS + 1) <= SL_MATTER_MAX_STORED_OP_KEYS,
	"Not enough operational keys requested to cover all potential fabrics (+1 staging for fabric update)");
	static_assert(SL_MATTER_MAX_STORED_OP_KEYS >= 1, "Minimum supported amount of operational keys is 1");

	using namespace chip::Crypto;

	using chip::Platform::MemoryCalloc;
	using chip::Platform::MemoryFree;

	Efr32PsaOperationalKeystore::~Efr32PsaOperationalKeystore()
	{
	Deinit();
	}

	CHIP_ERROR Efr32PsaOperationalKeystore::Init()
	{
	// Detect existing keymap size
	CHIP_ERROR error = CHIP_NO_ERROR;
	size_t wantedLen = SL_MATTER_MAX_STORED_OP_KEYS * sizeof(FabricIndex);
	size_t existingLen = 0;
	bool update_cache = false;

	if (EFR32Config::ConfigValueExists(EFR32Config::kConfigKey_OpKeyMap, existingLen))
	{
	// There's a pre-existing key map on disk. Size the map to read it fully.
	size_t outLen = 0;

	if (existingLen > (kEFR32OpaqueKeyIdPersistentMax - kEFR32OpaqueKeyIdPersistentMin) * sizeof(FabricIndex))
	{
	return CHIP_ERROR_INTERNAL;
	}

	// Upsize the map if the config was changed
	if (existingLen < wantedLen)
	{
	existingLen = wantedLen;
	}

	mKeyMap = (FabricIndex *) MemoryCalloc(1, existingLen);
	VerifyOrExit(mKeyMap, error = CHIP_ERROR_NO_MEMORY);

	// Read the existing key map
	error = EFR32Config::ReadConfigValueBin(EFR32Config::kConfigKey_OpKeyMap, (uint8_t *) mKeyMap, existingLen, outLen);
	SuccessOrExit(error);

	// If upsizing, extend the map with undefined indices
	for (size_t i = (outLen / sizeof(FabricIndex)); i < (existingLen / sizeof(FabricIndex)); i++)
	{
	mKeyMap[i] = kUndefinedFabricIndex;
	}

	// If the config has changed, check whether it can be downsized fully or partially
	if (existingLen > wantedLen)
	{
	size_t highest_found_index = 0;
	for (size_t i = (wantedLen / sizeof(FabricIndex)); i < (existingLen / sizeof(FabricIndex)); i++)
	{
	if (mKeyMap[i] != kUndefinedFabricIndex)
	{
	highest_found_index = i;
	}
	}

	// set size to the smallest that will fit the upper opaque key ID in use
	if (highest_found_index > 0)
	{
	existingLen = (highest_found_index + 1) * sizeof(FabricIndex);
	update_cache = true;
	}
	}

	// Set the key map size
	mKeyMapSize = existingLen;
	}
	else
	{
	// No key map on disk. Create and initialize a new one.
	mKeyMap = (FabricIndex *) MemoryCalloc(1, wantedLen);
	VerifyOrExit(mKeyMap, error = CHIP_ERROR_NO_MEMORY);

	for (size_t i = 0; i < (wantedLen / sizeof(FabricIndex)); i++)
	{
	mKeyMap[i] = kUndefinedFabricIndex;
	}

	mKeyMapSize = wantedLen;

	update_cache = true;
	}

	// Write-out keymap if needed
	if (update_cache)
	{
	error = EFR32Config::WriteConfigValueBin(EFR32Config::kConfigKey_OpKeyMap, mKeyMap, mKeyMapSize);
	SuccessOrExit(error);
	}

	// Initialize cache key
	mCachedKey = Platform::New<EFR32OpaqueP256Keypair>();
	VerifyOrExit(mCachedKey, error = CHIP_ERROR_NO_MEMORY);

	exit:
	if (error != CHIP_NO_ERROR)
	{
	Deinit();
	return error;
	}

	mIsInitialized = true;
	return CHIP_NO_ERROR;
	}

	EFR32OpaqueKeyId Efr32PsaOperationalKeystore::FindKeyIdForFabric(FabricIndex fabricIndex) const
	{
	// Search the map linearly to find a matching index slot
	for (size_t i = 0; i < (mKeyMapSize / sizeof(FabricIndex)); i++)
	{
	if (mKeyMap[i] == fabricIndex)
	{
	// Found a match
	return i + kEFR32OpaqueKeyIdPersistentMin;
	}
	}

	return kEFR32OpaqueKeyIdUnknown;
	}

	bool Efr32PsaOperationalKeystore::HasOpKeypairForFabric(FabricIndex fabricIndex) const
	{
	VerifyOrReturnError(mIsInitialized, false);
	VerifyOrReturnError(IsValidFabricIndex(fabricIndex), false);

	// If there was a pending keypair, then there's really a usable key
	if (mIsPendingKeypairActive && (fabricIndex == mPendingFabricIndex) && (mPendingKeypair != nullptr))
	{
	return true;
	}

	// Check whether we have a match in the map
	if (FindKeyIdForFabric(fabricIndex) != kEFR32OpaqueKeyIdUnknown)
	{
	return true;
	}

	return false;
	}

	CHIP_ERROR Efr32PsaOperationalKeystore::NewOpKeypairForFabric(FabricIndex fabricIndex,
	MutableByteSpan & outCertificateSigningRequest)
	{
	CHIP_ERROR error = CHIP_NO_ERROR;
	VerifyOrReturnError(mIsInitialized, CHIP_ERROR_WELL_UNINITIALIZED);
	VerifyOrReturnError(IsValidFabricIndex(fabricIndex), CHIP_ERROR_INVALID_FABRIC_INDEX);

	// If a key is pending, we cannot generate for a different fabric index until we commit or revert.
	if ((mPendingFabricIndex != kUndefinedFabricIndex) && (fabricIndex != mPendingFabricIndex))
	{
	return CHIP_ERROR_INVALID_FABRIC_INDEX;
	}

	VerifyOrReturnError(outCertificateSigningRequest.size() >= Crypto::kMAX_CSR_Length, CHIP_ERROR_BUFFER_TOO_SMALL);

	// Generate new key
	EFR32OpaqueKeyId id = kEFR32OpaqueKeyIdUnknown;

	if (mPendingFabricIndex != kUndefinedFabricIndex)
	{
	// If we already have a pending key, delete it and put a new one in its place
	id = mPendingKeypair->GetKeyId();
	if (id == kEFR32OpaqueKeyIdUnknown)
	{
	ResetPendingKey();
	}
	else
	{
	mPendingKeypair->Delete();
	if (id == kEFR32OpaqueKeyIdVolatile)
	{
	id = kEFR32OpaqueKeyIdUnknown;
	}
	}
	}

	if (id == kEFR32OpaqueKeyIdUnknown)
	{
	// Try to find an available opaque ID in the map
	id = FindKeyIdForFabric(kUndefinedFabricIndex);

	if (!mPendingKeypair)
	{
	mPendingKeypair = Platform::New<EFR32OpaqueP256Keypair>();
	}
	}

	if (id == kEFR32OpaqueKeyIdUnknown)
	{
	// Could not find a free spot in the map
	return CHIP_ERROR_NO_MEMORY;
	}

	// Create new key on the old or found key ID
	error = mPendingKeypair->Create(id, EFR32OpaqueKeyUsages::ECDSA_P256_SHA256);
	if (error != CHIP_NO_ERROR)
	{
	ResetPendingKey();
	return error;
	}

	// Set CSR and state
	size_t csrLength = outCertificateSigningRequest.size();
	error = mPendingKeypair->NewCertificateSigningRequest(outCertificateSigningRequest.data(), csrLength);
	if (error != CHIP_NO_ERROR)
	{
	ResetPendingKey();
	return error;
	}

	outCertificateSigningRequest.reduce_size(csrLength);
	mPendingFabricIndex = fabricIndex;

	return CHIP_NO_ERROR;
	}

	CHIP_ERROR Efr32PsaOperationalKeystore::ActivateOpKeypairForFabric(FabricIndex fabricIndex,
	const Crypto::P256PublicKey & nocPublicKey)
	{
	VerifyOrReturnError(mIsInitialized, CHIP_ERROR_WELL_UNINITIALIZED);
	VerifyOrReturnError(mPendingKeypair != nullptr, CHIP_ERROR_INVALID_FABRIC_INDEX);
	VerifyOrReturnError(IsValidFabricIndex(fabricIndex) && (fabricIndex == mPendingFabricIndex), CHIP_ERROR_INVALID_FABRIC_INDEX);

	// Validate public key being activated matches last generated pending keypair
	VerifyOrReturnError(mPendingKeypair->Pubkey().Matches(nocPublicKey), CHIP_ERROR_INVALID_PUBLIC_KEY);

	mIsPendingKeypairActive = true;

	return CHIP_NO_ERROR;
	}

	CHIP_ERROR Efr32PsaOperationalKeystore::CommitOpKeypairForFabric(FabricIndex fabricIndex)
	{
	VerifyOrReturnError(mIsInitialized, CHIP_ERROR_WELL_UNINITIALIZED);
	VerifyOrReturnError(mPendingKeypair != nullptr, CHIP_ERROR_INVALID_FABRIC_INDEX);
	VerifyOrReturnError(IsValidFabricIndex(fabricIndex) && (fabricIndex == mPendingFabricIndex), CHIP_ERROR_INVALID_FABRIC_INDEX);
	VerifyOrReturnError(mIsPendingKeypairActive == true, CHIP_ERROR_INCORRECT_STATE);

	// Add key association to key map
	EFR32OpaqueKeyId id = mPendingKeypair->GetKeyId();

	if (id == kEFR32OpaqueKeyIdUnknown \|\| id == kEFR32OpaqueKeyIdVolatile)
	{
	ResetPendingKey();
	return CHIP_ERROR_INTERNAL;
	}

	// Guard against array out-of-bounds (should not happen with correctly initialised keys)
	size_t keymap_index = id - kEFR32OpaqueKeyIdPersistentMin;
	if (keymap_index >= (mKeyMapSize / sizeof(FabricIndex)))
	{
	return CHIP_ERROR_INTERNAL;
	}

	if (mKeyMap[keymap_index] != kUndefinedFabricIndex)
	{
	ResetPendingKey();
	return CHIP_ERROR_INTERNAL;
	}

	mKeyMap[keymap_index] = fabricIndex;

	// Persist key map
	CHIP_ERROR error = EFR32Config::WriteConfigValueBin(EFR32Config::kConfigKey_OpKeyMap, mKeyMap, mKeyMapSize);
	if (error != CHIP_NO_ERROR)
	{
	return error;
	}

	// There's a good chance we'll need the key again soon
	mCachedKey->Load(id);

	mPendingKeypair = nullptr;
	mIsPendingKeypairActive = false;
	mPendingFabricIndex = kUndefinedFabricIndex;

	return CHIP_NO_ERROR;
	}

	CHIP_ERROR Efr32PsaOperationalKeystore::RemoveOpKeypairForFabric(FabricIndex fabricIndex)
	{
	VerifyOrReturnError(mIsInitialized, CHIP_ERROR_WELL_UNINITIALIZED);
	VerifyOrReturnError(IsValidFabricIndex(fabricIndex), CHIP_ERROR_INVALID_FABRIC_INDEX);

	// Remove pending keypair if we have it and the fabric ID matches
	if ((mPendingKeypair != nullptr) && (fabricIndex == mPendingFabricIndex))
	{
	RevertPendingKeypair();
	}

	EFR32OpaqueKeyId id = FindKeyIdForFabric(fabricIndex);
	if (id == kEFR32OpaqueKeyIdUnknown)
	{
	// Fabric is not in the map, so assume it's gone already
	return CHIP_NO_ERROR;
	}

	// Guard against array out-of-bounds (should not happen with correctly initialised keys)
	size_t keymap_index = id - kEFR32OpaqueKeyIdPersistentMin;
	if (keymap_index >= (mKeyMapSize / sizeof(FabricIndex)))
	{
	return CHIP_ERROR_INTERNAL;
	}

	// Reset the key mapping since we'll be deleting this key
	mKeyMap[keymap_index] = kUndefinedFabricIndex;

	// Persist key map
	CHIP_ERROR error = EFR32Config::WriteConfigValueBin(EFR32Config::kConfigKey_OpKeyMap, mKeyMap, mKeyMapSize);
	if (error != CHIP_NO_ERROR)
	{
	return error;
	}

	// Check if key is cached
	EFR32OpaqueKeyId cachedId = mCachedKey->GetKeyId();

	if (id == cachedId)
	{
	// Delete from persistent storage and unload
	mCachedKey->Delete();
	return CHIP_NO_ERROR;
	}

	// Load it for purposes of deletion
	error = mCachedKey->Load(id);
	if (error != CHIP_NO_ERROR && error != CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND)
	{
	return CHIP_ERROR_INTERNAL;
	}

	mCachedKey->Delete();

	return CHIP_NO_ERROR;
	}

	void Efr32PsaOperationalKeystore::RevertPendingKeypair()
	{
	if (mIsInitialized)
	{
	// Just delete the pending key from storage
	ResetPendingKey();
	}
	}

	CHIP_ERROR Efr32PsaOperationalKeystore::SignWithOpKeypair(FabricIndex fabricIndex, const ByteSpan & message,
	Crypto::P256ECDSASignature & outSignature) const
	{
	VerifyOrReturnError(mIsInitialized, CHIP_ERROR_WELL_UNINITIALIZED);
	VerifyOrReturnError(IsValidFabricIndex(fabricIndex), CHIP_ERROR_INVALID_FABRIC_INDEX);

	// Check to see whether the key is an activated pending key
	if (mIsPendingKeypairActive && (fabricIndex == mPendingFabricIndex))
	{
	VerifyOrReturnError(mPendingKeypair != nullptr, CHIP_ERROR_INTERNAL);
	return mPendingKeypair->ECDSA_sign_msg(message.data(), message.size(), outSignature);
	}

	// Figure out which key ID we're looking for
	EFR32OpaqueKeyId id = FindKeyIdForFabric(fabricIndex);

	if (id == kEFR32OpaqueKeyIdUnknown)
	{
	// Fabric is not in the map, but the caller thinks it's there?
	return CHIP_ERROR_INTERNAL;
	}

	// Check whether we have the key in cache
	EFR32OpaqueKeyId cachedId = mCachedKey->GetKeyId();

	if (id == cachedId)
	{
	return mCachedKey->ECDSA_sign_msg(message.data(), message.size(), outSignature);
	}

	// If not, we need to recreate from the backend
	CHIP_ERROR error = mCachedKey->Load(id);
	if (error != CHIP_NO_ERROR)
	{
	return CHIP_ERROR_INTERNAL;
	}

	// Sign with retrieved key
	error = mCachedKey->ECDSA_sign_msg(message.data(), message.size(), outSignature);
	if (error != CHIP_NO_ERROR)
	{
	return CHIP_ERROR_INTERNAL;
	}

	return CHIP_NO_ERROR;
	}

	Crypto::P256Keypair * Efr32PsaOperationalKeystore::AllocateEphemeralKeypairForCASE()
	{
	EFR32OpaqueP256Keypair * new_key = Platform::New<EFR32OpaqueP256Keypair>();

	if (new_key != nullptr)
	{
	new_key->Create(kEFR32OpaqueKeyIdVolatile, EFR32OpaqueKeyUsages::ECDH_P256);
	}

	return new_key;
	}

	void Efr32PsaOperationalKeystore::ReleaseEphemeralKeypair(Crypto::P256Keypair * keypair)
	{
	Platform::Delete<EFR32OpaqueP256Keypair>((EFR32OpaqueP256Keypair *) keypair);
	}

	} // namespace Internal
	} // namespace DeviceLayer
	} // namespace chip