Aunque no es un requisito, algunas situaciones de prueba requieren la creación de certificados de Matter que no sean de producción.
Algunas funciones del ecosistema de Google, incluidas las actualizaciones de software de dispositivos inalámbricos, no se pueden realizar con un VID/PID de prueba.
En esta guía, se explica cómo crear y verificar certificados Matter que no sean de producción para usarlos en pruebas. Los tipos de certificados son los siguientes:
- La Declaración de Certificación (CD)
- El certificado intermedio de certificación de productos (PAI)
- El certificado de certificación de dispositivo (DAC)
Durante el proceso de puesta en marcha, un dispositivo certificado con Matter debe certificarse, es decir, probar que es un producto genuino certificado por Matter. Las credenciales que usan los dispositivos Matter para la certificación son las siguientes:
- Un par de claves de certificación
- Una cadena de certificados
El certificado de certificación de dispositivo (DAC) es el primer vínculo de la cadena de certificados y está validado por el certificado intermedio de certificación de productos (PAI), que, a su vez, está validado por la autoridad de certificación de productos (PAA).
Los certificados se firman al mismo tiempo que se genera el par de claves de certificación y se firman con la clave privada de la autoridad certificadora un nivel anterior, lo que forma una cadena de confianza. Por lo tanto, un certificado DAC está firmado por una clave PAI, y un certificado PAI está firmado por una clave PAA. Dado que son los principales de la cadena, los certificados de PAA están autofirmados. Esta cadena de confianza forma una estructura de PAA federada que se sincroniza mediante un registro de cumplimiento distribuido (DCL).
Puedes encontrar más información sobre el proceso de certificación y las declaraciones de certificación (CD) en Documentos y mensajes adicionales de certificación y en la especificación de Matter.
Cómo instalar el SDK de Matter
En estas instrucciones, se da por sentado que tienes una instalación en funcionamiento del SDK de Matter. Consulta la documentación de GitHub o consulta Cómo comenzar a usar Matter para obtener más información.
Instala la utilidad hexdump xxd
si no la tienes. Esta herramienta es útil para imprimir las credenciales en un formato estilo C:
sudo apt-get install xxd
Compilación chip-cert
Asegúrese de estar trabajando en una versión reciente del SDK. Estos procedimientos se probaron en la SHA de GitHub de GitHub
0b17bce8
, en la ramav1.0-branch
:$ cd connectedhomeip $ git checkout v1.0-branch $ git pull
Compila
chip-cert
, que es la herramienta que se usa para varias operaciones en credenciales de dispositivos Matter:Configura la compilación:
$ cd src/credentials $ source ../../scripts/activate.sh $ gn gen out
Ejemplo de resultado
gn
:Done. Made 5774 targets from 289 files in 658ms
Ejecuta la compilación:
$ ninja -C out
Ejemplo de resultado
ninja
:ninja: Entering directory `out' [2000/2000] stamp obj/default.stamp
Crea tus certificados
Exporta tu VID/PID personalizado como variables de entorno para disminuir las posibilidades de que ocurra un error administrativo cuando edites tus argumentos de comando:
$ cd ../..
$ export VID=hexVendorId
$ export PID=hexProductId
Genera un CD
Genera el CD con
chip-cert
. Actualmente, el comisionador solo valida que el VID y el PID coincidan con los datos expuestos por el dispositivo: el clúster de información básica, el DAC y el origen de DAC (cuando lo tiene). Puedes dejar los otros campos sin modificar:$ 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"
Verifica el CD. Asegúrate de que contenga tu VID/PID (en formato decimal):
$ src/credentials/out/chip-cert print-cd credentials/test/certification-declaration/Chip-Test-CD-${VID}-${PID}.der
Resultado de ejemplo:
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
Genere PAI y DAC
En este ejemplo, usaremos el certificado de la autoridad de certificación del producto (PAA) de prueba de Matter y la clave de firma Chip-Test-PAA-NoVID
como nuestro certificado raíz. La usaremos como CA raíz para generar nuestros propios PAI y DAC.
Genere el PAI mediante el PAA. De forma opcional, puedes incluir la información del PID en el PAI, pero omitirla te brinda más flexibilidad para las pruebas. Si necesitas DAC para PID adicionales, puedes ejecutar solo el paso de generación de 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
Genera el DAC con el 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
Verifica la cadena de DAC, PAI y PAA. Si no aparecen errores en el resultado, significa que la cadena de certificación se verificó de forma correcta:
$ 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
Puedes inspeccionar tus claves con
openssl
:$ openssl ec -noout -text -in \ credentials/test/attestation/test-DAC-${VID}-${PID}-key.pem
Resultado de ejemplo:
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
También puedes usar
openssl
para inspeccionar tus certificados generados:$ openssl x509 -noout -text -in \ credentials/test/attestation/test-DAC-${VID}-${PID}-cert.pem
Resultado de ejemplo:
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
Podría usarse un proceso similar para generar un PAA autofirmado, pero no es necesario hacerlo.
En su lugar, lo que hicimos aquí es usar un PAA de desarrollo autofirmado existente que no incluye información de VID.
Para ver más ejemplos sobre cómo generar un CD, consulta credentials/test/gen-test-cds.sh
. Si deseas obtener más ejemplos sobre cómo generar un PAA, PAI y DAC, consulta credentials/test/gen-test-attestation-certs.sh
.
Reemplaza los certificados
Reemplace el PAA y PAI.
- Ejecuta la siguiente secuencia de comandos auxiliar, que usa la herramienta de certificado CHIP (
chip-cert
) para generar arreglos de estilo C de tus certificados.
Descarga la secuencia de comandos del Asistente para certificados incorporables
#!/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/\0x/g' | 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"
Copia el contenido de los resultados de PAI y DAC en tu implementación de
DeviceAttestationCredentialsProvider::GetProductAttestationIntermediateCert
.En los dispositivos de producción, la PAI y el DAC se encuentran en los datos de fábrica, mientras que la CD está incorporada en el firmware.
Si todavía no usas datos de fábrica, te recomendamos que coloques tu PAI en
src/credentials/examples/ExampleDACs.cpp
. En este caso, agrega el código generado resultante a tu archivoExampleDACs.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
Si usas datos de fábrica o un proveedor de credenciales personalizado, asegúrate de insertar las credenciales en las ubicaciones adecuadas. Te recomendamos que consultes con tu proveedor de SoC las especificaciones de tu plataforma.
Reemplaza el CD
Extrae una representación de texto del contenido de tu archivo de CD con
xxd
:$ xxd -i credentials/test/certification-declaration/Chip-Test-CD-${VID}-${PID}.der
Resultado de ejemplo:
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; ```
Copia el texto que extrajiste en el paso anterior en el archivo que se usó para definir el CD en tu compilación. Al igual que en el caso de PAI y DAC, la forma de hacerlo depende de la plataforma en la que se desarrolle.
Si usas los ejemplos de credenciales, es probable que quieras reemplazar el contenido de kCdForAllExamples
en ExampleDACProvider::GetCertificationDeclaration
, en 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
};
Crea el destino
Compila y escribe en la memoria flash del destino usando las credenciales creadas recientemente. Esta sección depende de la plataforma. Consulta la documentación del SoC o dispositivos compatibles para obtener más información.
Asignar el dispositivo
Ahora puedes seguir los pasos que se indican en Cómo vincular un dispositivo Matter para asignar tu dispositivo Matter a Google Home platform.
Depura problemas con chip-tool
chip-tool
puede ser una herramienta valiosa para comprobar si tu dispositivo envía los certificados correctos. Para compilarlo, sigue estos pasos:
$ 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 ../..
Para habilitar registros adicionales, siempre que ejecutes chip-tool
, asegúrate de pasar la marca --trace_decode 1
. Además, se recomienda pasar la ruta de acceso de tu archivo APA con la marca --paa-trust-store-path
.
Por lo tanto, para encargar un dispositivo Thread con BLE, puedes ejecutar lo siguiente:
```
$ 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
```
En el caso de los dispositivos de prueba, <PAIRING CODE>
es 20202021
y <DISCRIMINATOR>
es 3840
.
Para obtener tus credenciales de Thread de tu Google Nest Hub (2nd gen), puedes ejecutar lo siguiente:
$ adb connect border_router_ip_address
$ adb -e shell ot-ctl dataset active -x
$ adb disconnect
Además, para encargar un dispositivo Wi-Fi, puedes usar la opción ble-wifi
:
$ examples/chip-tool/out/debug/chip-tool pairing ble-wifi 1 "SSID" SSID_password pairing_code discriminator