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

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

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

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

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

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

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

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

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

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

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

התקנת Matter SDK

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

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

sudo apt-get install xxd

גרסת build `chip-cert`

חשוב לוודא שאתם עובדים עם גרסה עדכנית של ה-SDK. התהליכים האלה נבדקו ב-GitHub SHA 0b17bce8, בהסתעפות v1.0-branch:
```
$ cd connectedhomeip
$ git checkout v1.0-branch
$ git pull
```
פיתוח 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

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

יוצרים את התקליטור באמצעות 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"

מאמתים את התקליטור. חשוב לוודא שהם מכילים את ה-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

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

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

הורדת הסקריפט של התעודות שניתן להטמיע

#!/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/\/,/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

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

התקנת Matter SDK

גרסת build chip-cert

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

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

יצירת PAI ו-DAC

PAA

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

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

מחליפים את התקליטור

פיתוח היעד

איך מפעילים את המכשיר

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

גרסת build `chip-cert`

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