Matter डिवाइस के टेस्ट सर्टिफ़िकेट बनाएं

हालांकि, यह ज़रूरी नहीं है, लेकिन कुछ टेस्टिंग के मामलों में, नॉन-प्रोडक्शन मैटर सर्टिफ़िकेट बनाने की ज़रूरत होती है.

Google के ईकोसिस्टम की कुछ सुविधाओं का इस्तेमाल, टेस्ट वीआईडी/पीआईडी का इस्तेमाल करके नहीं किया जा सकता. इनमें डिवाइस के ओटीए सॉफ़्टवेयर अपडेट भी शामिल हैं.

इस गाइड में, टेस्टिंग के लिए नॉन-प्रोडक्शन Matter सर्टिफ़िकेट बनाने और उनकी पुष्टि करने का तरीका बताया गया है. सर्टिफ़िकेट के टाइप ये हैं:

  1. सर्टिफ़िकेट का एलान (सीडी)
  2. प्रॉडक्ट अटेस्टेशन इंटरमीडिएट सर्टिफ़िकेट (PAI)
  3. डिवाइस की पुष्टि करने वाला सर्टिफ़िकेट (DAC)

कमीशनिंग की प्रोसेस के दौरान, Matter सर्टिफ़ाइड डिवाइस को खुद की पुष्टि करनी होती है. इसका मतलब है कि उसे यह साबित करना होता है कि वह Matter-सर्टिफ़ाइड असली प्रॉडक्ट है. Matter डिवाइसों के लिए, पुष्टि करने के लिए इस्तेमाल किए गए क्रेडेंशियल में ये शामिल हैं:

  1. प्रमाणित करने वाली कुंजी का पेयर
  2. सर्टिफ़िकेट चेन

डिवाइस अटेस्टेशन सर्टिफ़िकेट (डीएसी), सर्टिफ़िकेट चेन का पहला लिंक होता है. इसकी पुष्टि, प्रॉडक्ट अटेस्टेशन इंटरमीडिएट सर्टिफ़िकेट (पीएआई) करता है. पीएआई की पुष्टि, प्रॉडक्ट अटेस्टेशन अथॉरिटी (पीएए) करती है.

सर्टिफ़िकेट पर उसी समय हस्ताक्षर किए जाते हैं जब पुष्टि करने वाली कुंजी का जोड़ा जनरेट किया जाता है. साथ ही, इन पर एक लेवल ऊपर मौजूद सर्टिफ़िकेट अथॉरिटी की निजी कुंजी का इस्तेमाल करके हस्ताक्षर किए जाते हैं. इससे भरोसे की चेन बनती है. इसलिए, डीएसी सर्टिफ़िकेट पर पीएआई कुंजी से हस्ताक्षर किया जाता है और पीएआई सर्टिफ़िकेट पर पीएए कुंजी से हस्ताक्षर किया जाता है. चेन में सबसे ऊपर होने की वजह से, PAA सर्टिफ़िकेट पर खुद ही हस्ताक्षर किए जाते हैं. भरोसे की यह चेन, फ़ेडरेटेड PAA स्ट्रक्चर बनाती है. इसे डिस्ट्रिब्यूटेड कंप्लायंस लेज़र (डीसीएल) सिंक करता है.

अटेस्टेशन की प्रोसेस और सर्टिफ़िकेशन के बारे में ज़्यादा जानकारी के लिए, अटेस्टेशन के अतिरिक्त दस्तावेज़ और मैसेज और Matter की खास बातें देखें.

Matter SDK इंस्टॉल करना

इन निर्देशों में यह माना गया है कि आपने Matter SDK टूल को इंस्टॉल किया हुआ है और वह काम कर रहा है. ज़्यादा जानकारी के लिए, कृपया Github पर इसका दस्तावेज़ देखें या Matter का इस्तेमाल शुरू करना लेख पढ़ें.

