דף זה תורגם על ידי Cloud Translation API.

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

למרות שזה לא חובה, בתרחישי בדיקה מסוימים צריך ליצור אישורי Matter שאינם אישורי ייצור.

חלק מהתכונות של המערכת האקולוגית של Google, כולל עדכוני תוכנה של מכשירים דרך האוויר (OTA), לא ניתנות לביצוע באמצעות VID/PID לבדיקה.

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

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

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

זוג מפתחות לאימות
שרשרת אישורים

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

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

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

התקנה של Matter SDK

ההוראות האלה מבוססות על ההנחה שיש לכם התקנה תקינה של Matter SDK. למידע נוסף, אפשר לעיין במאמרי העזרה בנושא Github או במאמר תחילת העבודה עם Matter.

מתקינים את כלי השירות hexdump xxd אם הוא לא מותקן. הכלי הזה שימושי להדפסת פרטי הכניסה בפורמט בסגנון C:

sudo apt-get install xxd

גרסת Build‏ `chip-cert`

חשוב לוודא שאתם עובדים עם גרסה עדכנית של ה-SDK. התהליכים האלה נבדקו ב-SHA 0b17bce8 ב-GitHub, בענף v1.0-branch:
```
$ cd connectedhomeip
$ git checkout v1.0-branch
$ git pull
```
‫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. מריצים את הבנייה:
```
$ ninja -C out
```
  פלט ninja לדוגמה:
```
ninja: Entering directory `out'
[2000/2000] stamp obj/default.stamp
```

יצירת אישורים

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

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

יצירת תקליטור

יוצרים את ה-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"

מאמתים את ה-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 משלנו.

יוצרים את תמונת ה-PAI באמצעות ה-PAA. אפשר לכלול את פרטי ה-PID ב-PAI, אבל אם לא כוללים אותם יש יותר גמישות בבדיקות. אם אתם צריכים קודי DAC למספרי 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

יוצרים את ה-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

מאמתים את השרשרת של 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

אתם יכולים לבדוק את המפתחות באמצעות 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

אפשר גם להשתמש ב-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

מריצים את סקריפט העזר הבא, שמשתמש בכלי האישורים של 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"

מעתיקים את התוכן של הפלט של ה-PAI וה-DAC אל ההטמעה של DeviceAttestationCredentialsProvider::GetProductAttestationIntermediateCert.

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

אם אתם עדיין לא משתמשים בנתוני יצרן, כדאי להציב את נתוני ה-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

אם אתם משתמשים בנתוני יצרן או בספק אישורים בהתאמה אישית, הקפידו להוסיף את האישורים במיקומים המתאימים. כדאי לבדוק עם ספק ה-SoC את הפרטים הספציפיים של הפלטפורמה.

החלפת התקליטור

מחלקים את קובץ ה-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;
  ```

מעתיקים את הטקסט שחולץ בשלב הקודם לקובץ שמשמש להגדרת ה-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

מכינים תמונת OTA

בדיקת OTA של מטרה

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

התקנה של Matter SDK

גרסת Build‏ chip-cert

יצירת אישורים

יצירת תקליטור

יצירת PAI ו-DAC

PAA

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

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

החלפת התקליטור

בניית היעד

הפעלת המכשיר

ניפוי באגים באמצעות chip-tool

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

גרסת Build‏ `chip-cert`

ניפוי באגים באמצעות `chip-tool`