Line data    Source code

       1              : /*
       2              :  *
       3              :  *    Copyright (c) 2022 Project CHIP Authors
       4              :  *    All rights reserved.
       5              :  *
       6              :  *    Licensed under the Apache License, Version 2.0 (the "License");
       7              :  *    you may not use this file except in compliance with the License.
       8              :  *    You may obtain a copy of the License at
       9              :  *
      10              :  *        http://www.apache.org/licenses/LICENSE-2.0
      11              :  *
      12              :  *    Unless required by applicable law or agreed to in writing, software
      13              :  *    distributed under the License is distributed on an "AS IS" BASIS,
      14              :  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      15              :  *    See the License for the specific language governing permissions and
      16              :  *    limitations under the License.
      17              :  */
      18              : 
      19              : #pragma once
      20              : 
      21              : #include <credentials/GroupDataProvider.h>
      22              : #include <crypto/CHIPCryptoPAL.h>
      23              : 
      24              : namespace chip {
      25              : 
      26              : namespace GroupTesting {
      27              : 
      28              : class DefaultIpkValue
      29              : {
      30              : public:
      31              :     DefaultIpkValue() {}
      32              : 
      33            0 :     static ByteSpan GetDefaultIpk()
      34              :     {
      35              :         static const uint8_t mDefaultIpk[Crypto::CHIP_CRYPTO_SYMMETRIC_KEY_LENGTH_BYTES] = {
      36              :             't', 'e', 'm', 'p', 'o', 'r', 'a', 'r', 'y', ' ', 'i', 'p', 'k', ' ', '0', '1'
      37              :         };
      38            0 :         return ByteSpan(mDefaultIpk);
      39              :     }
      40              : };
      41              : 
      42              : inline CHIP_ERROR InitData(chip::Credentials::GroupDataProvider * provider, chip::FabricIndex fabric_index,
      43              :                            const ByteSpan & compressed_fabric_id)
      44              : {
      45              :     static const chip::GroupId kGroup1   = 0x0101;
      46              :     static const chip::GroupId kGroup2   = 0x0102;
      47              :     static const chip::GroupId kGroup3   = 0x0103;
      48              :     static const chip::KeysetId kKeySet1 = 0x01a1;
      49              :     static const chip::KeysetId kKeySet2 = 0x01a2;
      50              :     static const chip::KeysetId kKeySet3 = 0x01a3;
      51              : 
      52              :     // Groups
      53              : 
      54              :     const chip::Credentials::GroupDataProvider::GroupInfo group1(kGroup1, "Group #1");
      55              :     ReturnErrorOnFailure(provider->SetGroupInfo(fabric_index, group1));
      56              :     ReturnErrorOnFailure(provider->AddEndpoint(fabric_index, group1.group_id, 1));
      57              : 
      58              :     const chip::Credentials::GroupDataProvider::GroupInfo group2(kGroup2, "Group #2");
      59              :     ReturnErrorOnFailure(provider->SetGroupInfo(fabric_index, group2));
      60              :     ReturnErrorOnFailure(provider->AddEndpoint(fabric_index, group2.group_id, 0));
      61              : 
      62              :     const chip::Credentials::GroupDataProvider::GroupInfo group3(kGroup3, "Group #3");
      63              :     ReturnErrorOnFailure(provider->SetGroupInfo(fabric_index, group3));
      64              :     ReturnErrorOnFailure(provider->AddEndpoint(fabric_index, group3.group_id, 0));
      65              : 
      66              :     // Key Sets
      67              : 
      68              :     chip::Credentials::GroupDataProvider::KeySet keyset1(kKeySet1,
      69              :                                                          chip::Credentials::GroupDataProvider::SecurityPolicy::kCacheAndSync, 3);
      70              :     const chip::Credentials::GroupDataProvider::EpochKey epoch_keys1[] = {
      71              :         { 1110000, { 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf } },
      72              :         { 1110001, { 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf } },
      73              :         { 1110002, { 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf } },
      74              :     };
      75              :     memcpy(keyset1.epoch_keys, epoch_keys1, sizeof(epoch_keys1));
      76              :     CHIP_ERROR err = provider->SetKeySet(fabric_index, compressed_fabric_id, keyset1);
      77              :     ReturnErrorOnFailure(err);
      78              : 
      79              :     chip::Credentials::GroupDataProvider::KeySet keyset2(kKeySet2,
      80              :                                                          chip::Credentials::GroupDataProvider::SecurityPolicy::kCacheAndSync, 3);
      81              :     const chip::Credentials::GroupDataProvider::EpochKey epoch_keys2[] = {
      82              :         { 2220000, { 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf } },
      83              :         { 2220001, { 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef } },
      84              :         { 2220002, { 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff } },
      85              :     };
      86              :     memcpy(keyset2.epoch_keys, epoch_keys2, sizeof(epoch_keys2));
      87              :     err = provider->SetKeySet(fabric_index, compressed_fabric_id, keyset2);
      88              :     ReturnErrorOnFailure(err);
      89              : 
      90              :     chip::Credentials::GroupDataProvider::KeySet keyset3(kKeySet3,
      91              :                                                          chip::Credentials::GroupDataProvider::SecurityPolicy::kTrustFirst, 3);
      92              :     const chip::Credentials::GroupDataProvider::EpochKey epoch_keys3[] = {
      93              :         { 2220000, { 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf } },
      94              :         { 2220001, { 0xd1, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf } },
      95              :         { 2220002, { 0xd2, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf } },
      96              :     };
      97              :     memcpy(keyset3.epoch_keys, epoch_keys3, sizeof(epoch_keys3));
      98              :     err = provider->SetKeySet(fabric_index, compressed_fabric_id, keyset3);
      99              :     ReturnErrorOnFailure(err);
     100              : 
     101              :     provider->SetGroupKeyAt(fabric_index, 0, chip::Credentials::GroupDataProvider::GroupKey(kGroup1, kKeySet1));
     102              :     provider->SetGroupKeyAt(fabric_index, 1, chip::Credentials::GroupDataProvider::GroupKey(kGroup2, kKeySet2));
     103              :     provider->SetGroupKeyAt(fabric_index, 2, chip::Credentials::GroupDataProvider::GroupKey(kGroup3, kKeySet3));
     104              : 
     105              :     return CHIP_NO_ERROR;
     106              : }
     107              : 
     108              : } // namespace GroupTesting
     109              : 
     110              : } // namespace chip