अगर आपके पास hexdump यूटिलिटी xxd नहीं है, तो इसे इंस्टॉल करें. यह टूल, क्रेडेंशियल को C-स्टाइल फ़ॉर्मैट में प्रिंट करने के लिए काम आता है:

sudo apt-get install xxd

chip-cert बनाएं

  1. पक्का करें कि आपके पास SDK का नया वर्शन हो. इन प्रक्रियाओं को GitHub SHA 0b17bce8 पर, v1.0-branch ब्रांच पर टेस्ट किया गया था:

    $ cd connectedhomeip
$ git checkout v1.0-branch
$ git pull

  2. chip-cert बनाएं. यह एक ऐसा टूल है जिसका इस्तेमाल Matter डिवाइसों के क्रेडेंशियल पर कई कार्रवाइयां करने के लिए किया जाता है:

    1. बिल्ड को कॉन्फ़िगर करें:

      $ cd src/credentials
$ source ../../scripts/activate.sh
$ gn gen out

      आउटपुट का उदाहरण gn:

      Done. Made 5774 targets from 289 files in 658ms

    2. बिल्ड चलाएं:

      $ ninja -C out

      आउटपुट का उदाहरण ninja:

      ninja: Entering directory `out'
[2000/2000] stamp obj/default.stamp

अपने सर्टिफ़िकेट मिंट करना

अपने कस्टम VID/PID को एनवायरमेंट वैरिएबल के तौर पर एक्सपोर्ट करें, ताकि कमांड आर्ग्युमेंट में बदलाव करते समय क्लर्क की गड़बड़ी की संभावना कम हो सके:

$ cd ../..
$ export VID=hexVendorId
$ export PID=hexProductId

सीडी जनरेट करना

  1. chip-cert का इस्तेमाल करके सीडी जनरेट करें. फ़िलहाल, कमिश्नर सिर्फ़ यह पुष्टि करता है कि वीआईडी और पीआईडी, डिवाइस की ओर से अन्य जगहों पर दिखाए गए डेटा से मेल खाते हैं या नहीं. जैसे, बुनियादी जानकारी क्लस्टर, डीएसी, और डीएसी ओरिजिन (अगर डिवाइस में यह जानकारी मौजूद है). आपके पास अन्य फ़ील्ड में कोई बदलाव न करने का विकल्प है:

    $ src/credentials/out/chip-cert gen-cd \
  --key credentials/test/certification-declaration/Chip-Test-CD-Signing-Key.pem \
  --cert credentials/test/certification-declaration/Chip-Test-CD-Signing-Cert.pem \
  --out credentials/test/certification-declaration/Chip-Test-CD-${VID}-${PID}.der \
  --format-version "1" \
  --vendor-id "${VID}" \
  --product-id "${PID}" \
  --device-type-id "0x1234" \
  --certificate-id "ZIG20141ZB330001-24" \
  --security-level "0" \
  --security-info "0" \
  --version-number "9876" \
  --certification-type "0"

  2. सीडी की पुष्टि करें. पक्का करें कि इसमें आपका VID/PID (दशमलव फ़ॉर्मैट में) शामिल हो:

    $ src/credentials/out/chip-cert print-cd credentials/test/certification-declaration/Chip-Test-CD-${VID}-${PID}.der

    आउटपुट का उदाहरण:

    SignerKeyId value: hex:62FA823359ACFAA9963E1CFA140ADDF504F37160
0x01, tag[Anonymous]: 0xffffffff, type: Structure (0x15), container:
0x04,     tag[Context Specific]: 0x0, type: Unsigned Fixed Point (0x04), value: 1
0x08,     tag[Context Specific]: 0x1, type: Unsigned Fixed Point (0x04), value: XXXXX // <- VID
0x0A,     tag[Context Specific]: 0x2, type: Array (0x16), container:
0x0D,         tag[Anonymous]: 0xffffffff, type: Unsigned Fixed Point (0x04), value: XXXXX // <- PID
0x12,     tag[Context Specific]: 0x3, type: Unsigned Fixed Point (0x04), value: 4660
0x15,     tag[Context Specific]: 0x4, type: UTF-8 String (0x0c), length: 19, value: "ZIG20141ZB330001-24"
0x2B,     tag[Context Specific]: 0x5, type: Unsigned Fixed Point (0x04), value: 0
0x2E,     tag[Context Specific]: 0x6,type: Unsigned Fixed Point (0x04), value: 0
0x32,     tag[Context Specific]: 0x7, type: Unsigned Fixed Point (0x04), value: 39030
0x35,     tag[Context Specific]: 0x8, type: Unsigned Fixed Point (0x04), value: 0

पीएआई और डीएसी जनरेट करना

इस उदाहरण में, हम Matter के अपने टेस्ट प्रॉडक्ट अटेस्टेशन अथॉरिटी (पीएए) सर्टिफ़िकेट और साइनिंग पासकोड Chip-Test-PAA-NoVID को रूट सर्टिफ़िकेट के तौर पर इस्तेमाल करेंगे. हम इसका इस्तेमाल रूट CA के तौर पर करेंगे, ताकि हम अपना PAI और DAC जनरेट कर सकें.

  1. पीएए का इस्तेमाल करके पीएआई जनरेट करें. PAI में PID की जानकारी शामिल करना ज़रूरी नहीं है. हालांकि, इसे शामिल न करने पर आपको टेस्टिंग के लिए ज़्यादा विकल्प मिलते हैं. अगर आपको अन्य पीआईडी के लिए डीएसी की ज़रूरत है, तो सिर्फ़ डीएसी जनरेट करने वाला चरण पूरा करें:

    $ src/credentials/out/chip-cert gen-att-cert --type i \
  --subject-cn "Matter Test PAI" \
  --subject-vid "${VID}" \
  --valid-from "2021-06-28 14:23:43" \
  --lifetime "4294967295" \
  --ca-key credentials/test/attestation/Chip-Test-PAA-NoVID-Key.pem \
  --ca-cert credentials/test/attestation/Chip-Test-PAA-NoVID-Cert.pem \
  --out-key credentials/test/attestation/"test-PAI-${VID}-key".pem \
  --out credentials/test/attestation/"test-PAI-${VID}-cert".pem

  2. पीएआई का इस्तेमाल करके डीएसी जनरेट करें:

    $ src/credentials/out/chip-cert gen-att-cert --type d \
  --subject-cn "Matter Test DAC 0" \
  --subject-vid "${VID}" \
  --subject-pid "${PID}" \
  --valid-from "2021-06-28 14:23:43" \
  --lifetime "4294967295" \
  --ca-key credentials/test/attestation/"test-PAI-${VID}-key".pem \
  --ca-cert credentials/test/attestation/"test-PAI-${VID}-cert".pem \
  --out-key credentials/test/attestation/"test-DAC-${VID}-${PID}-key".pem \
  --out credentials/test/attestation/"test-DAC-${VID}-${PID}-cert".pem

  3. डीएसी, पीएआई, और पीएए चेन की पुष्टि करें. अगर आउटपुट में कोई गड़बड़ी नहीं दिखती है, तो इसका मतलब है कि प्रमाणपत्र की पुष्टि करने वाली चेन की पुष्टि हो गई है:

    $ src/credentials/out/chip-cert validate-att-cert \
--dac credentials/test/attestation/"test-DAC-${VID}-${PID}-cert".pem \
--pai credentials/test/attestation/"test-PAI-${VID}-cert".pem \
--paa credentials/test/attestation/Chip-Test-PAA-NoVID-Cert.pem

  4. openssl का इस्तेमाल करके, अपनी कुंजियों की जांच की जा सकती है:

    $ openssl ec -noout -text -in \
  credentials/test/attestation/test-DAC-${VID}-${PID}-key.pem

    आउटपुट का उदाहरण:

    read EC key
Private-Key: (256 bit)
priv:
    c9:f2:b3:04:b2:db:0d:6f:cd:c6:be:f3:7b:76:8d:
    8c:01:4e:0b:9e:ce:3e:72:49:3c:0e:35:63:7c:6c:
    6c:d6
pub:
    04:4f:93:ba:3b:bf:63:90:73:98:76:1e:af:87:79:
    11:e6:77:e8:e2:df:a7:49:f1:7c:ac:a8:a6:91:76:
    08:5b:39:ce:6c:72:db:6d:9a:92:b3:ba:05:b0:e8:
    31:a0:bf:36:50:2b:5c:72:55:7f:11:c8:01:ff:3a:
    46:b9:19:60:28
ASN1 OID: prime256v1
NIST CURVE: P-256

  5. जनरेट किए गए सर्टिफ़िकेट की जांच करने के लिए, openssl का इस्तेमाल भी किया जा सकता है:

    $ openssl x509 -noout -text -in \
  credentials/test/attestation/test-DAC-${VID}-${PID}-cert.pem

    आउटपुट का उदाहरण:

    Certificate:
    Data:
        Version: 3 (0x2)
        Serial Number: 2875998130766646679 (0x27e9990fef088d97)
        Signature Algorithm: ecdsa-with-SHA256
        Issuer: CN = Matter Test PAI, 1.3.6.1.4.1.37244.2.1 = hexVendorId
        Validity
            Not Before: Jun 28 14:23:43 2021 GMT
            Not After : Dec 31 23:59:59 9999 GMT
        Subject: CN = Matter Test DAC 0, 1.3.6.1.4.1.37244.2.1 = hexVendorId, 1.3.6.1.4.1.37244.2.2 = hexProductId
        Subject Public Key Info:
            Public Key Algorithm: id-ecPublicKey
                Public-Key: (256 bit)
                pub:
                    04:4f:93:ba:3b:bf:63:90:73:98:76:1e:af:87:79:
                    11:e6:77:e8:e2:df:a7:49:f1:7c:ac:a8:a6:91:76:
                    08:5b:39:ce:6c:72:db:6d:9a:92:b3:ba:05:b0:e8:
                    31:a0:bf:36:50:2b:5c:72:55:7f:11:c8:01:ff:3a:
                    46:b9:19:60:28
                ASN1 OID: prime256v1
                NIST CURVE: P-256
        X509v3 extensions:
            X509v3 Basic Constraints: critical
                CA:FALSE
            X509v3 Key Usage: critical
                Digital Signature
            X509v3 Subject Key Identifier:
                21:0A:CA:B1:B6:5F:17:65:D8:61:19:73:84:1A:9D:52:81:19:C5:39
            X509v3 Authority Key Identifier:
                37:7F:24:9A:73:41:4B:16:6E:6A:42:6E:F5:E8:89:FB:75:F8:77:BB
    Signature Algorithm: ecdsa-with-SHA256
    Signature Value:
        30:45:02:20:38:8f:c5:0d:3e:90:95:dd:7d:7c:e9:5a:05:19:
        1f:2d:14:08:a3:d7:0e:b5:15:6d:d3:b0:0b:f7:b8:28:4d:bf:
        02:21:00:d4:05:30:43:a6:05:00:0e:b9:99:0d:34:3d:75:fe:
        d3:c1:4e:73:ff:e7:05:64:7a:62:8d:2d:38:8f:fd:4d:ad

PAA

खुद हस्ताक्षर किया हुआ PAA जनरेट करने के लिए, इसी तरह की प्रोसेस का इस्तेमाल किया जा सकता है. हालांकि, ऐसा करना ज़रूरी नहीं है.

इसके बजाय, हमने यहां एक मौजूदा सेल्फ-साइन किया गया डेवलपमेंट PAA इस्तेमाल किया है. इसमें VID की जानकारी शामिल नहीं है.

सीडी जनरेट करने के ज़्यादा उदाहरण देखने के लिए, credentials/test/gen-test-cds.sh देखें. इसके अलावा, पीएए, पीएआई, और डीएसी जनरेट करने के ज़्यादा उदाहरण देखने के लिए, credentials/test/gen-test-attestation-certs.sh देखें

सर्टिफ़िकेट बदलना

पीएए और पीएआई को बदलें

  1. नीचे दी गई हेल्पर स्क्रिप्ट चलाएं. यह स्क्रिप्ट, आपके सर्टिफ़िकेट के C-स्टाइल वाले ऐरे जनरेट करने के लिए, CHIP सर्टिफ़िकेट टूल (chip-cert) का इस्तेमाल करती है.

'Embeddable Certificates Helper' स्क्रिप्ट डाउनलोड करें

#!/bin/bash

#
# generate-embeddable-certs.sh script
# —----------------------------------
#
# This script generates self-minted DAC and PAI.
# The output may easily be included in your C++ source code.
#

# Edit this information with your paths and certificates
folder="credentials/test/attestation"
chip_cert_tool="src/credentials/out/chip-cert"
cert_file_der="${folder}/test-PAI-${VID}-cert.der"
cert_file_pem="${folder}/test-PAI-${VID}-cert.pem"
key_file_pem="${folder}/test-PAI-${VID}-key.pem"

type="Pai"

printf "namespace chip {\n"
printf "namespace DevelopmentCerts {\n\n"
printf "#if CHIP_DEVICE_CONFIG_DEVICE_PRODUCT_ID == ${PID}\n\n"

printcert() {
  # convert cert to DER
  if [ -f "${cert_file_der}" ]; then
      rm "${cert_file_der}"
  fi
  "${chip_cert_tool}" convert-cert "${cert_file_pem}" "${cert_file_der}" --x509-der

  printf "// ------------------------------------------------------------ \n"
  printf "// ${type} CERTIFICATE ${cert_file_der} \n\n"

  printf "constexpr uint8_t ${type}_Cert_Array[] = {\n"
  less -f "${cert_file_der}" | od -t x1 -An | sed 's/\ | sed 's/\>/,/g' | sed 's/^/   /g'
  printf "};\n\n"
  printf "ByteSpan k${type}Cert = ByteSpan(${type}_Cert_Array);\n\n"

  printf "// ${type} PUBLIC KEY FROM ${key_file_pem} \n\n"

  printf "constexpr uint8_t ${type}_PublicKey_Array[] = {\n"
  openssl ec -text -noout -in "${key_file_pem}" 2>/dev/null | sed '/ASN1 OID/d' | sed '/NIST CURVE/d' | sed -n '/pub:/,$p' | sed '/pub:/d' | sed 's/\([0-9a-fA-F][0-9a-fA-F]\)/0x\1/g' | sed 's/:/, /g'
  printf "};\n\n"
  printf "ByteSpan k${type}PublicKey = ByteSpan(${type}_PublicKey_Array);\n\n"

  printf "// ${type} PRIVATE KEY FROM ${key_file_pem} \n\n"

  printf "constexpr uint8_t ${type}_PrivateKey_Array[] = {\n"
  openssl ec -text -noout -in "${key_file_pem}" 2>/dev/null | sed '/read EC key/d' | sed '/Private-Key/d' | sed '/priv:/d' | sed '/pub:/,$d' | sed 's/\([0-9a-fA-F][0-9a-fA-F]\)/0x\1/g' | sed 's/:/, /g'
  printf "};\n\n"
  printf "ByteSpan k${type}PrivateKey = ByteSpan(${type}_PrivateKey_Array);\n\n"
}

# generates PAI
printcert

type="Dac"
cert_file_der="${folder}/test-DAC-${VID}-${PID}-cert.der"
cert_file_pem="${folder}/test-DAC-${VID}-${PID}-cert.pem"
key_file_pem="${folder}/test-DAC-${VID}-${PID}-key.pem"

# generates DAC
printcert

printf "#endif // CHIP_DEVICE_CONFIG_DEVICE_PRODUCT_ID\n"
printf "} // namespace DevelopmentCerts\n"
printf "} // namespace chip\n"

  1. PAI और DAC के आउटपुट के कॉन्टेंट को DeviceAttestationCredentialsProvider::GetProductAttestationIntermediateCert के अपने वर्शन में कॉपी करें.

    प्रोडक्शन डिवाइसों पर, पीएआई और डीएसी फ़ैक्ट्री डेटा में होते हैं. वहीं, सीडी को फ़र्मवेयर में ही एम्बेड किया जाता है.

    1. अगर फ़ैक्ट्री डेटा का इस्तेमाल अब तक नहीं किया जा रहा है, तो हो सकता है कि आपको अपना पीएआई src/credentials/examples/ExampleDACs.cpp में रखना पड़े. इस मामले में, जनरेट किए गए कोड को अपनी ExampleDACs.cpp फ़ाइल में जोड़ें:

      ByteSpan kDacCert       = ByteSpan(kDevelopmentDAC_Cert_FFF1_801F);
ByteSpan kDacPrivateKey = ByteSpan(kDevelopmentDAC_PrivateKey_FFF1_801F);
ByteSpan kDacPublicKey  = ByteSpan(kDevelopmentDAC_PublicKey_FFF1_801F);
#endif
} // namespace DevelopmentCerts
} // namespace chip

/* ------------------------------------------ */
/* current end-of-file                        */
/* ------------------------------------------ */

/* ------------------------------------------ */
/* output of creds-codelab.sh script          */
/* ------------------------------------------ */

namespace chip {
namespace DevelopmentCerts {

#if CHIP_DEVICE_CONFIG_DEVICE_PRODUCT_ID == hexProductId

...

ByteSpan kDacPrivateKey = ByteSpan(Dac_PrivateKey_Array);

#endif // CHIP_DEVICE_CONFIG_DEVICE_PRODUCT_ID
} // namespace DevelopmentCerts
} // namespace chip

    2. अगर फ़ैक्ट्री डेटा या कस्टम क्रेडेंशियल प्रोवाइडर का इस्तेमाल किया जा रहा है, तो पक्का करें कि क्रेडेंशियल सही जगहों पर डाले गए हों. अपने प्लैटफ़ॉर्म के बारे में ज़्यादा जानकारी पाने के लिए, SoC की सेवा देने वाली कंपनी से संपर्क करें.

सीडी बदलें

  1. xxd का इस्तेमाल करके, अपनी सीडी फ़ाइल के कॉन्टेंट का टेक्स्ट वर्शन निकालें:

      $ xxd -i credentials/test/certification-declaration/Chip-Test-CD-${VID}-${PID}.der

    आउटपुट का उदाहरण:

      unsigned char credentials_test_certification_declaration_Chip_Test_CD_hexVendorId_hexProductId_der[] = {
    0x30, 0x81, 0xe9, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01,
    0x07, 0x02, 0xa0, 0x81, 0xdb, 0x30, 0x81, 0xd8, 0x02, 0x01, 0x03, 0x31,
    0x0d, 0x30, 0x0b, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04,
    0x02, 0x01, 0x30, 0x45, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d,
    0x01, 0x07, 0x01, 0xa0, 0x38, 0x04, 0x36, 0x15, 0x24, 0x00, 0x01, 0x25,
    0x01, 0xfe, 0xca, 0x36, 0x02, 0x05, 0xce, 0xfa, 0x18, 0x25, 0x03, 0x34,
    0x12, 0x2c, 0x04, 0x13, 0x5a, 0x49, 0x47, 0x32, 0x30, 0x31, 0x34, 0x31,
    0x5a, 0x42, 0x33, 0x33, 0x30, 0x30, 0x30, 0x31, 0x2d, 0x32, 0x34, 0x24,
    0x05, 0x00, 0x24, 0x06, 0x00, 0x25, 0x07, 0x76, 0x98, 0x24, 0x08, 0x00,
    0x18, 0x31, 0x7d, 0x30, 0x7b, 0x02, 0x01, 0x03, 0x80, 0x14, 0x62, 0xfa,
    0x82, 0x33, 0x59, 0xac, 0xfa, 0xa9, 0x96, 0x3e, 0x1c, 0xfa, 0x14, 0x0a,
    0xdd, 0xf5, 0x04, 0xf3, 0x71, 0x60, 0x30, 0x0b, 0x06, 0x09, 0x60, 0x86,
    0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x30, 0x0a, 0x06, 0x08, 0x2a,
    0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x04, 0x47, 0x30, 0x45, 0x02,
    0x20, 0x53, 0x25, 0x03, 0x2c, 0x96, 0x50, 0xb6, 0x64, 0xf4, 0x18, 0xbf,
    0x99, 0x47, 0xf8, 0x9d, 0xe6, 0xeb, 0x43, 0x94, 0xf1, 0xce, 0xb2, 0x61,
    0x00, 0xe0, 0xf9, 0x89, 0xa8, 0x71, 0x82, 0x02, 0x0a, 0x02, 0x21, 0x00,
    0xea, 0x0a, 0x40, 0xab, 0x87, 0xad, 0x7e, 0x25, 0xe1, 0xa1, 0x6c, 0xb1,
    0x12, 0xfa, 0x86, 0xfe, 0xea, 0x8a, 0xaf, 0x4b, 0xc1, 0xf3, 0x6f, 0x09,
    0x85, 0x46, 0x50, 0xb6, 0xd0, 0x55, 0x40, 0xe2
  };
  unsigned int credentials_test_certification_declaration_Chip_Test_CD_hexVendorId_hexProductId_der_len = 236;
  ```

  2. पिछले चरण में निकाले गए टेक्स्ट को उस फ़ाइल में कॉपी करें जिसका इस्तेमाल, सीडी को अपनी बिल्ड में तय करने के लिए किया जाता है. पीएआई और डीएसी की तरह ही, इसे लागू करने का तरीका इस बात पर निर्भर करता है कि आपने किस प्लैटफ़ॉर्म पर ऐप्लिकेशन डेवलप किया है.

