Cette page a été traduite par l'API Cloud Translation.

Créer des certificats de test des appareils Matter

Bien que cela ne soit pas obligatoire, certains scénarios de test nécessitent de créer des certificats Matter non destinés à la production.

Certaines fonctionnalités de l'écosystème Google, y compris les mises à jour logicielles OTA de l'appareil, ne peuvent pas être effectuées à l'aide d'un VID/PID de test.

Ce guide explique comment créer et vérifier des certificats Matter non destinés à la production à utiliser pour les tests. Les types de certificats sont les suivants:

La déclaration de certification (CD)
Certificat intermédiaire de certification produit (PAI)
Certificat d'attestation d'appareil (DAC)

Lors du processus de mise en service, un appareil certifié Matter doit s'attester, c'est-à-dire prouver qu'il s'agit d'un produit certifié Matter authentique. Les identifiants utilisés par les appareils Matter pour l'attestation se composent des éléments suivants:

Une paire de clés d'attestation
Chaîne de certificats

Le certificat d'attestation d'appareil (DAC) est le premier maillon de la chaîne de certificats. Il est validé par le certificat intermédiaire d'attestation de produit (PAI), qui est à son tour validé par l'autorité d'attestation de produit (PAA).

Les certificats sont signés en même temps que la paire de clés d'attestation est générée et sont signés à l'aide de la clé privée de l'autorité de certification au niveau supérieur, formant une chaîne de confiance. Ainsi, un certificat DAC est signé par une clé PAI, et un certificat PAI est signé par une clé PAA. Étant au sommet de la chaîne, les certificats PAA sont autosignés. Cette chaîne de confiance forme une structure PAA fédérée, qui est synchronisée par le Distributed Compliance Ledger (DCL).

Pour en savoir plus sur le processus d'attestation et les déclarations de certification (CD), consultez les documents et messages d'attestation supplémentaires et la spécification Matter.

Installer le SDK Matter

Dans ces instructions, nous partons du principe que vous disposez d'une installation fonctionnelle du SDK Matter. Pour en savoir plus, consultez la documentation sur GitHub ou Premiers pas avec Matter.

Installez l'utilitaire hexdump xxd si vous ne l'avez pas. Cet outil est utile pour imprimer les identifiants dans un format de style C:

sudo apt-get install xxd

Build `chip-cert`

Assurez-vous d'utiliser une version récente du SDK. Ces procédures ont été testées sur la SHA GitHub 0b17bce8, sur la branche v1.0-branch:
```
$ cd connectedhomeip
$ git checkout v1.0-branch
$ git pull
```

Créez chip-cert, l'outil utilisé pour plusieurs opérations sur les identifiants des appareils Matter:

Configurez la compilation:

$ cd src/credentials
$ source ../../scripts/activate.sh
$ gn gen out

Exemple de sortie gn:

Done. Made 5774 targets from 289 files in 658ms

Exécutez le build:

$ ninja -C out

Exemple de sortie ninja:

