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

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

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

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

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

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

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

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

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

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

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

התקנה של Matter SDK

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

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

sudo apt-get install xxd

Build `chip-cert`

צריך לוודא שהגרסה של ה-SDK עדכנית. התהליכים האלה נבדקו ב-GitHub SHA 0b17bce8, בהסתעפות 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. מריצים את גרסת ה-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

בדוגמה הזו נשתמש באישור של Matter לבדיקת אישור אימות (PAA) של המוצר ובמפתח החתימה 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. אם לא מופיעות שגיאות בפלט, פירוש הדבר הוא ששרשרת האימות (attestation) אומתה בהצלחה:

$ 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 נמצאים בנתוני היצרן, והתקליטור מוטמע בקושחה עצמה.

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

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

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

Build `chip-cert`

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