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 la création de certificats Matter non destinés à la production.

Certaines fonctionnalités de l'écosystème Google, y compris les mises à jour logicielles OTA des appareils, 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 non destinés à la production pour les tests. Voici les types de certificats :

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

Lors du processus de mise en service, un appareil certifié Matter doit s'authentifier, 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 :

Paire de clés d'attestation
Chaîne de certificats

Le certificat d'attestation de l'appareil (DAC) est le premier maillon de la chaîne de certificats. Il est validé par le certificat intermédiaire d'attestation du produit (PAI), qui est lui-même validé par l'autorité d'attestation du produit (PAA).

Les certificats sont signés en même temps que la paire de clés d'attestation est générée. Ils sont signés à l'aide de la clé privée de l'autorité de certification de niveau supérieur, ce qui forme 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. Les certificats PAA étant au sommet de la chaîne, ils 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 la procédure d'attestation et les déclarations de certification, consultez Documents et messages d'attestation supplémentaires et la spécification Matter.

Installer le SDK Matter

Ces instructions supposent 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 déjà fait. Cet outil est utile pour imprimer les identifiants au format 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, 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

Générer vos certificats

Exportez votre VID/PID personnalisé en tant que variables d'environnement pour réduire les risques d'erreur de saisie lorsque vous modifiez les 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 valide 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 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 et la clé de signature de l'autorité d'attestation de produit (PAA) de Matter, Chip-Test-PAA-NoVID, comme certificat racine. Nous l'utiliserons comme autorité de certification racine pour générer notre propre PAI et DAC.

Générez l'IAP à l'aide de l'AAP. Vous pouvez inclure les informations PID dans la PAI, mais les omettre vous offre plus de flexibilité pour les tests. Si vous avez besoin de DAC pour d'autres PID, vous pouvez exécuter uniquement l'étape de génération des 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 le résultat, cela signifie que la chaîne d'attestation du certificat a été validée avec succès :

$ 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 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 sur le VID.

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

Remplacer les certificats

Remplacer l'adresse et les informations de paiement

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'assistance 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 Factory Data (Données d'usine), tandis que le CD est intégré au micrologiciel lui-même.

Si vous n'utilisez pas encore Factory Data, vous pouvez placer votre PAI dans src/credentials/examples/ExampleDACs.cpp. Dans ce cas, ajoutez le code généré au 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. Pour en savoir plus sur les spécificités de votre plate-forme, contactez votre fournisseur de SoC.

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 compilation. Comme pour les API et les composants d'accès aux données, la procédure à suivre 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 nouveaux identifiants. Cette section dépend de la plate-forme. Pour en savoir plus, consultez la documentation de votre SoC ou la page Appareils compatibles.

Mettre en service l'appareil

Vous pouvez maintenant suivre les étapes déjà décrites dans Associer un appareil Matter pour mettre en service votre appareil Matter sur 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 compiler :

$ 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'indicateur --trace_decode 1 chaque fois que vous exécutez chip-tool. 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 de 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

Préparer une image OTA

Test OTA de Matter

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

Générer vos certificats

Générer un CD

Générer un PAI et un DAC

PAA

Remplacer les certificats

Remplacer l'adresse et les informations de paiement

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`