ninja: Entering directory `out'
[2000/2000] stamp obj/default.stamp

Générer vos certificats

Exportez votre VID/PID personnalisé en tant que variables d'environnement pour réduire les risques d'erreurs lors de la modification de vos arguments de commande:

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

Générer un CD

Générez le CD à l'aide de chip-cert. Actuellement, le commissaire ne vérifie que si le VID et le PID correspondent aux données exposées ailleurs par l'appareil: le cluster d'informations de base, le DAC et l'origine du DAC (lorsqu'il en dispose). Vous pouvez laisser les autres champs tels quels:

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

Vérifiez le CD. Assurez-vous qu'il contient votre VID/PID (au format décimal):

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

Exemple de résultat :

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

Générer un PAI et un DAC

Dans cet exemple, nous utiliserons le certificat de l'autorité d'attestation de produit (PAA) de test de Matter et la clé de signature Chip-Test-PAA-NoVID comme certificat racine. Nous l'utiliserons comme autorité de certification racine pour générer notre propre PAI et notre propre DAC.

Générez l'API à l'aide de la PAA. Vous pouvez inclure les informations PID dans le PAI, mais les omettre vous offre plus de flexibilité pour les tests. Si vous avez besoin de DAC pour des PID supplémentaires, vous pouvez exécuter uniquement l'étape de génération 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

Générez le DAC à l'aide de l'API 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

Vérifiez la chaîne DAC, PAI et PAA. Si aucune erreur ne s'affiche dans la sortie, cela signifie que la chaîne d'attestation de certificat a été validée:

$ 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

Vous pouvez inspecter vos clés à l'aide de openssl:

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

Exemple de résultat :

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

Vous pouvez également utiliser openssl pour inspecter les certificats générés:

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

Exemple de résultat :

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

Un processus similaire peut être utilisé pour générer une PAA autosignée, mais ce n'est pas nécessaire.

Au lieu de cela, nous avons utilisé un PAA de développement autosigné existant qui n'inclut pas d'informations VID.

Pour voir d'autres exemples de génération d'un CD, consultez credentials/test/gen-test-cds.sh. Pour voir d'autres exemples de génération d'un PAA, d'un PAI et d'un DAC, consultez credentials/test/gen-test-attestation-certs.sh.

Remplacer les certificats

Remplacer le PAA et le PAI

Exécutez le script d'assistance suivant, qui utilise l'outil de certification CHIP (chip-cert) pour générer des tableaux de type C de vos certificats.

Télécharger le script d'assistance pour les certificats intégrés

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

Copiez le contenu de la sortie PAI et DAC dans votre implémentation de DeviceAttestationCredentialsProvider::GetProductAttestationIntermediateCert.

Sur les appareils de production, le PAI et le DAC se trouvent dans les données d'usine, tandis que le CD est intégré au micrologiciel lui-même.

Si vous n'utilisez pas encore les données d'usine, vous pouvez placer votre PAI dans src/credentials/examples/ExampleDACs.cpp. Dans ce cas, ajoutez le code généré à votre fichier 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

Si vous utilisez des données d'usine ou un fournisseur d'identifiants personnalisé, veillez à insérer les identifiants aux emplacements appropriés. Vous pouvez contacter votre fournisseur de SoC pour connaître les spécificités de votre plate-forme.

Remplacer le CD

Extrayez une représentation textuelle du contenu de votre fichier CD à l'aide de xxd:

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

Exemple de résultat :

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

Copiez le texte que vous avez extrait à l'étape précédente dans le fichier utilisé pour définir le CD dans votre build. Comme pour les PAI et les DAC, la méthode à suivre dépend de la plate-forme sur laquelle vous effectuez le développement.

Si vous utilisez les exemples d'identifiants, vous devrez probablement remplacer le contenu de kCdForAllExamples dans ExampleDACProvider::GetCertificationDeclaration, dans 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
        };

Créer la cible

Créez et flashez votre cible à l'aide de vos nouveaux identifiants. Cette section dépend de la plate-forme. Pour en savoir plus, consultez la documentation de votre SoC ou la section Appareils compatibles.

Mettre en service l'appareil

Vous pouvez maintenant suivre la procédure décrite dans Associer un appareil Matter pour mettre en service votre appareil Matter sur le Google Home platform.

Déboguer les problèmes à l'aide de `chip-tool`

chip-tool peut être un outil utile pour vérifier si votre appareil envoie les certificats appropriés. Pour le créer:

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

Pour activer des journaux supplémentaires, chaque fois que vous exécutez chip-tool, veillez à transmettre l'indicateur --trace_decode 1. De plus, nous vous recommandons de transmettre le chemin d'accès à votre fichier PAA avec l'indicateur --paa-trust-store-path.

Pour mettre en service un appareil Thread à l'aide du BLE, vous pouvez exécuter les commandes suivantes:

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

Dans le cas des appareils de test, <PAIRING CODE> est 20202021 et <DISCRIMINATOR> est 3840.

Pour obtenir vos identifiants Thread à partir de votre Google Nest Hub (2nd gen), vous pouvez exécuter:

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

Pour mettre en service un appareil Wi-Fi, vous pouvez utiliser l'option ble-wifi:

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

Préparer une image OTA

Test OTA de Matter

Créer des certificats de test des appareils Matter

Installer le SDK Matter

Build chip-cert

Générer vos certificats

Générer un CD

Générer un PAI et un DAC

PAA

Remplacer les certificats

Remplacer le PAA et le PAI

Remplacer le CD

Créer la cible

Mettre en service l'appareil

Déboguer les problèmes à l'aide de chip-tool

Build `chip-cert`

Déboguer les problèmes à l'aide de `chip-tool`