अगर क्रेडेंशियल के उदाहरणों का इस्तेमाल किया जा रहा है, तो शायद आपको kCdForAllExamples के कॉन्टेंट को ExampleDACProvider::GetCertificationDeclaration और src/credentials/examples/DeviceAttestationCredsExample.cpp में बदलना होगा:

    const uint8_t kCdForAllExamples[] = {
            0x30, 0x81, 0xe9, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01,
            0x07, 0x02, 0xa0, 0x81, 0xdb, 0x30, 0x81, 0xd8, 0x02, 0x01, 0x03, 0x31,
            0x0d, 0x30, 0x0b, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04,
            0x02, 0x01, 0x30, 0x45, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d,
            0x01, 0x07, 0x01, 0xa0, 0x38, 0x04, 0x36, 0x15, 0x24, 0x00, 0x01, 0x25,
            0x01, 0xfe, 0xca, 0x36, 0x02, 0x05, 0xce, 0xfa, 0x18, 0x25, 0x03, 0x34,
            0x12, 0x2c, 0x04, 0x13, 0x5a, 0x49, 0x47, 0x32, 0x30, 0x31, 0x34, 0x31,
            0x5a, 0x42, 0x33, 0x33, 0x30, 0x30, 0x30, 0x31, 0x2d, 0x32, 0x34, 0x24,
            0x05, 0x00, 0x24, 0x06, 0x00, 0x25, 0x07, 0x76, 0x98, 0x24, 0x08, 0x00,
            0x18, 0x31, 0x7d, 0x30, 0x7b, 0x02, 0x01, 0x03, 0x80, 0x14, 0x62, 0xfa,
            0x82, 0x33, 0x59, 0xac, 0xfa, 0xa9, 0x96, 0x3e, 0x1c, 0xfa, 0x14, 0x0a,
            0xdd, 0xf5, 0x04, 0xf3, 0x71, 0x60, 0x30, 0x0b, 0x06, 0x09, 0x60, 0x86,
            0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x30, 0x0a, 0x06, 0x08, 0x2a,
            0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x04, 0x47, 0x30, 0x45, 0x02,
            0x20, 0x53, 0x25, 0x03, 0x2c, 0x96, 0x50, 0xb6, 0x64, 0xf4, 0x18, 0xbf,
            0x99, 0x47, 0xf8, 0x9d, 0xe6, 0xeb, 0x43, 0x94, 0xf1, 0xce, 0xb2, 0x61,
            0x00, 0xe0, 0xf9, 0x89, 0xa8, 0x71, 0x82, 0x02, 0x0a, 0x02, 0x21, 0x00,
            0xea, 0x0a, 0x40, 0xab, 0x87, 0xad, 0x7e, 0x25, 0xe1, 0xa1, 0x6c, 0xb1,
            0x12, 0xfa, 0x86, 0xfe, 0xea, 0x8a, 0xaf, 0x4b, 0xc1, 0xf3, 0x6f, 0x09,
            0x85, 0x46, 0x50, 0xb6, 0xd0, 0x55, 0x40, 0xe2
        };

