À partir de 2026, toutes les intégrations et tous les tests Matter nécessiteront l'Interop Test de l'Alliance. Pour en savoir plus, consultez la page de transition de l'Alliance Interop Test Lab.

Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Créer des certificats de test des appareils Matter

Certains scénarios de développement, tels que les tests OTA, nécessitent la création de certificats Matter hors production.

Certaines fonctionnalités de l'écosystème de 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 valider des certificats Matter hors production à des fins de test. Voici les types de certificats :

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

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

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

Le certificat d'attestation d'appareil (DAC) est le premier lien 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 un niveau au-dessus, 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 de PAA fédérée, qui est synchronisée par le registre de conformité distribué (DCL, Distributed Compliance Ledger).

Pour en savoir plus sur le processus d'attestation et les déclarations de certification (CD), consultez 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 le SHA GitHub 0b17bce8, sur la branche v1.0-branch :
```
$ cd connectedhomeip
$ git checkout v1.0-branch
$ git pull
```

Build chip-cert, qui est 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 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

Créer vos certificats

Exportez votre VID/PID personnalisé en tant que variables d'environnement pour réduire les risques d'erreur de saisie 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 vérifie uniquement que 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 (le cas échéant). Vous pouvez laisser les autres champs 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. 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 allons utiliser le certificat et la clé de signature Chip-Test-PAA-NoVID de l'autorité de certification de produit (PAA) de test de Matter comme certificat racine. Nous l'utiliserons comme autorité de certification racine pour générer nos propres PAI et DAC.

Générez le PAI à l'aide du PAA. Vous pouvez éventuellement 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 du 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 n'apparaît dans le résultat, cela 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

Un processus similaire pourrait être utilisé pour générer un PAA autosigné, mais cela n'est pas nécessaire.

À la place, nous avons utilisé un PAA de développement autosigné existant qui n'inclut pas d'informations VID.

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

Remplacer les certificats

Remplacer l'AAP et l'AIP

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

Télécharger le script 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 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é obtenu à 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 Factory Data ou un fournisseur d'identifiants personnalisé, veillez à insérer les identifiants aux emplacements appropriés. Vous pouvez vérifier auprès de votre fournisseur de SoC 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 procédure 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 de vos identifiants nouvellement créés. 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éjà 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 bons certificats. 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, veillez à transmettre l'option --trace_decode 1 chaque fois que vous exécutez chip-tool. De plus, il est recommandé de transmettre le chemin d'accès de votre fichier PAA avec l'option --paa-trust-store-path.

Ainsi, pour mettre en service un appareil Thread à l'aide du 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> est 20202021 et <DISCRIMINATOR> est 3840.

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

$ 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

Créer des certificats de test des appareils Matter Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Installer le SDK Matter

Build chip-cert

Créer vos certificats

Générer un CD

Générer un PAI et un DAC

PAA

Remplacer les certificats

Remplacer l'AAP et l'AIP

Remplacer le CD

Créer la cible

Mettre en service l'appareil

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

Créer des certificats de test des appareils Matter

Build `chip-cert`

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