blob: db8b1ae8ccf59545e0f3ea792b43b129eb76f3b5 [file] [log] [blame]
/*
*
* Copyright (c) 2020-2021 Project CHIP Authors
* Copyright (c) 2013-2017 Nest Labs, Inc.
* All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @file
* This file implements a process to effect a functional test for
* the CHIP Abstract Syntax Notifcation One (ASN1) encode and
* decode interfaces.
*
*/
#include <gtest/gtest.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <lib/asn1/ASN1.h>
#include <lib/asn1/ASN1Macros.h>
#include <lib/core/TLV.h>
using namespace chip;
using namespace chip::ASN1;
using namespace chip::TLV;
enum
{
kTestVal_01_Bool = false,
kTestVal_02_Bool = true,
kTestVal_03_BitString = 0x0,
kTestVal_04_BitString = 0x1,
kTestVal_05_BitString = 0x3,
kTestVal_06_BitString = 0x17,
kTestVal_07_BitString = 0x37,
kTestVal_08_BitString = 0x187,
kTestVal_09_BitString = 0x3E7,
kTestVal_10_Int = 0,
kTestVal_11_Int = 1,
kTestVal_12_Int = -1,
kTestVal_13_Int = 0xFF00FF,
kTestVal_14_Int = -0xFF00FF,
kTestVal_15_Int = INT32_MAX,
kTestVal_16_Int = INT32_MIN,
kTestVal_17_Int = INT64_MAX,
kTestVal_18_Int = INT64_MIN,
kTestVal_19_OID = kOID_AttributeType_OrganizationName,
kTestVal_23_OID = kOID_AttributeType_CommonName,
kTestVal_24_Int = 42,
};
// clang-format off
static uint8_t kTestVal_09_BitString_AsOctetString[] = { 0xE7, 0xC0 };
static uint8_t kTestVal_20_OctetString[] = { 0x01, 0x03, 0x05, 0x07, 0x10, 0x30, 0x50, 0x70, 0x00 };
static const char kTestVal_21_PrintableString[] = "Sudden death in Venice";
static const char kTestVal_22_UTFString[] = "Ond bra\xCC\x8A""d do\xCC\x88""d i Venedig";
// clang-format on
// Manually copied from ASN1OID.h for testing.
static const uint8_t sOID_AttributeType_ChipNodeId[] = { 0x2B, 0x06, 0x01, 0x04, 0x01, 0x82, 0xA2, 0x7C, 0x01, 0x01 };
static const uint8_t sOID_SigAlgo_ECDSAWithSHA256[] = { 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x02 };
static const uint8_t sOID_EllipticCurve_prime256v1[] = { 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03, 0x01, 0x07 };
static const uint8_t sOID_Extension_AuthorityKeyIdentifier[] = { 0x55, 0x1D, 0x23 };
static const uint8_t sOID_Extension_BasicConstraints[] = { 0x55, 0x1D, 0x13 };
static const uint8_t sOID_KeyPurpose_ServerAuth[] = { 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x03, 0x01 };
uint8_t TestASN1_EncodedData[] = {
0x30, 0x81, 0xBA, 0x01, 0x01, 0x00, 0x01, 0x01, 0xFF, 0x31, 0x00, 0x03, 0x01, 0x00, 0x03, 0x02, 0x07, 0x80, 0x03, 0x02, 0x06,
0xC0, 0x30, 0x16, 0x30, 0x0F, 0x30, 0x08, 0x03, 0x02, 0x03, 0xE8, 0x03, 0x02, 0x02, 0xEC, 0x03, 0x03, 0x07, 0xE1, 0x80, 0x03,
0x03, 0x06, 0xE7, 0xC0, 0x02, 0x01, 0x00, 0x02, 0x01, 0x01, 0x02, 0x01, 0xFF, 0x02, 0x04, 0x00, 0xFF, 0x00, 0xFF, 0x02, 0x04,
0xFF, 0x00, 0xFF, 0x01, 0x02, 0x04, 0x7F, 0xFF, 0xFF, 0xFF, 0x02, 0x04, 0x80, 0x00, 0x00, 0x00, 0x02, 0x08, 0x7F, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x02, 0x08, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x03, 0x55, 0x04, 0x0A, 0x04,
0x09, 0x01, 0x03, 0x05, 0x07, 0x10, 0x30, 0x50, 0x70, 0x00, 0x04, 0x01, 0x01, 0x04, 0x00, 0x1B, 0x00, 0x13, 0x16, 0x53, 0x75,
0x64, 0x64, 0x65, 0x6E, 0x20, 0x64, 0x65, 0x61, 0x74, 0x68, 0x20, 0x69, 0x6E, 0x20, 0x56, 0x65, 0x6E, 0x69, 0x63, 0x65, 0x0C,
0x1A, 0x4F, 0x6E, 0x64, 0x20, 0x62, 0x72, 0x61, 0xCC, 0x8A, 0x64, 0x20, 0x64, 0x6F, 0xCC, 0x88, 0x64, 0x20, 0x69, 0x20, 0x56,
0x65, 0x6E, 0x65, 0x64, 0x69, 0x67, 0x04, 0x0D, 0x30, 0x0B, 0x06, 0x03, 0x55, 0x04, 0x03, 0x03, 0x04, 0x00, 0x02, 0x01, 0x2A
};
static CHIP_ERROR EncodeASN1TestData(ASN1Writer & writer)
{
CHIP_ERROR err = CHIP_NO_ERROR;
ASN1_START_SEQUENCE
{
ASN1_ENCODE_BOOLEAN(kTestVal_01_Bool);
ASN1_ENCODE_BOOLEAN(kTestVal_02_Bool);
ASN1_START_SET {}
ASN1_END_SET;
ASN1_ENCODE_BIT_STRING(kTestVal_03_BitString);
ASN1_ENCODE_BIT_STRING(kTestVal_04_BitString);
ASN1_ENCODE_BIT_STRING(kTestVal_05_BitString);
ASN1_START_SEQUENCE
{
ASN1_START_SEQUENCE
{
ASN1_START_SEQUENCE
{
ASN1_ENCODE_BIT_STRING(kTestVal_06_BitString);
ASN1_ENCODE_BIT_STRING(kTestVal_07_BitString);
}
ASN1_END_SEQUENCE;
ASN1_ENCODE_BIT_STRING(kTestVal_08_BitString);
}
ASN1_END_SEQUENCE;
ASN1_ENCODE_BIT_STRING(kTestVal_09_BitString);
}
ASN1_END_SEQUENCE;
ASN1_ENCODE_INTEGER(kTestVal_10_Int);
ASN1_ENCODE_INTEGER(kTestVal_11_Int);
ASN1_ENCODE_INTEGER(kTestVal_12_Int);
ASN1_ENCODE_INTEGER(kTestVal_13_Int);
ASN1_ENCODE_INTEGER(kTestVal_14_Int);
ASN1_ENCODE_INTEGER(kTestVal_15_Int);
ASN1_ENCODE_INTEGER(kTestVal_16_Int);
ASN1_ENCODE_INTEGER(kTestVal_17_Int);
ASN1_ENCODE_INTEGER(kTestVal_18_Int);
ASN1_ENCODE_OBJECT_ID(kTestVal_19_OID);
ASN1_ENCODE_OCTET_STRING(kTestVal_20_OctetString, sizeof(kTestVal_20_OctetString));
ASN1_ENCODE_OCTET_STRING(kTestVal_20_OctetString, 1);
ASN1_ENCODE_OCTET_STRING(kTestVal_20_OctetString, 0);
ASN1_ENCODE_STRING(kASN1UniversalTag_GeneralString, "", 0);
ASN1_ENCODE_STRING(kASN1UniversalTag_PrintableString, kTestVal_21_PrintableString,
static_cast<uint16_t>(strlen(kTestVal_21_PrintableString)));
ASN1_ENCODE_STRING(kASN1UniversalTag_UTF8String, kTestVal_22_UTFString,
static_cast<uint16_t>(strlen(kTestVal_22_UTFString)));
ASN1_START_OCTET_STRING_ENCAPSULATED
{
ASN1_START_SEQUENCE
{
ASN1_ENCODE_OBJECT_ID(kTestVal_23_OID);
ASN1_START_BIT_STRING_ENCAPSULATED
{
ASN1_ENCODE_INTEGER(kTestVal_24_Int);
}
ASN1_END_ENCAPSULATED;
}
ASN1_END_SEQUENCE;
}
ASN1_END_ENCAPSULATED;
}
ASN1_END_SEQUENCE;
exit:
return err;
}
TEST(TestASN1, Encode)
{
CHIP_ERROR err;
static uint8_t buf[2048];
ASN1Writer writer;
size_t encodedLen;
writer.Init(buf);
err = EncodeASN1TestData(writer);
EXPECT_EQ(err, CHIP_NO_ERROR);
encodedLen = writer.GetLengthWritten();
EXPECT_EQ(encodedLen, sizeof(TestASN1_EncodedData));
EXPECT_EQ(memcmp(buf, TestASN1_EncodedData, sizeof(TestASN1_EncodedData)), 0);
#define DUMP_HEX 0
#if DUMP_HEX
for (uint16_t i = 0; i < encodedLen; i++)
{
if (i != 0 && i % 16 == 0)
printf("\n");
printf("0x%02X, ", buf[i]);
}
printf("\n");
#endif
}
TEST(TestASN1, Decode)
{
CHIP_ERROR err = CHIP_NO_ERROR;
ASN1Reader reader;
bool boolVal;
uint32_t bitStringVal;
int64_t intVal;
OID oidVal;
reader.Init(TestASN1_EncodedData);
ASN1_PARSE_ENTER_SEQUENCE
{
ASN1_PARSE_BOOLEAN(boolVal);
EXPECT_EQ(boolVal, kTestVal_01_Bool);
ASN1_PARSE_BOOLEAN(boolVal);
EXPECT_EQ(boolVal, kTestVal_02_Bool);
ASN1_PARSE_ENTER_SET {}
ASN1_EXIT_SET;
ASN1_PARSE_BIT_STRING(bitStringVal);
EXPECT_EQ(bitStringVal, kTestVal_03_BitString);
ASN1_PARSE_BIT_STRING(bitStringVal);
EXPECT_EQ(bitStringVal, kTestVal_04_BitString);
ASN1_PARSE_BIT_STRING(bitStringVal);
EXPECT_EQ(bitStringVal, kTestVal_05_BitString);
ASN1_PARSE_ENTER_SEQUENCE
{
ASN1_PARSE_ENTER_SEQUENCE
{
ASN1_PARSE_ENTER_SEQUENCE
{
ASN1_PARSE_BIT_STRING(bitStringVal);
EXPECT_EQ(bitStringVal, kTestVal_06_BitString);
ASN1_PARSE_BIT_STRING(bitStringVal);
EXPECT_EQ(bitStringVal, kTestVal_07_BitString);
}
ASN1_EXIT_SEQUENCE;
ASN1_PARSE_BIT_STRING(bitStringVal);
EXPECT_EQ(bitStringVal, kTestVal_08_BitString);
}
ASN1_EXIT_SEQUENCE;
ASN1_PARSE_BIT_STRING(bitStringVal);
EXPECT_EQ(bitStringVal, kTestVal_09_BitString);
}
ASN1_EXIT_SEQUENCE;
ASN1_PARSE_INTEGER(intVal);
EXPECT_EQ(intVal, kTestVal_10_Int);
ASN1_PARSE_INTEGER(intVal);
EXPECT_EQ(intVal, kTestVal_11_Int);
ASN1_PARSE_INTEGER(intVal);
EXPECT_EQ(intVal, kTestVal_12_Int);
ASN1_PARSE_INTEGER(intVal);
EXPECT_EQ(intVal, kTestVal_13_Int);
ASN1_PARSE_INTEGER(intVal);
EXPECT_EQ(intVal, kTestVal_14_Int);
ASN1_PARSE_INTEGER(intVal);
EXPECT_EQ(intVal, kTestVal_15_Int);
ASN1_PARSE_INTEGER(intVal);
EXPECT_EQ(intVal, kTestVal_16_Int);
ASN1_PARSE_INTEGER(intVal);
EXPECT_EQ(intVal, kTestVal_17_Int);
ASN1_PARSE_INTEGER(intVal);
EXPECT_EQ(intVal, kTestVal_18_Int);
ASN1_PARSE_OBJECT_ID(oidVal);
EXPECT_EQ(oidVal, kTestVal_19_OID);
ASN1_PARSE_ELEMENT(kASN1TagClass_Universal, kASN1UniversalTag_OctetString);
EXPECT_EQ(reader.GetValueLen(), sizeof(kTestVal_20_OctetString));
EXPECT_EQ(memcmp(reader.GetValue(), kTestVal_20_OctetString, sizeof(kTestVal_20_OctetString)), 0);
ASN1_PARSE_ELEMENT(kASN1TagClass_Universal, kASN1UniversalTag_OctetString);
EXPECT_EQ(reader.GetValueLen(), 1u);
EXPECT_EQ(reader.GetValue()[0], kTestVal_20_OctetString[0]);
ASN1_PARSE_ELEMENT(kASN1TagClass_Universal, kASN1UniversalTag_OctetString);
EXPECT_EQ(reader.GetValueLen(), 0u);
ASN1_PARSE_ELEMENT(kASN1TagClass_Universal, kASN1UniversalTag_GeneralString);
EXPECT_EQ(reader.GetValueLen(), 0u);
ASN1_PARSE_ELEMENT(kASN1TagClass_Universal, kASN1UniversalTag_PrintableString);
EXPECT_EQ(reader.GetValueLen(), strlen(kTestVal_21_PrintableString));
EXPECT_EQ(memcmp(reader.GetValue(), kTestVal_21_PrintableString, strlen(kTestVal_21_PrintableString)), 0);
ASN1_PARSE_ELEMENT(kASN1TagClass_Universal, kASN1UniversalTag_UTF8String);
EXPECT_EQ(reader.GetValueLen(), strlen(kTestVal_22_UTFString));
EXPECT_EQ(memcmp(reader.GetValue(), kTestVal_22_UTFString, strlen(kTestVal_22_UTFString)), 0);
ASN1_PARSE_ENTER_ENCAPSULATED(kASN1TagClass_Universal, kASN1UniversalTag_OctetString)
{
ASN1_PARSE_ENTER_SEQUENCE
{
ASN1_PARSE_OBJECT_ID(oidVal);
EXPECT_EQ(oidVal, kTestVal_23_OID);
ASN1_PARSE_ENTER_ENCAPSULATED(kASN1TagClass_Universal, kASN1UniversalTag_BitString)
{
ASN1_PARSE_INTEGER(intVal);
EXPECT_EQ(intVal, kTestVal_24_Int);
}
ASN1_EXIT_ENCAPSULATED;
}
ASN1_EXIT_SEQUENCE;
}
ASN1_EXIT_ENCAPSULATED;
}
ASN1_EXIT_SEQUENCE;
exit:
EXPECT_EQ(err, CHIP_NO_ERROR);
}
TEST(TestASN1, NullWriter)
{
CHIP_ERROR err;
ASN1Writer writer;
size_t encodedLen;
writer.InitNullWriter();
err = EncodeASN1TestData(writer);
EXPECT_EQ(err, CHIP_NO_ERROR);
encodedLen = writer.GetLengthWritten();
EXPECT_EQ(encodedLen, 0u);
// Methods that take a reader should still read from it,
// even if the output is suppressed by the null writer.
TLVReader emptyTlvReader;
emptyTlvReader.Init(ByteSpan());
err = writer.PutBitString(0, emptyTlvReader);
EXPECT_EQ(err, CHIP_ERROR_WRONG_TLV_TYPE);
emptyTlvReader.Init(ByteSpan());
err = writer.PutOctetString(kASN1TagClass_ContextSpecific, 123, emptyTlvReader);
EXPECT_EQ(err, CHIP_ERROR_WRONG_TLV_TYPE);
}
TEST(TestASN1, ASN1UniversalTime)
{
struct ASN1TimeTestCase
{
ASN1UniversalTime asn1Time;
const char * asn1TimeStr;
};
struct ASN1TimeErrorTestCase
{
const char * asn1TimeStr;
CHIP_ERROR mExpectedResult;
};
// clang-format off
static ASN1TimeTestCase sASN1TimeTestCases[] = {
// ASN1 Universal Time ASN1_TIME String
// ====================================================
{ { 2020, 10, 15, 14, 23, 43 }, "201015142343Z" },
{ { 2020, 12, 1, 2, 34, 0 }, "201201023400Z" },
{ { 1979, 1, 30, 12, 0, 0 }, "790130120000Z" },
{ { 2079, 1, 30, 12, 0, 0 }, "20790130120000Z" },
{ { 2049, 3, 31, 23, 59, 59 }, "490331235959Z" },
{ { 1949, 3, 31, 23, 59, 59 }, "19490331235959Z" },
{ { 1950, 3, 31, 23, 59, 59 }, "500331235959Z" },
};
// clang-format on
// clang-format off
static ASN1TimeErrorTestCase sASN1TimeErrorTestCases[] = {
// ASN1_TIME String Expected Result
// =======================================================
{ "201015142343z", ASN1_ERROR_UNSUPPORTED_ENCODING },
{ "20105142343Z", ASN1_ERROR_UNSUPPORTED_ENCODING },
{ "2010115142343Z", ASN1_ERROR_UNSUPPORTED_ENCODING },
{ "201014415142343Z", ASN1_ERROR_UNSUPPORTED_ENCODING },
{ "201O15142343Z", ASN1_ERROR_INVALID_ENCODING },
{ "200015142343Z", ASN1_ERROR_INVALID_ENCODING },
{ "201315142343Z", ASN1_ERROR_INVALID_ENCODING },
{ "201000142343Z", ASN1_ERROR_INVALID_ENCODING },
{ "201032142343Z", ASN1_ERROR_INVALID_ENCODING },
{ "201015242343Z", ASN1_ERROR_INVALID_ENCODING },
{ "201015146043Z", ASN1_ERROR_INVALID_ENCODING },
{ "201015142360Z", ASN1_ERROR_INVALID_ENCODING },
};
// clang-format on
for (auto & testCase : sASN1TimeTestCases)
{
CharSpan testStr = CharSpan(testCase.asn1TimeStr, strlen(testCase.asn1TimeStr));
ASN1UniversalTime result;
EXPECT_EQ(result.ImportFrom_ASN1_TIME_string(testStr), CHIP_NO_ERROR);
EXPECT_EQ(result.Year, testCase.asn1Time.Year);
EXPECT_EQ(result.Month, testCase.asn1Time.Month);
EXPECT_EQ(result.Day, testCase.asn1Time.Day);
EXPECT_EQ(result.Hour, testCase.asn1Time.Hour);
EXPECT_EQ(result.Minute, testCase.asn1Time.Minute);
EXPECT_EQ(result.Second, testCase.asn1Time.Second);
char buf[ASN1UniversalTime::kASN1TimeStringMaxLength];
MutableCharSpan resultTimeStr(buf);
EXPECT_EQ(result.ExportTo_ASN1_TIME_string(resultTimeStr), CHIP_NO_ERROR);
EXPECT_TRUE(resultTimeStr.data_equal(testStr));
}
for (auto & testCase : sASN1TimeErrorTestCases)
{
CharSpan testStr = CharSpan(testCase.asn1TimeStr, strlen(testCase.asn1TimeStr));
ASN1UniversalTime result;
EXPECT_EQ(result.ImportFrom_ASN1_TIME_string(testStr), testCase.mExpectedResult);
}
}
TEST(TestASN1, ObjectID)
{
CHIP_ERROR err;
static uint8_t buf[2048];
ASN1Writer writer;
ASN1Reader reader;
size_t encodedLen;
writer.Init(buf, sizeof(buf));
ASN1_START_SEQUENCE
{
ASN1_ENCODE_OBJECT_ID(kOID_AttributeType_MatterNodeId);
ASN1_ENCODE_OBJECT_ID(kOID_SigAlgo_ECDSAWithSHA256);
ASN1_ENCODE_OBJECT_ID(kOID_EllipticCurve_prime256v1);
ASN1_ENCODE_OBJECT_ID(kOID_Extension_AuthorityKeyIdentifier);
ASN1_ENCODE_OBJECT_ID(kOID_Extension_BasicConstraints);
ASN1_ENCODE_OBJECT_ID(kOID_KeyPurpose_ServerAuth);
}
ASN1_END_SEQUENCE;
encodedLen = writer.GetLengthWritten();
EXPECT_GT(encodedLen, 0u);
reader.Init(buf, encodedLen);
// Parse and check OIDs as actual ASN1 encoded values.
ASN1_PARSE_ENTER_SEQUENCE
{
ASN1_PARSE_ELEMENT(kASN1TagClass_Universal, kASN1UniversalTag_ObjectId);
EXPECT_EQ(reader.GetValueLen(), sizeof(sOID_AttributeType_ChipNodeId));
EXPECT_EQ(memcmp(reader.GetValue(), sOID_AttributeType_ChipNodeId, sizeof(sOID_AttributeType_ChipNodeId)), 0);
ASN1_PARSE_ELEMENT(kASN1TagClass_Universal, kASN1UniversalTag_ObjectId);
EXPECT_EQ(reader.GetValueLen(), sizeof(sOID_SigAlgo_ECDSAWithSHA256));
EXPECT_EQ(memcmp(reader.GetValue(), sOID_SigAlgo_ECDSAWithSHA256, sizeof(sOID_SigAlgo_ECDSAWithSHA256)), 0);
ASN1_PARSE_ELEMENT(kASN1TagClass_Universal, kASN1UniversalTag_ObjectId);
EXPECT_EQ(reader.GetValueLen(), sizeof(sOID_EllipticCurve_prime256v1));
EXPECT_EQ(memcmp(reader.GetValue(), sOID_EllipticCurve_prime256v1, sizeof(sOID_EllipticCurve_prime256v1)), 0);
ASN1_PARSE_ELEMENT(kASN1TagClass_Universal, kASN1UniversalTag_ObjectId);
EXPECT_EQ(reader.GetValueLen(), sizeof(sOID_Extension_AuthorityKeyIdentifier));
EXPECT_EQ(memcmp(reader.GetValue(), sOID_Extension_AuthorityKeyIdentifier, sizeof(sOID_Extension_AuthorityKeyIdentifier)),
0);
ASN1_PARSE_ELEMENT(kASN1TagClass_Universal, kASN1UniversalTag_ObjectId);
EXPECT_EQ(reader.GetValueLen(), sizeof(sOID_Extension_BasicConstraints));
EXPECT_EQ(memcmp(reader.GetValue(), sOID_Extension_BasicConstraints, sizeof(sOID_Extension_BasicConstraints)), 0);
ASN1_PARSE_ELEMENT(kASN1TagClass_Universal, kASN1UniversalTag_ObjectId);
EXPECT_EQ(reader.GetValueLen(), sizeof(sOID_KeyPurpose_ServerAuth));
EXPECT_EQ(memcmp(reader.GetValue(), sOID_KeyPurpose_ServerAuth, sizeof(sOID_KeyPurpose_ServerAuth)), 0);
}
ASN1_EXIT_SEQUENCE;
exit:
EXPECT_EQ(err, CHIP_NO_ERROR);
}
TEST(TestASN1, FromTLVReader)
{
CHIP_ERROR err;
static uint8_t tlvBuf[128];
static uint8_t asn1Buf1[128];
static uint8_t asn1Buf2[128];
TLVWriter tlvWriter;
TLVReader tlvReader;
ASN1Writer writer;
ASN1Reader reader;
MutableByteSpan tlvEncodedData(tlvBuf);
MutableByteSpan asn1EncodedData1(asn1Buf1);
MutableByteSpan asn1EncodedData2(asn1Buf2);
TLVType outerContainerType;
// Construct TLV Encoded Structure.
{
tlvWriter.Init(tlvEncodedData);
err = tlvWriter.StartContainer(AnonymousTag(), kTLVType_Structure, outerContainerType);
EXPECT_EQ(err, CHIP_NO_ERROR);
err = tlvWriter.PutBytes(TLV::ContextTag(1), kTestVal_20_OctetString, sizeof(kTestVal_20_OctetString));
EXPECT_EQ(err, CHIP_NO_ERROR);
err = tlvWriter.PutBytes(TLV::ContextTag(2), kTestVal_09_BitString_AsOctetString,
sizeof(kTestVal_09_BitString_AsOctetString));
EXPECT_EQ(err, CHIP_NO_ERROR);
err = tlvWriter.PutString(TLV::ContextTag(3), kTestVal_21_PrintableString);
EXPECT_EQ(err, CHIP_NO_ERROR);
err = tlvWriter.EndContainer(outerContainerType);
EXPECT_EQ(err, CHIP_NO_ERROR);
err = tlvWriter.Finalize();
EXPECT_EQ(err, CHIP_NO_ERROR);
}
// Construct first ASN1 SEQUESNCE using values.
writer.Init(asn1EncodedData1);
ASN1_START_SEQUENCE
{
ASN1_ENCODE_OCTET_STRING(kTestVal_20_OctetString, sizeof(kTestVal_20_OctetString));
ASN1_ENCODE_BIT_STRING(kTestVal_09_BitString);
err = writer.PutValue(kASN1TagClass_Universal, kASN1UniversalTag_PrintableString, false,
reinterpret_cast<const uint8_t *>(kTestVal_21_PrintableString),
static_cast<uint16_t>(strlen(kTestVal_21_PrintableString)));
EXPECT_EQ(err, CHIP_NO_ERROR);
}
ASN1_END_SEQUENCE;
asn1EncodedData1.reduce_size(writer.GetLengthWritten());
// Construct second ASN1 SEQUENCE from TLVReader.
tlvReader.Init(tlvEncodedData);
writer.Init(asn1EncodedData2);
ASN1_START_SEQUENCE
{
err = tlvReader.Next(kTLVType_Structure, AnonymousTag());
EXPECT_EQ(err, CHIP_NO_ERROR);
err = tlvReader.EnterContainer(outerContainerType);
EXPECT_EQ(err, CHIP_NO_ERROR);
err = tlvReader.Next(kTLVType_ByteString, ContextTag(1));
EXPECT_EQ(err, CHIP_NO_ERROR);
err = writer.PutOctetString(kASN1TagClass_Universal, kASN1UniversalTag_OctetString, tlvReader);
EXPECT_EQ(err, CHIP_NO_ERROR);
err = tlvReader.Next(kTLVType_ByteString, ContextTag(2));
EXPECT_EQ(err, CHIP_NO_ERROR);
err = writer.PutBitString(6, tlvReader);
EXPECT_EQ(err, CHIP_NO_ERROR);
err = tlvReader.Next(kTLVType_UTF8String, ContextTag(3));
EXPECT_EQ(err, CHIP_NO_ERROR);
err = writer.PutValue(kASN1TagClass_Universal, kASN1UniversalTag_PrintableString, false, tlvReader);
EXPECT_EQ(err, CHIP_NO_ERROR);
err = tlvReader.ExitContainer(outerContainerType);
EXPECT_EQ(err, CHIP_NO_ERROR);
}
ASN1_END_SEQUENCE;
asn1EncodedData2.reduce_size(writer.GetLengthWritten());
// Compare two ASN1 SEQUENCEs.
EXPECT_TRUE(asn1EncodedData2.data_equal(asn1EncodedData1));
// Initialize ASN1Reader and test data.
reader.Init(asn1EncodedData2);
ASN1_PARSE_ENTER_SEQUENCE
{
ASN1_PARSE_ELEMENT(kASN1TagClass_Universal, kASN1UniversalTag_OctetString);
ASSERT_NE(reader.GetValue(), nullptr);
EXPECT_EQ(reader.GetValueLen(), sizeof(kTestVal_20_OctetString));
EXPECT_EQ(memcmp(reader.GetValue(), kTestVal_20_OctetString, sizeof(kTestVal_20_OctetString)), 0);
uint32_t val;
ASN1_PARSE_BIT_STRING(val);
EXPECT_EQ(val, kTestVal_09_BitString);
ASN1_PARSE_ELEMENT(kASN1TagClass_Universal, kASN1UniversalTag_PrintableString);
ASSERT_NE(reader.GetValue(), nullptr);
EXPECT_EQ(reader.GetValueLen(), strlen(kTestVal_21_PrintableString));
EXPECT_EQ(memcmp(reader.GetValue(), kTestVal_21_PrintableString, strlen(kTestVal_21_PrintableString)), 0);
}
ASN1_EXIT_SEQUENCE;
exit:
EXPECT_EQ(err, CHIP_NO_ERROR);
}