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

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

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

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

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

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

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

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

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

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

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

התקנה של תקן Matter SDK

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

מתקינים את כלי העזר ההקסדצימלי 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

בדוגמה הזו נשתמש באישור מהרשות לאימות על מוצרים (PAA) ובמפתח החתימה Chip-Test-PAA-NoVID של Matter בתור האישור הבסיסי שלנו. נשתמש בו בתור רשות האישורים הבסיסית כדי ליצור 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 לעזור

#!/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 פרטים ספציפיים על הפלטפורמה.

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

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

יצירת היעד

יוצרים יעד ומריצים אותו ב-Flash בעזרת פרטי הכניסה החדשים שנוצרו. הקטע הזה תלוי בפלטפורמה. מידע נוסף זמין במשאבי העזרה של 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`