1 /*
2  *  Copyright (c) 2016, The OpenThread Authors.
3  *  All rights reserved.
4  *
5  *  Redistribution and use in source and binary forms, with or without
6  *  modification, are permitted provided that the following conditions are met:
7  *  1. Redistributions of source code must retain the above copyright
8  *     notice, this list of conditions and the following disclaimer.
9  *  2. Redistributions in binary form must reproduce the above copyright
10  *     notice, this list of conditions and the following disclaimer in the
11  *     documentation and/or other materials provided with the distribution.
12  *  3. Neither the name of the copyright holder nor the
13  *     names of its contributors may be used to endorse or promote products
14  *     derived from this software without specific prior written permission.
15  *
16  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17  *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
20  *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21  *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22  *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23  *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24  *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25  *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26  *  POSSIBILITY OF SUCH DAMAGE.
27  */
28 
29 /**
30  * @file
31  *   This file implements Thread security material generation.
32  */
33 
34 #include "key_manager.hpp"
35 
36 #include "crypto/hkdf_sha256.hpp"
37 #include "crypto/storage.hpp"
38 #include "instance/instance.hpp"
39 
40 namespace ot {
41 
42 RegisterLogModule("KeyManager");
43 
44 const uint8_t KeyManager::kThreadString[] = {
45     'T', 'h', 'r', 'e', 'a', 'd',
46 };
47 
48 #if OPENTHREAD_CONFIG_RADIO_LINK_TREL_ENABLE
49 const uint8_t KeyManager::kHkdfExtractSaltString[] = {'T', 'h', 'r', 'e', 'a', 'd', 'S', 'e', 'q', 'u', 'e', 'n',
50                                                       'c', 'e', 'M', 'a', 's', 't', 'e', 'r', 'K', 'e', 'y'};
51 
52 const uint8_t KeyManager::kTrelInfoString[] = {'T', 'h', 'r', 'e', 'a', 'd', 'O', 'v', 'e',
53                                                'r', 'I', 'n', 'f', 'r', 'a', 'K', 'e', 'y'};
54 #endif
55 
56 //---------------------------------------------------------------------------------------------------------------------
57 // SecurityPolicy
58 
SetToDefault(void)59 void SecurityPolicy::SetToDefault(void)
60 {
61     Clear();
62     mRotationTime = kDefaultKeyRotationTime;
63     SetToDefaultFlags();
64 }
65 
SetToDefaultFlags(void)66 void SecurityPolicy::SetToDefaultFlags(void)
67 {
68     mObtainNetworkKeyEnabled        = true;
69     mNativeCommissioningEnabled     = true;
70     mRoutersEnabled                 = true;
71     mExternalCommissioningEnabled   = true;
72     mCommercialCommissioningEnabled = false;
73     mAutonomousEnrollmentEnabled    = false;
74     mNetworkKeyProvisioningEnabled  = false;
75     mTobleLinkEnabled               = true;
76     mNonCcmRoutersEnabled           = false;
77     mVersionThresholdForRouting     = 0;
78 }
79 
SetFlags(const uint8_t * aFlags,uint8_t aFlagsLength)80 void SecurityPolicy::SetFlags(const uint8_t *aFlags, uint8_t aFlagsLength)
81 {
82     OT_ASSERT(aFlagsLength > 0);
83 
84     SetToDefaultFlags();
85 
86     mObtainNetworkKeyEnabled        = aFlags[0] & kObtainNetworkKeyMask;
87     mNativeCommissioningEnabled     = aFlags[0] & kNativeCommissioningMask;
88     mRoutersEnabled                 = aFlags[0] & kRoutersMask;
89     mExternalCommissioningEnabled   = aFlags[0] & kExternalCommissioningMask;
90     mCommercialCommissioningEnabled = (aFlags[0] & kCommercialCommissioningMask) == 0;
91     mAutonomousEnrollmentEnabled    = (aFlags[0] & kAutonomousEnrollmentMask) == 0;
92     mNetworkKeyProvisioningEnabled  = (aFlags[0] & kNetworkKeyProvisioningMask) == 0;
93 
94     VerifyOrExit(aFlagsLength > sizeof(aFlags[0]));
95     mTobleLinkEnabled           = aFlags[1] & kTobleLinkMask;
96     mNonCcmRoutersEnabled       = (aFlags[1] & kNonCcmRoutersMask) == 0;
97     mVersionThresholdForRouting = aFlags[1] & kVersionThresholdForRoutingMask;
98 
99 exit:
100     return;
101 }
102 
GetFlags(uint8_t * aFlags,uint8_t aFlagsLength) const103 void SecurityPolicy::GetFlags(uint8_t *aFlags, uint8_t aFlagsLength) const
104 {
105     OT_ASSERT(aFlagsLength > 0);
106 
107     memset(aFlags, 0, aFlagsLength);
108 
109     if (mObtainNetworkKeyEnabled)
110     {
111         aFlags[0] |= kObtainNetworkKeyMask;
112     }
113 
114     if (mNativeCommissioningEnabled)
115     {
116         aFlags[0] |= kNativeCommissioningMask;
117     }
118 
119     if (mRoutersEnabled)
120     {
121         aFlags[0] |= kRoutersMask;
122     }
123 
124     if (mExternalCommissioningEnabled)
125     {
126         aFlags[0] |= kExternalCommissioningMask;
127     }
128 
129     if (!mCommercialCommissioningEnabled)
130     {
131         aFlags[0] |= kCommercialCommissioningMask;
132     }
133 
134     if (!mAutonomousEnrollmentEnabled)
135     {
136         aFlags[0] |= kAutonomousEnrollmentMask;
137     }
138 
139     if (!mNetworkKeyProvisioningEnabled)
140     {
141         aFlags[0] |= kNetworkKeyProvisioningMask;
142     }
143 
144     VerifyOrExit(aFlagsLength > sizeof(aFlags[0]));
145 
146     if (mTobleLinkEnabled)
147     {
148         aFlags[1] |= kTobleLinkMask;
149     }
150 
151     if (!mNonCcmRoutersEnabled)
152     {
153         aFlags[1] |= kNonCcmRoutersMask;
154     }
155 
156     aFlags[1] |= kReservedMask;
157     aFlags[1] |= mVersionThresholdForRouting;
158 
159 exit:
160     return;
161 }
162 
163 //---------------------------------------------------------------------------------------------------------------------
164 // KeyManager
165 
KeyManager(Instance & aInstance)166 KeyManager::KeyManager(Instance &aInstance)
167     : InstanceLocator(aInstance)
168     , mKeySequence(0)
169     , mMleFrameCounter(0)
170     , mStoredMacFrameCounter(0)
171     , mStoredMleFrameCounter(0)
172     , mHoursSinceKeyRotation(0)
173     , mKeySwitchGuardTime(kDefaultKeySwitchGuardTime)
174     , mKeySwitchGuardTimer(0)
175     , mKeyRotationTimer(aInstance)
176     , mKekFrameCounter(0)
177     , mIsPskcSet(false)
178 {
179     otPlatCryptoInit();
180 
181 #if OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE
182     {
183         NetworkKey networkKey;
184 
185         mNetworkKeyRef = Crypto::Storage::kInvalidKeyRef;
186         mPskcRef       = Crypto::Storage::kInvalidKeyRef;
187 
188         IgnoreError(networkKey.GenerateRandom());
189         StoreNetworkKey(networkKey, /* aOverWriteExisting */ false);
190     }
191 #else
192     IgnoreError(mNetworkKey.GenerateRandom());
193     mPskc.Clear();
194 #endif
195 
196     mMacFrameCounters.Reset();
197 }
198 
Start(void)199 void KeyManager::Start(void)
200 {
201     mKeySwitchGuardTimer = 0;
202     ResetKeyRotationTimer();
203 }
204 
Stop(void)205 void KeyManager::Stop(void) { mKeyRotationTimer.Stop(); }
206 
SetPskc(const Pskc & aPskc)207 void KeyManager::SetPskc(const Pskc &aPskc)
208 {
209 #if OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE
210     if (Crypto::Storage::IsKeyRefValid(mPskcRef))
211     {
212         Pskc pskc;
213 
214         GetPskc(pskc);
215         VerifyOrExit(aPskc != pskc, Get<Notifier>().SignalIfFirst(kEventPskcChanged));
216     }
217 
218     StorePskc(aPskc);
219     Get<Notifier>().Signal(kEventPskcChanged);
220 #else
221     SuccessOrExit(Get<Notifier>().Update(mPskc, aPskc, kEventPskcChanged));
222 #endif
223 
224 exit:
225     mIsPskcSet = true;
226 }
227 
ResetFrameCounters(void)228 void KeyManager::ResetFrameCounters(void)
229 {
230     Router *parent;
231 
232     // reset parent frame counters
233     parent = &Get<Mle::MleRouter>().GetParent();
234     parent->SetKeySequence(0);
235     parent->GetLinkFrameCounters().Reset();
236     parent->SetLinkAckFrameCounter(0);
237     parent->SetMleFrameCounter(0);
238 
239 #if OPENTHREAD_FTD
240     // reset router frame counters
241     for (Router &router : Get<RouterTable>())
242     {
243         router.SetKeySequence(0);
244         router.GetLinkFrameCounters().Reset();
245         router.SetLinkAckFrameCounter(0);
246         router.SetMleFrameCounter(0);
247     }
248 
249     // reset child frame counters
250     for (Child &child : Get<ChildTable>().Iterate(Child::kInStateAnyExceptInvalid))
251     {
252         child.SetKeySequence(0);
253         child.GetLinkFrameCounters().Reset();
254         child.SetLinkAckFrameCounter(0);
255         child.SetMleFrameCounter(0);
256     }
257 #endif
258 }
259 
SetNetworkKey(const NetworkKey & aNetworkKey)260 void KeyManager::SetNetworkKey(const NetworkKey &aNetworkKey)
261 {
262 #if OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE
263     if (Crypto::Storage::IsKeyRefValid(mNetworkKeyRef))
264     {
265         NetworkKey networkKey;
266 
267         GetNetworkKey(networkKey);
268         VerifyOrExit(networkKey != aNetworkKey, Get<Notifier>().SignalIfFirst(kEventNetworkKeyChanged));
269     }
270 
271     StoreNetworkKey(aNetworkKey, /* aOverWriteExisting */ true);
272     Get<Notifier>().Signal(kEventNetworkKeyChanged);
273 #else
274     SuccessOrExit(Get<Notifier>().Update(mNetworkKey, aNetworkKey, kEventNetworkKeyChanged));
275 #endif
276 
277     Get<Notifier>().Signal(kEventThreadKeySeqCounterChanged);
278 
279     mKeySequence = 0;
280     UpdateKeyMaterial();
281     ResetFrameCounters();
282 
283 exit:
284     return;
285 }
286 
ComputeKeys(uint32_t aKeySequence,HashKeys & aHashKeys) const287 void KeyManager::ComputeKeys(uint32_t aKeySequence, HashKeys &aHashKeys) const
288 {
289     Crypto::HmacSha256 hmac;
290     uint8_t            keySequenceBytes[sizeof(uint32_t)];
291     Crypto::Key        cryptoKey;
292 
293 #if OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE
294     cryptoKey.SetAsKeyRef(mNetworkKeyRef);
295 #else
296     cryptoKey.Set(mNetworkKey.m8, NetworkKey::kSize);
297 #endif
298 
299     hmac.Start(cryptoKey);
300 
301     BigEndian::WriteUint32(aKeySequence, keySequenceBytes);
302     hmac.Update(keySequenceBytes);
303     hmac.Update(kThreadString);
304 
305     hmac.Finish(aHashKeys.mHash);
306 }
307 
308 #if OPENTHREAD_CONFIG_RADIO_LINK_TREL_ENABLE
ComputeTrelKey(uint32_t aKeySequence,Mac::Key & aKey) const309 void KeyManager::ComputeTrelKey(uint32_t aKeySequence, Mac::Key &aKey) const
310 {
311     Crypto::HkdfSha256 hkdf;
312     uint8_t            salt[sizeof(uint32_t) + sizeof(kHkdfExtractSaltString)];
313     Crypto::Key        cryptoKey;
314 
315 #if OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE
316     cryptoKey.SetAsKeyRef(mNetworkKeyRef);
317 #else
318     cryptoKey.Set(mNetworkKey.m8, NetworkKey::kSize);
319 #endif
320 
321     BigEndian::WriteUint32(aKeySequence, salt);
322     memcpy(salt + sizeof(uint32_t), kHkdfExtractSaltString, sizeof(kHkdfExtractSaltString));
323 
324     hkdf.Extract(salt, sizeof(salt), cryptoKey);
325     hkdf.Expand(kTrelInfoString, sizeof(kTrelInfoString), aKey.m8, Mac::Key::kSize);
326 }
327 #endif
328 
UpdateKeyMaterial(void)329 void KeyManager::UpdateKeyMaterial(void)
330 {
331     HashKeys hashKeys;
332 
333     ComputeKeys(mKeySequence, hashKeys);
334 
335     mMleKey.SetFrom(hashKeys.GetMleKey());
336 
337 #if OPENTHREAD_CONFIG_RADIO_LINK_IEEE_802_15_4_ENABLE
338     {
339         Mac::KeyMaterial curKey;
340         Mac::KeyMaterial prevKey;
341         Mac::KeyMaterial nextKey;
342 
343         curKey.SetFrom(hashKeys.GetMacKey(), kExportableMacKeys);
344 
345         ComputeKeys(mKeySequence - 1, hashKeys);
346         prevKey.SetFrom(hashKeys.GetMacKey(), kExportableMacKeys);
347 
348         ComputeKeys(mKeySequence + 1, hashKeys);
349         nextKey.SetFrom(hashKeys.GetMacKey(), kExportableMacKeys);
350 
351         Get<Mac::SubMac>().SetMacKey(Mac::Frame::kKeyIdMode1, (mKeySequence & 0x7f) + 1, prevKey, curKey, nextKey);
352     }
353 #endif
354 
355 #if OPENTHREAD_CONFIG_RADIO_LINK_TREL_ENABLE
356     {
357         Mac::Key key;
358 
359         ComputeTrelKey(mKeySequence, key);
360         mTrelKey.SetFrom(key);
361     }
362 #endif
363 }
364 
SetCurrentKeySequence(uint32_t aKeySequence,KeySeqUpdateFlags aFlags)365 void KeyManager::SetCurrentKeySequence(uint32_t aKeySequence, KeySeqUpdateFlags aFlags)
366 {
367     VerifyOrExit(aKeySequence != mKeySequence, Get<Notifier>().SignalIfFirst(kEventThreadKeySeqCounterChanged));
368 
369     if (aFlags & kApplySwitchGuard)
370     {
371         VerifyOrExit(mKeySwitchGuardTimer == 0);
372     }
373 
374     mKeySequence = aKeySequence;
375     UpdateKeyMaterial();
376 
377     SetAllMacFrameCounters(0, /* aSetIfLarger */ false);
378     mMleFrameCounter = 0;
379 
380     ResetKeyRotationTimer();
381 
382     if (aFlags & kResetGuardTimer)
383     {
384         mKeySwitchGuardTimer = mKeySwitchGuardTime;
385     }
386 
387     Get<Notifier>().Signal(kEventThreadKeySeqCounterChanged);
388 
389 exit:
390     return;
391 }
392 
GetTemporaryMleKey(uint32_t aKeySequence)393 const Mle::KeyMaterial &KeyManager::GetTemporaryMleKey(uint32_t aKeySequence)
394 {
395     HashKeys hashKeys;
396 
397     ComputeKeys(aKeySequence, hashKeys);
398     mTemporaryMleKey.SetFrom(hashKeys.GetMleKey());
399 
400     return mTemporaryMleKey;
401 }
402 
403 #if OPENTHREAD_CONFIG_WAKEUP_END_DEVICE_ENABLE
GetTemporaryMacKey(uint32_t aKeySequence)404 const Mle::KeyMaterial &KeyManager::GetTemporaryMacKey(uint32_t aKeySequence)
405 {
406     HashKeys hashKeys;
407 
408     ComputeKeys(aKeySequence, hashKeys);
409     mTemporaryMacKey.SetFrom(hashKeys.GetMacKey());
410 
411     return mTemporaryMacKey;
412 }
413 #endif
414 
415 #if OPENTHREAD_CONFIG_RADIO_LINK_TREL_ENABLE
GetTemporaryTrelMacKey(uint32_t aKeySequence)416 const Mac::KeyMaterial &KeyManager::GetTemporaryTrelMacKey(uint32_t aKeySequence)
417 {
418     Mac::Key key;
419 
420     ComputeTrelKey(aKeySequence, key);
421     mTemporaryTrelKey.SetFrom(key);
422 
423     return mTemporaryTrelKey;
424 }
425 #endif
426 
SetAllMacFrameCounters(uint32_t aFrameCounter,bool aSetIfLarger)427 void KeyManager::SetAllMacFrameCounters(uint32_t aFrameCounter, bool aSetIfLarger)
428 {
429     mMacFrameCounters.SetAll(aFrameCounter);
430 
431 #if OPENTHREAD_CONFIG_RADIO_LINK_IEEE_802_15_4_ENABLE
432     Get<Mac::SubMac>().SetFrameCounter(aFrameCounter, aSetIfLarger);
433 #else
434     OT_UNUSED_VARIABLE(aSetIfLarger);
435 #endif
436 }
437 
438 #if OPENTHREAD_CONFIG_RADIO_LINK_IEEE_802_15_4_ENABLE
MacFrameCounterUsed(uint32_t aMacFrameCounter)439 void KeyManager::MacFrameCounterUsed(uint32_t aMacFrameCounter)
440 {
441     // This is callback from `SubMac` to indicate that a frame
442     // counter value is used for tx. We ensure to handle it
443     // even if it is called out of order.
444 
445     VerifyOrExit(mMacFrameCounters.Get154() <= aMacFrameCounter);
446 
447     mMacFrameCounters.Set154(aMacFrameCounter + 1);
448 
449     if (mMacFrameCounters.Get154() >= mStoredMacFrameCounter)
450     {
451         IgnoreError(Get<Mle::MleRouter>().Store());
452     }
453 
454 exit:
455     return;
456 }
457 #else
MacFrameCounterUsed(uint32_t)458 void KeyManager::MacFrameCounterUsed(uint32_t) {}
459 #endif
460 
461 #if OPENTHREAD_CONFIG_RADIO_LINK_TREL_ENABLE
IncrementTrelMacFrameCounter(void)462 void KeyManager::IncrementTrelMacFrameCounter(void)
463 {
464     mMacFrameCounters.IncrementTrel();
465 
466     if (mMacFrameCounters.GetTrel() >= mStoredMacFrameCounter)
467     {
468         IgnoreError(Get<Mle::MleRouter>().Store());
469     }
470 }
471 #endif
472 
IncrementMleFrameCounter(void)473 void KeyManager::IncrementMleFrameCounter(void)
474 {
475     mMleFrameCounter++;
476 
477     if (mMleFrameCounter >= mStoredMleFrameCounter)
478     {
479         IgnoreError(Get<Mle::MleRouter>().Store());
480     }
481 }
482 
SetKek(const Kek & aKek)483 void KeyManager::SetKek(const Kek &aKek)
484 {
485     mKek.SetFrom(aKek, /* aIsExportable */ true);
486     mKekFrameCounter = 0;
487 }
488 
SetSecurityPolicy(const SecurityPolicy & aSecurityPolicy)489 void KeyManager::SetSecurityPolicy(const SecurityPolicy &aSecurityPolicy)
490 {
491     SecurityPolicy newPolicy = aSecurityPolicy;
492 
493     if (newPolicy.mRotationTime < SecurityPolicy::kMinKeyRotationTime)
494     {
495         newPolicy.mRotationTime = SecurityPolicy::kMinKeyRotationTime;
496         LogNote("Key Rotation Time in SecurityPolicy is set to min allowed value of %u", newPolicy.mRotationTime);
497     }
498 
499     if (newPolicy.mRotationTime != mSecurityPolicy.mRotationTime)
500     {
501         uint32_t newGuardTime = newPolicy.mRotationTime;
502 
503         // Calculations are done using a `uint32_t` variable to prevent
504         // potential overflow.
505 
506         newGuardTime *= kKeySwitchGuardTimePercentage;
507         newGuardTime /= 100;
508 
509         mKeySwitchGuardTime = static_cast<uint16_t>(newGuardTime);
510     }
511 
512     IgnoreError(Get<Notifier>().Update(mSecurityPolicy, newPolicy, kEventSecurityPolicyChanged));
513 
514     CheckForKeyRotation();
515 }
516 
ResetKeyRotationTimer(void)517 void KeyManager::ResetKeyRotationTimer(void)
518 {
519     mHoursSinceKeyRotation = 0;
520     mKeyRotationTimer.Start(Time::kOneHourInMsec);
521 }
522 
HandleKeyRotationTimer(void)523 void KeyManager::HandleKeyRotationTimer(void)
524 {
525     mKeyRotationTimer.Start(Time::kOneHourInMsec);
526 
527     mHoursSinceKeyRotation++;
528 
529     if (mKeySwitchGuardTimer > 0)
530     {
531         mKeySwitchGuardTimer--;
532     }
533 
534     CheckForKeyRotation();
535 }
536 
CheckForKeyRotation(void)537 void KeyManager::CheckForKeyRotation(void)
538 {
539     if (mHoursSinceKeyRotation >= mSecurityPolicy.mRotationTime)
540     {
541         SetCurrentKeySequence(mKeySequence + 1, kForceUpdate | kResetGuardTimer);
542     }
543 }
544 
GetNetworkKey(NetworkKey & aNetworkKey) const545 void KeyManager::GetNetworkKey(NetworkKey &aNetworkKey) const
546 {
547 #if OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE
548     if (Crypto::Storage::HasKey(mNetworkKeyRef))
549     {
550         size_t keyLen;
551 
552         SuccessOrAssert(Crypto::Storage::ExportKey(mNetworkKeyRef, aNetworkKey.m8, NetworkKey::kSize, keyLen));
553         OT_ASSERT(keyLen == NetworkKey::kSize);
554     }
555     else
556     {
557         aNetworkKey.Clear();
558     }
559 #else
560     aNetworkKey = mNetworkKey;
561 #endif
562 }
563 
GetPskc(Pskc & aPskc) const564 void KeyManager::GetPskc(Pskc &aPskc) const
565 {
566 #if OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE
567     if (Crypto::Storage::HasKey(mPskcRef))
568     {
569         size_t keyLen;
570 
571         SuccessOrAssert(Crypto::Storage::ExportKey(mPskcRef, aPskc.m8, Pskc::kSize, keyLen));
572         OT_ASSERT(keyLen == Pskc::kSize);
573     }
574     else
575     {
576         aPskc.Clear();
577     }
578 #else
579     aPskc = mPskc;
580 #endif
581 }
582 
583 #if OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE
584 
StoreNetworkKey(const NetworkKey & aNetworkKey,bool aOverWriteExisting)585 void KeyManager::StoreNetworkKey(const NetworkKey &aNetworkKey, bool aOverWriteExisting)
586 {
587     NetworkKeyRef keyRef;
588 
589     keyRef = Get<Crypto::Storage::KeyRefManager>().KeyRefFor(Crypto::Storage::KeyRefManager::kNetworkKey);
590 
591     if (!aOverWriteExisting)
592     {
593         // Check if there is already a network key stored in ITS. If
594         // stored, and we are not overwriting the existing key,
595         // return without doing anything.
596         if (Crypto::Storage::HasKey(keyRef))
597         {
598             ExitNow();
599         }
600     }
601 
602     Crypto::Storage::DestroyKey(keyRef);
603 
604     SuccessOrAssert(Crypto::Storage::ImportKey(keyRef, Crypto::Storage::kKeyTypeHmac,
605                                                Crypto::Storage::kKeyAlgorithmHmacSha256,
606                                                Crypto::Storage::kUsageSignHash | Crypto::Storage::kUsageExport,
607                                                Crypto::Storage::kTypePersistent, aNetworkKey.m8, NetworkKey::kSize));
608 
609 exit:
610     if (mNetworkKeyRef != keyRef)
611     {
612         Crypto::Storage::DestroyKey(mNetworkKeyRef);
613     }
614 
615     mNetworkKeyRef = keyRef;
616 }
617 
StorePskc(const Pskc & aPskc)618 void KeyManager::StorePskc(const Pskc &aPskc)
619 {
620     PskcRef keyRef = Get<Crypto::Storage::KeyRefManager>().KeyRefFor(Crypto::Storage::KeyRefManager::kPskc);
621 
622     Crypto::Storage::DestroyKey(keyRef);
623 
624     SuccessOrAssert(Crypto::Storage::ImportKey(keyRef, Crypto::Storage::kKeyTypeRaw,
625                                                Crypto::Storage::kKeyAlgorithmVendor, Crypto::Storage::kUsageExport,
626                                                Crypto::Storage::kTypePersistent, aPskc.m8, Pskc::kSize));
627 
628     if (mPskcRef != keyRef)
629     {
630         Crypto::Storage::DestroyKey(mPskcRef);
631     }
632 
633     mPskcRef = keyRef;
634 }
635 
SetPskcRef(PskcRef aKeyRef)636 void KeyManager::SetPskcRef(PskcRef aKeyRef)
637 {
638     VerifyOrExit(mPskcRef != aKeyRef, Get<Notifier>().SignalIfFirst(kEventPskcChanged));
639 
640     Crypto::Storage::DestroyKey(mPskcRef);
641 
642     mPskcRef = aKeyRef;
643     Get<Notifier>().Signal(kEventPskcChanged);
644 
645 exit:
646     mIsPskcSet = true;
647 }
648 
SetNetworkKeyRef(otNetworkKeyRef aKeyRef)649 void KeyManager::SetNetworkKeyRef(otNetworkKeyRef aKeyRef)
650 {
651     VerifyOrExit(mNetworkKeyRef != aKeyRef, Get<Notifier>().SignalIfFirst(kEventNetworkKeyChanged));
652 
653     Crypto::Storage::DestroyKey(mNetworkKeyRef);
654 
655     mNetworkKeyRef = aKeyRef;
656     Get<Notifier>().Signal(kEventNetworkKeyChanged);
657     Get<Notifier>().Signal(kEventThreadKeySeqCounterChanged);
658     mKeySequence = 0;
659     UpdateKeyMaterial();
660     ResetFrameCounters();
661 
662 exit:
663     return;
664 }
665 
DestroyTemporaryKeys(void)666 void KeyManager::DestroyTemporaryKeys(void)
667 {
668     mMleKey.Clear();
669     mKek.Clear();
670     Get<Mac::SubMac>().ClearMacKeys();
671     Get<Mac::Mac>().ClearMode2Key();
672 }
673 
DestroyPersistentKeys(void)674 void KeyManager::DestroyPersistentKeys(void) { Get<Crypto::Storage::KeyRefManager>().DestroyPersistentKeys(); }
675 
676 #endif // OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE
677 
678 } // namespace ot
679