Tworzenie certyfikatów testowych urządzeń Matter

Choć nie jest to wymagane, w niektórych scenariuszach testowych konieczne jest utworzenie certyfikatów Matter innych niż produkcyjne.

Niektórych funkcji ekosystemu Google, w tym aktualizacji oprogramowania OTA na urządzeniu, nie można wykonywać przy użyciu testowego identyfikatora VID/PID.

Z tego przewodnika dowiesz się, jak utworzyć i zweryfikować certyfikaty inne niż produkcyjne Matter do użycia w testach. Dostępne są te typy certyfikatów:

  1. Deklaracja certyfikacji (CD)
  2. Certyfikat pośredni potwierdzenia produktu (PAI)
  3. Certyfikat potwierdzenia urządzenia (DAC)

Podczas procesu uruchamiania urządzenie z Matter certyfikatem musi się potwierdzić, czyli udowodnić, że jest oryginalnym produktem z certyfikatem Matter. Dane uwierzytelniające używane przez Matter urządzenia do potwierdzania tożsamości obejmują:

  1. parę kluczy potwierdzających,
  2. łańcuch certyfikatów.

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

Certyfikaty są podpisywane w tym samym czasie, w którym generowana jest para kluczy potwierdzających, 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, które znajdują się na szczycie łańcucha, 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 potwierdzania i deklaracjach certyfikacji (CD) znajdziesz w dodatkowych dokumentach i wiadomościach dotyczących potwierdzania oraz w specyfikacji Matter.

Instalowanie pakietu SDK Matter

Te instrukcje zakładają, że masz działającą instalację pakietu Matter SDK. 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 uwierzytelniających w formacie C:

sudo apt-get install xxd

Kompilowanie chip-cert

  1. Upewnij się, że używasz najnowszej wersji pakietu SDK. Te procedury zostały przetestowane na GitHubie SHA 0b17bce8 w gałęzi v1.0-branch:

    $ cd connectedhomeip
$ git checkout v1.0-branch
$ git pull

  2. Skompiluj chip-cert, czyli narzędzie używane do wykonywania różnych operacji na danych uwierzytelniających urządzeń 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

Generowanie certyfikatów

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

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

Generowanie deklaracji certyfikacji

  1. Wygeneruj deklarację certyfikacji za pomocą chip-cert. Obecnie komisarz sprawdza tylko, czy identyfikator VID i PID pasują do danych udostępnianych przez urządzenie w innych miejscach: w klastrze informacji podstawowych, certyfikacie DAC i jego źródle (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"

  2. Sprawdź deklarację certyfikacji. Upewnij się, że zawiera ona Twój 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 certyfikatu PAI i DAC

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

  1. Wygeneruj certyfikat PAI za pomocą PAA. Opcjonalnie możesz uwzględnić informacje o identyfikatorze PID w certyfikacie 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

  2. Wygeneruj certyfikat DAC za pomocą certyfikatu 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

  3. Sprawdź łańcuch certyfikatów DAC, PAI i PAA. Jeśli w danych wyjściowych nie pojawią się żadne błędy, oznacza to, że łańcuch potwierdzania certyfikatu został 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

  4. Klucze możesz sprawdzić za pomocą 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

  5. Możesz też użyć openssl do sprawdzenia wygenerowanych certyfikatów:

    $ 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 samodzielnie podpisanego certyfikatu PAA, ale nie jest to konieczne.

Zamiast tego użyjemy istniejącego samodzielnie podpisanego certyfikatu PAA do celów programistycznych, który nie zawiera informacji o identyfikatorze VID.

Więcej przykładów generowania deklaracji certyfikacji znajdziesz w credentials/test/gen-test-cds.sh a więcej przykładów generowania certyfikatów PAA, PAI i DAC – w credentials/test/gen-test-attestation-certs.sh

Zastępowanie certyfikatów

Zastępowanie certyfikatów PAA i PAI

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

Pobierz skrypt pomocniczy do osadzania certyfikatów

#!/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"

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

    Na urządzeniach produkcyjnych certyfikaty PAI i DAC znajdują się w danych fabrycznych, a deklaracja certyfikacji jest osadzona w samym oprogramowaniu układowym.

    1. Jeśli nie używasz jeszcze danych fabrycznych, możesz umieścić certyfikat 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

    2. Jeśli używasz danych fabrycznych lub niestandardowego dostawcy danych uwierzytelniających, pamiętaj, aby wstawić dane uwierzytelniające w odpowiednich miejscach. Warto sprawdzić u dostawcy układu SoC szczegóły dotyczące platformy.

Zastępowanie deklaracji certyfikacji

  1. Wyodrębnij tekstową reprezentację zawartości pliku deklaracji certyfikacji 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;
  ```

  2. Skopiuj tekst wyodrębniony w poprzednim kroku do pliku używanego do definiowania deklaracji certyfikacji w kompilacji. Podobnie jak w przypadku certyfikatów PAI i DAC, sposób wykonania tej czynności zależy od platformy, na której programujesz.

Jeśli używasz przykładów danych uwierzytelniających, 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
        };

Kompilowanie elementu docelowego

Skompiluj i wgraj element docelowy za pomocą nowo wygenerowanych danych uwierzytelniających. Ta sekcja zależy od platformy. Więcej informacji znajdziesz w dokumentacji układu SoC lub w artykule Obsługiwane urządzenia.

Uruchamianie urządzenia

Możesz teraz wykonać kroki opisane w artykule Parowanie urządzenia Matter aby uruchomić urządzenie Matter na Google Home platform.

Rozwiązywanie 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 skompilować:

$ 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 logi, podczas uruchamiania chip-tool pamiętaj, aby przekazać flagę --trace_decode 1. Ponadto warto przekazać ścieżkę do pliku PAA za pomocą flagi --paa-trust-store-path.

Aby uruchomić urządzenie Thread za pomocą BLE, możesz uruchomić to 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 Thread z Google Nest Hub (2nd gen), możesz uruchomić to polecenie:

$ 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
Wstecz
Przygotuj obraz OTA
Dalej
Testowanie OTA Matter