יצירת אישורי בדיקה למכשירי Matter

בתרחישי פיתוח מסוימים, כמו בדיקות OTA, צריך ליצור אישורי Matter שלא מיועדים לסביבת הייצור.

אי אפשר להשתמש ב-VID או ב-PID לבדיקה כדי להפעיל תכונות מסוימות בסביבה העסקית של Google, כולל עדכוני תוכנה של המכשיר ב-OTA.

במדריך הזה מוסבר איך ליצור ולאמת אישורי Matter שלא מיועדים לסביבת הייצור, כדי להשתמש בהם לבדיקה. סוגי האישורים הם:

1. הצהרת האישור (CD)
2. אישור ביניים לאימות מוצר (PAI)
3. אישור אימות המכשיר (DAC)

במהלך תהליך ההפעלה, מכשיר עם אישור Matter צריך לאמת את עצמו, כלומר להוכיח שהוא מוצר מקורי עם אישור Matter. פרטי הכניסה שמשמשים לאימות ב-Matter מכשירים כוללים:

1. זוג מפתחות אימות (attestation)
2. שרשרת אישורים

אישור אימות המכשיר (DAC) הוא החוליה הראשונה בשרשרת האישורים, והוא מאומת על ידי אישור הביניים לאימות המוצר (PAI), שמאומת על ידי רשות אימות המוצר (PAA).

האישורים נחתמים באותו זמן שבו נוצר זוג מפתחות האימות, והם נחתמים באמצעות המפתח הפרטי של רשות האישורים ברמה אחת מעל, וכך נוצרת שרשרת אמון. לכן, אישור DAC נחתם על ידי מפתח PAI, ואישור PAI נחתם על ידי מפתח PAA. אישורי PAA נמצאים בראש השרשרת, ולכן הם חתומים באופן עצמי. שרשרת האמון הזו יוצרת מבנה מאוחד של PAA, שמסונכרן על ידי Distributed Compliance Ledger‏ (DCL).

מידע נוסף על תהליך האישור ועל הצהרות האישור (CD) זמין במאמר מסמכים והודעות נוספים בנושא אישור ובמפרט של Matter.

התקנת Matter SDK

ההוראות האלה מבוססות על ההנחה שהתקנתם את ה-SDK של Matter. למידע נוסף, אפשר לעיין במסמכי התיעוד של Matter ב-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. Build chip-cert, הכלי שמשמש לכמה פעולות שקשורות לפרטי הכניסה במכשירי Matter:

   1. מגדירים את ה-build:

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

      פלט gn לדוגמה:

      Done. Made 5774 targets from 289 files in 658ms
      

   2. מריצים את ה-build:

      $ ninja -C out
      

      פלט ninja לדוגמה:

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

הנפקת האישורים

מייצאים את ה-VID/PID המותאם אישית כמשתני סביבה כדי להקטין את הסיכויים לשגיאות הקלדה כשעורכים את הארגומנטים של הפקודה:

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

יצירת CD

1. יוצרים את ה-CD באמצעות chip-cert. נכון לעכשיו, הנציב רק מאמת שה-VID וה-PID תואמים לנתונים שנחשפים במקומות אחרים על ידי המכשיר: אשכול המידע הבסיסי, DAC ומקור ה-DAC (אם יש לו). אפשר להשאיר את שאר השדות ללא שינוי:

   $ 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. מאמתים את ה-CD. מוודאים שהוא מכיל את ה-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
   

יצירת PAI ו-DAC

בדוגמה הזו נשתמש באישור ובמפתח החתימה של רשות האישורים לבדיקת מוצרים (PAA) של Matter, Chip-Test-PAA-NoVID, בתור אישור הבסיס. נשתמש בה כרשות אישורים ברמה הבסיסית כדי ליצור PAI ו-DAC משלנו.

1. יוצרים את ה-PAI באמצעות ה-PAA. אפשר לכלול את פרטי ה-PID ב-PAI, אבל אם משמיטים אותם, יש יותר גמישות בבדיקות. אם אתם צריכים DACs למזהי PID נוספים, אתם יכולים לבצע רק את שלב יצירת ה-DAC:

   $ 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. יוצרים את ה-DAC באמצעות ה-PAI:

   $ 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. מאמתים את שרשרת ה-DAC, ה-PAI וה-PAA. אם לא מופיעות שגיאות בפלט, סימן ששרשרת האישורים אומתה בהצלחה:

   $ 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.

דוגמאות נוספות ליצירת CD זמינות במאמר credentials/test/gen-test-cds.sh, ודוגמאות נוספות ליצירת PAA,‏ PAI ו-DAC זמינות במאמר credentials/test/gen-test-attestation-certs.sh.

החלפת האישורים

החלפת ה-PAA וה-PAI

1. מריצים את סקריפט העזר הבא, שמשתמש בכלי האישורים של CHIP‏ (chip-cert) כדי ליצור מערכים בסגנון C של האישורים.

הורדת הסקריפט 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.

   במכשירים בסביבת הייצור, ה-PAI וה-DAC נמצאים בנתוני היצרן, וה-CD מוטמע בקושחה עצמה.

   1. אם אתם עדיין לא משתמשים בנתוני המפעל, כדאי להציב את ה-PAI ב-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. אם אתם משתמשים ב-Factory Data או בספק פרטי כניסה בהתאמה אישית, הקפידו להוסיף את פרטי הכניסה במיקומים המתאימים. כדאי לבדוק עם ספק ה-SoC את הפרטים הספציפיים של הפלטפורמה שלכם.

החלפת ה-CD

1. מחלצים ייצוג טקסט של תוכן קובץ ה-CD באמצעות 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. מעתיקים את הטקסט שחילצתם בשלב הקודם לקובץ שמשמש להגדרת ה-CD ב-build. כמו במקרה של PAI ו-DAC, האופן שבו עושים את זה תלוי בפלטפורמה שבה אתם מפתחים.

אם אתם משתמשים בדוגמאות של פרטי הכניסה, כנראה תרצו להחליף את התוכן של 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 כדי להפעיל את מכשיר Matter ב-Google Home platform.

ניפוי באגים באמצעות 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 עם הדגל --paa-trust-store-path.

כדי להפעיל מכשיר Thread באמצעות BLE, אפשר להריץ את הפקודה:

```
$ 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.

כדי לקבל את פרטי הכניסה לפרוטוקול Thread מ-Google Nest Hub (2nd gen), אפשר להריץ את הפקודה:

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

כדי להפעיל מכשיר Wi-Fi, אתם יכולים להשתמש באפשרות ble-wifi:

$ examples/chip-tool/out/debug/chip-tool pairing ble-wifi 1 "SSID" SSID_password pairing_code discriminator