Ta strona została przetłumaczona przez Cloud Translation API.

Tworzenie certyfikatów testowych urządzeń Matter

Chociaż nie jest to wymagane, niektóre scenariusze testów wymagają utworzenia certyfikatów Matter, które nie są przeznaczone do użytku produkcyjnego.

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

Z tego przewodnika dowiesz się, jak tworzyć i weryfikować certyfikaty inne niż produkcyjneMatter na potrzeby testów. Typy certyfikatów:

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

Podczas procesu uruchamiania urządzenie z certyfikatem Matter musi potwierdzać swoją tożsamość, czyli udowadniać, że jest oryginalnym produktem z certyfikatem Matter. Dane logowania używane przez urządzenia Matter do weryfikacji to:

para kluczy atestatycznych;
łańcuch certyfikatów,

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

Certyfikaty są podpisywane w tym samym momencie, w którym generowana jest para kluczy atestatycznych. Są one podpisywane za pomocą klucza prywatnego urzędu certyfikacji na poziomie wyższym, tworząc łańcuch zaufania. Certyfikat DAC jest podpisany kluczem PAI, a certyfikat PAI jest podpisany kluczem PAA. Certyfikaty PAA są podpisane samodzielnie, ponieważ znajdują się na szczycie łańcucha. Ten łańcuch zaufania tworzy federacyjną strukturę PAA, która jest synchronizowana przez rozproszone rejestry zgodności (DCL).

Więcej informacji o procesie certyfikacji i deklaracjach certyfikacyjnych znajdziesz w dodatkowych dokumentach i wiadomościach dotyczących certyfikacji oraz w specyfikacji sprawy.

Instalowanie pakietu SDK Matter

W tych instrukcjach przyjęto, że masz zainstalowany pakiet SDK Matter. Więcej informacji znajdziesz w dokumentacji na GitHub lub w artykule Pierwsze kroki z Matter.

Zainstaluj narzędzie hexdump xxd, jeśli go nie masz. To narzędzie jest przydatne do drukowania danych logowania w formacie C:

sudo apt-get install xxd

Kompilacja `chip-cert`

Upewnij się, że używasz najnowszej wersji pakietu SDK. Te procedury zostały przetestowane w ramach SHA 0b17bce8 w gałęzi v1.0-branch w GitHub:
```
$ cd connectedhomeip
$ git checkout v1.0-branch
$ git pull
```
Utwórz chip-cert, czyli narzędzie do wykonywania kilku operacji na danych logowania na urządzeniach Matter:
1. Konfigurowanie kompilacji:
```
$ 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
```

Wytwarzanie certyfikatów

Aby zmniejszyć ryzyko popełnienia błędu podczas edycji argumentów polecenia, wyeksportuj niestandardowe identyfikatory VID/PID jako zmienne środowiskowe:

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

Tworzenie płyty CD

Wygeneruj CD za pomocą chip-cert. Komisarz weryfikuje obecnie tylko to, czy VID i PID są zgodne z danymi wyświetlanymi przez urządzenie w innych miejscach: w podstawowym klastrze informacji, DAC i DAC origin (jeśli jest dostępny). Pozostaw pozostałe pola 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 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 użyjemy własnego testowego certyfikatu urzędu certyfikacji produktów (PAA) i klucza podpisywania Chip-Test-PAA-NoVID jako certyfikatu głównego.Matter Użyjemy go jako urzędu certyfikacji głównego do wygenerowania własnego PAI i DAC.

Wygeneruj PAI za pomocą PAA. Opcjonalnie możesz podać informacje o PID w plikach PAI, ale ich pominięcie daje Ci większą elastyczność podczas testowania. Jeśli potrzebujesz DAC-ów dla dodatkowych PID-ów, możesz wykonać tylko krok generowania 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 wyjściu nie pojawią się żadne błędy, oznacza to, że łańcuch atestacji 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

Możesz sprawdzić swoje klucze, korzystając z funkcji 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 samodzielnie podpisanego certyfikatu PAA, ale nie jest to konieczne.

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

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

Zastąp certyfikaty

Zastąp 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.

Pobierz skrypt pomocy dotyczącej certyfikatów do osadzenia

#!/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 są w danych fabrycznych, a CD jest wbudowany w firmware.

Jeśli nie używasz jeszcze danych fabrycznych, możesz umieścić PAI w sekcji src/credentials/examples/ExampleDACs.cpp. W takim przypadku dodaj 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. Skontaktuj się z dostawcą SoC, aby uzyskać informacje o specyfikacji Twojej platformy.

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 zdefiniowania CD w kompilacji. Podobnie jak w przypadku PAI i DAC, sposób wykonania tych działań zależy od platformy, na której tworzysz aplikację.

Jeśli używasz przykładowych danych logowania, prawdopodobnie musisz zastąpić zawartość elementu kCdForAllExamples w elementach ExampleDACProvider::GetCertificationDeclaration i 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 środowiska docelowego

Utwórz i wyświetl docelowe treści, korzystając z nowych danych logowania. Ten oddział jest zależny od platformy. Więcej informacji znajdziesz w dokumentacji dotyczącej SoC lub na stronie Obsługiwane urządzenia.

Konfigurowanie urządzenia

Aby uruchomić urządzenie Matter w sieci Google Home platform, wykonaj czynności opisane w artykule Parowanie urządzenia Matter.

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 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, gdy działa chip-tool, pamiętaj o przekazaniu flagi --trace_decode 1. Dobrą praktyką jest też przekazywanie ścieżki do pliku PAA z flagą --paa-trust-store-path.

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

```
$ 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 wykonać:

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

Aby zlecić konfigurację urządzenia 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

Tworzenie certyfikatów testowych urządzeń Matter

Instalowanie pakietu SDK Matter

Kompilacja chip-cert

Wytwarzanie certyfikatów

Tworzenie płyty CD

Generowanie PAI i DAC

PAA

Zastąp certyfikaty

Zastąp PAA i PAI

Wymień płytę CD

Tworzenie środowiska docelowego

Konfigurowanie urządzenia

Rozwiązywanie problemów za pomocą chip-tool

Kompilacja `chip-cert`

Rozwiązywanie problemów za pomocą `chip-tool`