Od 2026 r. wszystkie integracje i testy Matter będą wymagać testu Alliance Interop. Więcej informacji znajdziesz na stronie poświęconej zmianom w laboratorium testowym Alliance Interop.

Google używa technologii AI do tłumaczenia treści na Twój preferowany język. Tłumaczenia wygenerowane przez AI mogą zawierać błędy.

Tworzenie certyfikatów testowych urządzeń Matter

Niektóre scenariusze programistyczne, takie jak testowanie OTA, wymagają utworzenia certyfikatów Matter innych niż produkcyjne.

Niektóre funkcje ekosystemu Google, w tym aktualizacje oprogramowania OTA na urządzeniu, nie mogą być wykonywane przy użyciu testowego identyfikatora VID/PID.

Z tego przewodnika dowiesz się, jak tworzyć i weryfikować certyfikaty Matter nieprodukcyjne do celów testowych. Rodzaje certyfikatów:

Deklaracja certyfikacji (CD)
Certyfikat pośredni atestu produktu (PAI)
Certyfikat atestacji urządzenia (DAC)

Podczas procesu uruchamiania urządzenie z certyfikatem Matter musi przejść atestację, czyli udowodnić, że jest oryginalnym produktem z certyfikatem Matter. Dane logowania używane przez urządzenia Matter do atestacji obejmują:

para kluczy atestacji,
łańcuch certyfikatów,

Certyfikat atestu urządzenia (DAC) jest pierwszym ogniwem w łańcuchu certyfikatów i jest weryfikowany przez certyfikat pośredni atestu produktu (PAI), który z kolei jest weryfikowany przez urząd atestu produktu (PAA).

Certyfikaty są podpisywane w tym samym czasie, gdy generowana jest para kluczy atestu, i są podpisywane przy użyciu klucza prywatnego urzędu certyfikacji o jeden poziom wyżej, tworząc łańcuch zaufania. Certyfikat DAC jest więc podpisany kluczem PAI, a certyfikat PAI jest podpisany kluczem PAA. Certyfikaty PAA znajdują się na szczycie łańcucha, więc są podpisane samodzielnie. Ten łańcuch zaufania tworzy federacyjną strukturę PAA, która jest synchronizowana przez rozproszoną księgę zgodności (DCL).

Więcej informacji o procesie atestacji i deklaracjach certyfikacji znajdziesz w dodatkowych dokumentach i komunikatach dotyczących atestacji oraz w specyfikacji Matter.

Instalowanie pakietu SDK Matter

W tych instrukcjach przyjęto, że masz działającą instalację pakietu SDK Matter. Więcej informacji znajdziesz w dokumentacji na GitHubie lub w artykule Pierwsze kroki z Matter.

Jeśli nie masz narzędzia hexdump xxd, zainstaluj je. To narzędzie jest przydatne do drukowania danych logowania w formacie C-style:

sudo apt-get install xxd

Kompilacja `chip-cert`

Upewnij się, że używasz najnowszej wersji pakietu SDK. Te procedury zostały przetestowane na SHA 0b17bce8 w GitHubie, w gałęzi v1.0-branch:
```
$ cd connectedhomeip
$ git checkout v1.0-branch
$ git pull
```
Skompiluj chip-cert, czyli narzędzie używane do wykonywania kilku operacji na danych logowania na urządzeniach Matter:
1. Skonfiguruj kompilację:
```
$ cd src/credentials
$ source ../../scripts/activate.sh
$ gn gen out
```
  Przykładowe dane wyjściowe gn:
```
Done. Made 5774 targets from 289 files in 658ms
```
2. Uruchom kompilację:
```
$ ninja -C out
```
  Przykładowe dane wyjściowe ninja:
