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 testowe wymagają utworzenia certyfikatów innych niż produkcyjne.

Niektórych funkcji ekosystemu Google, takich jak aktualizacje oprogramowania OTA urządzenia, nie można przeprowadzać aktualizacji za pomocą testowego VID/PID.

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

Deklaracja certyfikacji (CD),
The Product Attestation Intermediate Certificate (PAI).
certyfikat atestu urządzenia (DAC),

Podczas procesu uruchamiania urządzenie z certyfikatem Matter musi potwierdzić, że jest to oryginalny produkt z certyfikatem Matter. Dane logowania używane przez urządzenia Matter do poświadczania składają się z:

Para kluczy atestu
łańcuch certyfikatów.

Certyfikat atestu urządzenia (The Device Attestation Certificate, DAC) to pierwszy link w łańcuchu certyfikatów. Jest on weryfikowany przez Product Attestation Intermediate Certificate (PAI), który z kolei jest weryfikowany przez Product Attestation Authority (PAA).

Certyfikaty są podpisywane w momencie generowania pary kluczy atestu oraz podpisane przy użyciu klucza prywatnego urzędu certyfikacji 1 poziomu wyżej, tworząc łańcuch zaufania. Certyfikat DAC jest podpisany kluczem PAI, a certyfikat PAI – kluczem PAA. Certyfikaty PAA, które znajdują się na początku łańcucha, są podpisywane samodzielnie. Ten łańcuch zaufania tworzy sfederowaną strukturę PAA, która jest synchronizowana przez rejestr zgodności DCL.

Więcej informacji o procesie poświadczania i deklaracjach certyfikacyjnych można znaleźć w artykule Dodatkowe dokumenty i wiadomości dotyczące poświadczania oraz w specyfikacji sprawy.

Zainstaluj pakiet SDK Matter

W tych instrukcjach zakładamy, że masz działającą instalację pakietu SDK Matter. Więcej informacji znajdziesz w dokumentacji na stronie GitHuba oraz w sekcji Pierwsze kroki ze standardem Matter.

Zainstaluj narzędzie szesnastkowe xxd, jeśli go nie masz. To narzędzie przydaje się do drukowania danych logowania w formacie C:

sudo apt-get install xxd

Kompilacja `chip-cert`

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

Tworzenie certyfikatów

Wyeksportuj niestandardowy identyfikator VID/PID jako zmienne środowiskowe, aby zmniejszyć ryzyko pomyłki przy edytowaniu argumentów poleceń:

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

Wygeneruj dysk CD

Wygeneruj dysk CD, używając programu chip-cert. Obecnie komisarz weryfikuje tylko, czy identyfikatory VID i PID są zgodne z danymi udostępnianymi w innym miejscu przez urządzenie: z klastra informacji podstawowych, a także z danych o pochodzeniu DAC i DAC (jeśli je uzyska). Możesz pozostawić inne 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ź dysk 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 użyjemy certyfikatu głównego urzędu certyfikacji (PAA) Matter oraz klucza podpisywania Chip-Test-PAA-NoVID. Wykorzystamy go jako główny urząd certyfikacji do generowania własnych PAI i DAC.

Wygeneruj PAI za pomocą PAA. Opcjonalnie możesz uwzględnić w PAI informacje o identyfikatorze PID, ale ich pominięcie daje Ci większą elastyczność podczas testów. Jeśli potrzebujesz DAC na potrzeby dodatkowych identyfikatorów PID, 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 plik 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ńcuchy DAC, PAI i PAA. Jeśli w danych wyjściowych nie pojawiają się żadne błędy, oznacza to, że łańcuch atestu certyfikatów 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

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

Do sprawdzenia wygenerowanych certyfikatów możesz też użyć narzędzia openssl:

$ 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 wykorzystać do generowania samodzielnie podpisanej umowy PAA, ale nie jest to konieczne.

Zamiast tego wykorzystaliśmy już podpisany samodzielnie podpis PAA, który nie zawiera informacji VID.

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

Wymień certyfikaty

Zastąp PAA i PAI

Uruchom poniższy skrypt pomocniczy, który za pomocą narzędzia CHIP Certificate Tool (chip-cert) generuje tablice certyfikatów w stylu C.

Pobierz skrypt pomocniczy certyfikatów osadzonych

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

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

Na urządzeniach produkcyjnych kanały PAI i DAC znajdują się w danych fabrycznych, a płyta CD jest wbudowana w oprogramowanie układowe.

Jeśli nie używasz jeszcze Factory Data, warto umieścić pakiet 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 korzystasz z danych fabrycznych lub niestandardowego dostawcy danych uwierzytelniających, pamiętaj, aby wstawić dane logowania w odpowiednich lokalizacjach. Informacje o swojej platformie możesz uzyskać z dostawcą SOC.

Wymień dysk CD

Wyodrębnij tekstową reprezentację zawartości pliku CD za pomocą funkcji 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żytego do zdefiniowania dysku CD do kompilacji. Tak jak w przypadku PAI i DAC, sposób, w jaki to zrobisz, zależy od platformy.

Jeśli używasz przykładowych danych logowania, prawdopodobnie zechcesz zastąpić zawartość pola kCdForAllExamples w pliku ExampleDACProvider::GetCertificationDeclaration w języku: 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

Utwórz i flashuj cel przy użyciu nowo wytworzonych danych logowania. Ta sekcja zależy od platformy. Więcej informacji znajdziesz w dokumentacji SOC lub w artykule na temat obsługiwanych urządzeń.

Przekaż urządzenie

Możesz teraz wykonać czynności opisane w artykule Parowanie urządzenia ze standardem Matter, aby przesłać urządzenie Matter na urządzenie Google Home platform.

Debugowanie problemów za pomocą narzędzia `chip-tool`

chip-tool może być przydatnym narzędziem do sprawdzania, czy Twoje urządzenie wysyła odpowiednie 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 logi, przy każdym uruchomieniu chip-tool przekaż flagę --trace_decode 1. Warto też przekazać ścieżkę pliku PAA z flagą --paa-trust-store-path.

Aby zlecić urządzeniu Thread za pomocą BLE, możesz uruchomić:

```
$ 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> ma wartość 20202021, a <DISCRIMINATOR> to 3840.

Aby uzyskać dane logowania 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

Wstecz

Przygotuj obraz OTA

Dalej

Testowanie OTA Matter

Tworzenie certyfikatów testowych urządzeń Matter

Zainstaluj pakiet SDK Matter

Kompilacja chip-cert

Tworzenie certyfikatów

Wygeneruj dysk CD

Generowanie PAI i DAC

PAA

Wymień certyfikaty

Zastąp PAA i PAI

Wymień dysk CD

Tworzenie celu

Przekaż urządzenie

Debugowanie problemów za pomocą narzędzia chip-tool

Kompilacja `chip-cert`

Debugowanie problemów za pomocą narzędzia `chip-tool`