टारगेट बनाना

नए क्रेडेंशियल का इस्तेमाल करके, टारगेट बनाएं और उसे फ़्लैश करें. यह सेक्शन, प्लैटफ़ॉर्म के हिसाब से अलग-अलग होता है. ज़्यादा जानकारी के लिए, अपने SoC का दस्तावेज़ या साथ काम करने वाले डिवाइस देखें.

डिवाइस को सेट अप करना

अब Matter डिवाइस को Google Home platform पर चालू करने के लिए, Matter डिवाइस को जोड़ना लेख में बताया गया तरीका अपनाएं.

chip-tool का इस्तेमाल करके समस्याओं को डीबग करना

chip-tool एक अहम टूल है. इससे यह पता लगाया जा सकता है कि आपका डिवाइस सही सर्टिफ़िकेट भेज रहा है या नहीं. इसे बनाने के लिए:

$ cd examples/chip-tool
$ gn gen out/debug
Done. Made 114 targets from 112 files in 157ms
$ ninja -C out/debug
ninja: Entering directory `out/debug'
$ cd ../..

chip-tool को चलाने के दौरान, अतिरिक्त लॉग चालू करने के लिए, --trace_decode 1 फ़्लैग को पास करना न भूलें. इसके अलावा, --paa-trust-store-path फ़्लैग के साथ अपनी PAA फ़ाइल का पाथ पास करना एक अच्छा तरीका है.

इसलिए, BLE का इस्तेमाल करके Thread डिवाइस को चालू करने के लिए, यह कमांड चलाएं:

```
$ examples/chip-tool/out/debug/chip-tool pairing ble-thread 1 \
  hex:Thread_credentials \
  pairing_code \
  discriminator \
  --paa-trust-store-path <path to PAA folder> \
  --trace_decode 1
```

टेस्ट डिवाइसों के मामले में, <PAIRING CODE> 20202021 है और <DISCRIMINATOR> 3840 है.

अपने Google Nest Hub (2nd gen) से Thread नेटवर्क के क्रेडेंशियल पाने के लिए, यह कमांड चलाएं:

$ adb connect border_router_ip_address
$ adb -e shell ot-ctl dataset active -x
$ adb disconnect

वाई-फ़ाई डिवाइस को चालू करने के लिए, ble-wifi विकल्प का इस्तेमाल किया जा सकता है:

$ examples/chip-tool/out/debug/chip-tool pairing ble-wifi 1 "SSID" SSID_password pairing_code discriminator
पीछे जाएं
OTA इमेज तैयार करना
आगे बढ़ें
Matter OTA की जांच करें