```
ninja: Entering directory `out'
[2000/2000] stamp obj/default.stamp
```

Wystawianie certyfikatów

Wyeksportuj niestandardowe identyfikatory VID/PID jako zmienne środowiskowe, aby zmniejszyć ryzyko błędu podczas edytowania argumentów poleceń:

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

Wygeneruj CD

Wygeneruj CD za pomocą chip-cert. Obecnie komisarz sprawdza tylko, czy identyfikatory VID i PID są zgodne z danymi udostępnianymi przez urządzenie w innym miejscu: w klastrze informacji podstawowych, DAC i źródle DAC (jeśli jest dostępne). Pozostałe pola możesz pozostawić bez zmian:

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

Sprawdź płytę CD. Upewnij się, że zawiera on identyfikator VID/PID (w formacie dziesiętnym):

$ src/credentials/out/chip-cert print-cd credentials/test/certification-declaration/Chip-Test-CD-${VID}-${PID}.der

Przykładowe dane wyjściowe:

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

Generowanie PAI i DAC

W tym przykładzie jako certyfikatu głównego użyjemy certyfikatu i klucza podpisywania testowego urzędu certyfikacji produktu (PAA) firmy Matter Chip-Test-PAA-NoVID. Użyjemy go jako głównego urzędu certyfikacji do wygenerowania własnego PAI i DAC.

Wygeneruj PAI za pomocą PAA. Możesz opcjonalnie uwzględnić informacje o PID w PAI, ale pominięcie ich daje większą elastyczność podczas testowania. Jeśli potrzebujesz certyfikatów DAC dla dodatkowych identyfikatorów PID, możesz wykonać tylko krok generowania certyfikatu 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

Wygeneruj DAC za pomocą 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

Sprawdź łańcuch DAC, PAI i PAA. Jeśli w danych wyjściowych nie pojawią się żadne błędy, oznacza to, że łańcuch atestowania certyfikatu został pomyślnie zweryfikowany:

$ 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

Klucze możesz sprawdzić za pomocą polecenia openssl:

$ openssl ec -noout -text -in \
  credentials/test/attestation/test-DAC-${VID}-${PID}-key.pem

Przykładowe dane wyjściowe:

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

Możesz też użyć openssl, aby sprawdzić wygenerowane certyfikaty:

$ openssl x509 -noout -text -in \
  credentials/test/attestation/test-DAC-${VID}-${PID}-cert.pem

Przykładowe dane wyjściowe:

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

Podobny proces można zastosować do wygenerowania certyfikatu PAA podpisanego samodzielnie, ale nie jest to konieczne.

Zamiast tego użyliśmy istniejącego, podpisanego samodzielnie certyfikatu PAA, który nie zawiera informacji o identyfikatorze VID.

Więcej przykładów generowania CD znajdziesz w credentials/test/gen-test-cds.sh. Więcej przykładów generowania PAA, PAI i DAC znajdziesz w credentials/test/gen-test-attestation-certs.sh.

Zastępowanie certyfikatów

Zastępowanie PAA i PAI

Uruchom ten skrypt pomocniczy, który używa narzędzia CHIP Certificate Tool (chip-cert) do generowania tablic certyfikatów w stylu C.

Pobieranie skryptu 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"

Skopiuj zawartość danych wyjściowych PAI i DAC do implementacji DeviceAttestationCredentialsProvider::GetProductAttestationIntermediateCert.

Na urządzeniach produkcyjnych PAI i DAC znajdują się w danych fabrycznych, a CD jest umieszczony w samym oprogramowaniu układowym.

Jeśli nie korzystasz jeszcze z danych fabrycznych, możesz umieścić PAI w src/credentials/examples/ExampleDACs.cpp. W takim przypadku dołącz wygenerowany kod do pliku 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

Jeśli używasz danych fabrycznych lub niestandardowego dostawcy danych logowania, pamiętaj, aby wstawić dane logowania w odpowiednich miejscach. Aby dowiedzieć się więcej o swojej platformie, skontaktuj się z dostawcą układu SoC.

Wymień płytę CD

Wyodrębnij tekstową reprezentację zawartości pliku CD za pomocą xxd:

  $ xxd -i credentials/test/certification-declaration/Chip-Test-CD-${VID}-${PID}.der

Przykładowe dane wyjściowe:

  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;
  ```

Skopiuj tekst wyodrębniony w poprzednim kroku do pliku używanego do definiowania CD w kompilacji. Podobnie jak w przypadku PAI i DAC, sposób, w jaki to zrobisz, zależy od platformy, na której tworzysz aplikację.

Jeśli używasz przykładowych danych logowania, prawdopodobnie chcesz zastąpić zawartość kCdForAllExamples w ExampleDACProvider::GetCertificationDeclaration w 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
        };

Tworzenie celu

Skompiluj i zapisz w pamięci flash urządzenie docelowe, używając nowo utworzonych danych logowania. Ta sekcja zależy od platformy. Więcej informacji znajdziesz w dokumentacji SoC lub na stronie Obsługiwane urządzenia.

Konfigurowanie urządzenia

Możesz teraz wykonać czynności opisane w sekcji Parowanie urządzenia Matter, aby uruchomić urządzenie Matter w sieci Google Home platform.

Debugowanie problemów za pomocą `chip-tool`

chip-tool może być przydatnym narzędziem do sprawdzania, czy urządzenie wysyła prawidłowe certyfikaty. Aby go utworzyć:

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

Aby włączyć dodatkowe dzienniki, podczas uruchamiania chip-tool pamiętaj o przekazaniu flagi --trace_decode 1. Ponadto dobrą praktyką jest przekazywanie ścieżki do pliku PAA za pomocą flagi --paa-trust-store-path.

Aby uruchomić urządzenie Thread za pomocą BLE, możesz wykonać polecenie:

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

W przypadku urządzeń testowych <PAIRING CODE> to 20202021, a <DISCRIMINATOR> to 3840.

Aby uzyskać dane uwierzytelniające sieci Thread z urządzenia Google Nest Hub (2nd gen), możesz uruchomić:

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

Aby uruchomić urządzenie Wi-Fi, możesz użyć opcji ble-wifi:

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

Tworzenie certyfikatów testowych urządzeń Matter Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

Instalowanie pakietu SDK Matter

Kompilacja chip-cert

Wystawianie certyfikatów

Wygeneruj CD

Generowanie PAI i DAC

PAA

Zastępowanie certyfikatów

Zastępowanie PAA i PAI

Wymień płytę CD

Tworzenie celu

Konfigurowanie urządzenia

Debugowanie problemów za pomocą chip-tool

Tworzenie certyfikatów testowych urządzeń Matter

Kompilacja `chip-cert`

Debugowanie problemów za pomocą `chip-tool`