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 applications hors production Les certificats Matter

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

Ce guide vous explique comment créer et valider un environnement hors production Matter certificats à utiliser pour les tests. Les types de les certificats suivants:

Déclaration de certification (CD)
Certificat intermédiaire d'attestation de produit (PAI)
Le certificat d'attestation de l'appareil (DAC)

Au cours du processus de mise en service, un Matter certifié l'appareil doit attester lui-même, c'est-à-dire prouver que c'est un produit authentique certifié Matter. Identifiants utilisés par Matter appareils pour l'attestation se composent des éléments suivants:

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

Le certificat d'attestation de l'appareil (DAC) est le premier lien du certificat d'attestation des produits. Elle est validée par le certificat intermédiaire d'attestation de produit (PAI), qui est à son tour validée par l'autorité d'attestation des produits (AP),

Les certificats sont signés en même temps que la paire de clés d'attestation générées et signées à l'aide de la clé privée de l'autorité de certification au niveau supérieur, formant ainsi 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. En tant que haut de la chaîne, les certificats PAA sont autosignés. Cette chaîne de confiance forme une structure PAA fédérée, synchronisée par le biais Ledger de conformité distribué (DCL).

Vous trouverez peut-être de plus amples informations sur le processus d'attestation et les déclarations de certification se trouvent dans Autres documents d'attestation Messages et dans la spécification Matter.

Installer le SDK Matter

Ces instructions partent du principe que l'installation SDK Matter. Reportez-vous à sa documentation sur GitHub ou consultez Premiers pas avec Matter pour plus d'informations.

Si vous ne l'avez pas déjà, installez l'utilitaire hexdump xxd. 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 étaient Testé sur GitHub SHA 0b17bce8, sur la branche v1.0-branch:
```
$ cd connectedhomeip
$ git checkout v1.0-branch
$ git pull
```

Compilez chip-cert, qui est l'outil utilisé pour effectuer plusieurs opérations sur identifiants pour Matter appareils:

Configurez la compilation:

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

Exemple de résultat gn:

Done. Made 5774 targets from 289 files in 658ms

Exécutez la compilation:

$ ninja -C out

Exemple de résultat 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 erreur lors de la modification des arguments de votre 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 valide que le VID et le PID correspondent aux données exposées ailleurs par l'appareil : Cluster d'informations de base, origine DAC et DAC (le cas échéant). Vous pouvez quitter les autres champs restent inchangés:

$ 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. Vérifiez 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 une DAC

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

Générez le PAI à l'aide du PAA. Vous pouvez aussi inclure le PID des informations dans l'API, mais vous pouvez les omettre tests. Si vous avez besoin de DAC pour des PID supplémentaires, vous pouvez exécuter uniquement le Étape de génération d'un fichier 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 fichier 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 les chaînes DAC, PAI et PAA. Si aucune erreur ne s'affiche dans le résultat, signifie que la chaîne d'attestation de certificat a bien é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

Vous pouvez utiliser un processus similaire pour générer un PAA autosigné, n'est pas nécessaire.

Ici, nous utilisons plutôt un PAA de développement autosigné existant. qui n'inclut pas d'informations sur le VID.

Pour plus d'exemples de génération de CD, consultez credentials/test/gen-test-cds.sh Pour voir d'autres exemples de génération d'un PAA, d'un PAI ou 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 certificat CHIP (chip-cert) pour générer des tableaux de certificats de style C.

Télécharger le script de l'outil d'aide pour les certificats intégrables

#!/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 des résultats de PAI et DAC dans votre implémentation de DeviceAttestationCredentialsProvider::GetProductAttestationIntermediateCert

Sur les appareils de production, le PAI et la DAC Données d'usine, alors que le CD est intégré dans le 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é généré dans 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é, assurez-vous pour insérer les identifiants aux emplacements appropriés. Vous voudrez peut-être vérifiez auprès de votre fournisseur de SoC les spécificités de votre plateforme.

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 extrait à l'étape précédente dans le fichier utilisé pour définir le CD dans votre build. Comme dans le cas des PAI et DAC, dépend de la plate-forme sur laquelle vous développez.

Si vous utilisez les exemples d'identifiants, vous souhaiterez 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 des nouveaux identifiants. Ce dépend de la plate-forme. Consultez la documentation sur le SoC ou Appareils compatibles pour en savoir plus.

Mettre l'appareil en service

Vous pouvez maintenant suivre les étapes déjà décrites dans Associer un Matter appareil sur mettre en service votre appareil Matter le Google Home platform

Déboguer les problèmes avec `chip-tool`

chip-tool peut être un outil précieux pour vérifier si votre appareil envoie les bonnes certificats. Pour la 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, lorsque vous exécutez chip-tool, veillez à transmettre la méthode --trace_decode 1. De plus, il est recommandé de transmettre le chemin Fichier PAA avec l'indicateur --paa-trust-store-path.

Ainsi, pour mettre en service un appareil Thread utilisant la technologie BLE, vous pouvez exécuter la commande suivante:

```
$ 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> correspond à 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 une DAC

PAA

Remplacer les certificats

Remplacer le PAA et le PAI

Remplacer le CD

Créer la cible

Mettre l'appareil en service

Déboguer les problèmes avec chip-tool

Build `chip-cert`

Déboguer les problèmes avec `chip-tool`