tree e09baeeb152578ab5f62d6c45cf74aeb0091f5c6
parent 37003a349b048b262c5788725857667052243e45
author James Swan <122404367+swan-amazon@users.noreply.github.com> 1685078287 -0700
committer GitHub <noreply@github.com> 1685078287 -0700
gpgsig -----BEGIN PGP SIGNATURE-----
 
 wsBcBAABCAAQBQJkcEEPCRBK7hj4Ov3rIwAAiwkIADPqoOvwgR5Obp62eMB/CjW0
 IZBDd8KXVLQOmEwrHoXUeaDXSOc57cqXrGOwPm0I8EWM3pl49kXcmFxyyyetjKST
 6JVzhTQ8KX7R/jZ1MKNSQ7YQPG3d0cVsYf8IaIKnW8EAHsUodMDTQHhG+qotE5wO
 mkFhltEzlBViYi/ngPycavFwPvhsgvHTicJ6CqmM3YdovRBdQNjZvS+JlPtKzE8Y
 lUyScwqJBLY7qaZWKbPoeJeOsnCvxeequOSR7oU2UNbmGjnlZiuOFCjZd53HasoQ
 356p7aO4OPyDv/qWzq794UErMQazABDfYywU3fdfTPZZBPIBZhMRSsD9Eg59+YQ=
 =OdG/
 -----END PGP SIGNATURE-----
 

[BUG] Linux Test Harness Certification Declaration encoding error (#26812)

* [BUG] Linux Test Harness Certification Declaration encoding error

During internal QA testing related to commissioning the
[chip-certification-tool (TH v 2.8.1 - 1.1 Release Build)](https://github.com/CHIP-Specifications/chip-certification-tool/releases/tag/v2.8.1-official)
a failure occurred while attempting to verify the Certification
Declaration payload using the latest releases of Bouncy Castle.

> **11.17.5.5. Attestation Information**
>
> The certification_declaration field SHALL be the DER-encoded octet
string representation of a CMS-formatted certification declaration, as
described in Section 6.3, “Certification Declaration”.

The [specific exception](https://github.com/bcgit/bc-java/blob/876bd0cf02811282707ddd38e4f0f9212a9f4d1f/core/src/main/java/org/bouncycastle/asn1/ASN1Primitive.java#L46-L49)
is thrown while attempting to decode the DER-encoded octet string, due
to unexpected bytes remaining after attempting to decode the packet.
After extracting the Certification Declaration payload and attempting to
perform manual validation using openssl, it was double-confirmed that
the payload contained an encoding error.

Finally, the Certification Declaration payload was confirmed to have an
extra byte originating from the hardcoded test payload. After the extra
byte is removed, the payload decoding is successful.

* Reverted changes to generated files

* Switched from sizeof to ArraySize.