blob: d6bb6bb10d3b4d758602f2fb32a0d4946b4aa8ce [file] [log] [blame]
Alexander Afanasyevc169a812014-05-20 20:37:29 -04001/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
Davide Pesaventoc2e12b42017-07-09 20:35:09 -04002/*
Davide Pesavento765abc92021-12-27 00:44:04 -05003 * Copyright (c) 2013-2021 Regents of the University of California.
Alexander Afanasyevdfa52c42014-04-24 21:10:11 -07004 *
5 * This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
Alexander Afanasyevdfa52c42014-04-24 21:10:11 -07006 *
Alexander Afanasyevc169a812014-05-20 20:37:29 -04007 * ndn-cxx library is free software: you can redistribute it and/or modify it under the
8 * terms of the GNU Lesser General Public License as published by the Free Software
9 * Foundation, either version 3 of the License, or (at your option) any later version.
10 *
11 * ndn-cxx library is distributed in the hope that it will be useful, but WITHOUT ANY
12 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
13 * PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
14 *
15 * You should have received copies of the GNU General Public License and GNU Lesser
16 * General Public License along with ndn-cxx, e.g., in COPYING.md file. If not, see
17 * <http://www.gnu.org/licenses/>.
18 *
19 * See AUTHORS.md for complete list of ndn-cxx authors and contributors.
Alexander Afanasyev5fa9e9a2013-12-24 19:45:07 -080020 */
21
Davide Pesavento7e780642018-11-24 15:51:34 -050022#include "ndn-cxx/data.hpp"
23#include "ndn-cxx/encoding/buffer-stream.hpp"
Davide Pesavento7e780642018-11-24 15:51:34 -050024#include "ndn-cxx/security/transform/private-key.hpp"
25#include "ndn-cxx/security/transform/public-key.hpp"
26#include "ndn-cxx/security/transform/signer-filter.hpp"
27#include "ndn-cxx/security/transform/step-source.hpp"
28#include "ndn-cxx/security/transform/stream-sink.hpp"
29#include "ndn-cxx/security/verification-helpers.hpp"
30#include "ndn-cxx/util/sha256.hpp"
Davide Pesavento14c56cd2020-05-21 01:44:03 -040031#include "ndn-cxx/util/string-helper.hpp"
Alexander Afanasyev5fa9e9a2013-12-24 19:45:07 -080032
Davide Pesavento7e780642018-11-24 15:51:34 -050033#include "tests/boost-test.hpp"
Davide Pesavento4c1ad4c2020-11-16 21:12:02 -050034#include "tests/key-chain-fixture.hpp"
Davide Pesavento14c56cd2020-05-21 01:44:03 -040035
Junxiao Shi81206d52017-07-23 12:43:22 +000036#include <boost/lexical_cast.hpp>
Alexander Afanasyevb1db7c62014-04-03 14:57:25 -070037
Alexander Afanasyev0abb2da2014-01-30 18:07:57 -080038namespace ndn {
Spyridon Mastorakis429634f2015-02-19 17:35:33 -080039namespace tests {
Alexander Afanasyev5fa9e9a2013-12-24 19:45:07 -080040
41BOOST_AUTO_TEST_SUITE(TestData)
42
Junxiao Shi81206d52017-07-23 12:43:22 +000043const uint8_t CONTENT1[] = {0x53, 0x55, 0x43, 0x43, 0x45, 0x53, 0x53, 0x21};
Alexander Afanasyev5fa9e9a2013-12-24 19:45:07 -080044
Junxiao Shi81206d52017-07-23 12:43:22 +000045const uint8_t DATA1[] = {
Davide Pesavento14c56cd2020-05-21 01:44:03 -040046 0x06, 0xc5, // Data
Alexander Afanasyevb1db7c62014-04-03 14:57:25 -070047 0x07, 0x14, // Name
Davide Pesavento14c56cd2020-05-21 01:44:03 -040048 0x08, 0x05,
49 0x6c, 0x6f, 0x63, 0x61, 0x6c,
50 0x08, 0x03,
51 0x6e, 0x64, 0x6e,
52 0x08, 0x06,
53 0x70, 0x72, 0x65, 0x66, 0x69, 0x78,
Alexander Afanasyev4b456282014-02-13 00:34:34 -080054 0x14, 0x04, // MetaInfo
Davide Pesavento14c56cd2020-05-21 01:44:03 -040055 0x19, 0x02, // FreshnessPeriod
56 0x27, 0x10,
Alexander Afanasyevb1db7c62014-04-03 14:57:25 -070057 0x15, 0x08, // Content
Davide Pesavento14c56cd2020-05-21 01:44:03 -040058 0x53, 0x55, 0x43, 0x43, 0x45, 0x53, 0x53, 0x21,
Alexander Afanasyev4b456282014-02-13 00:34:34 -080059 0x16, 0x1b, // SignatureInfo
Davide Pesavento14c56cd2020-05-21 01:44:03 -040060 0x1b, 0x01, // SignatureType
61 0x01,
62 0x1c, 0x16, // KeyLocator
63 0x07, 0x14, // Name
64 0x08, 0x04,
65 0x74, 0x65, 0x73, 0x74,
66 0x08, 0x03,
67 0x6b, 0x65, 0x79,
68 0x08, 0x07,
69 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72,
Alexander Afanasyev4b456282014-02-13 00:34:34 -080070 0x17, 0x80, // SignatureValue
Davide Pesavento14c56cd2020-05-21 01:44:03 -040071 0x2f, 0xd6, 0xf1, 0x6e, 0x80, 0x6f, 0x10, 0xbe, 0xb1, 0x6f, 0x3e, 0x31,
72 0xec, 0xe3, 0xb9, 0xea, 0x83, 0x30, 0x40, 0x03, 0xfc, 0xa0, 0x13, 0xd9,
73 0xb3, 0xc6, 0x25, 0x16, 0x2d, 0xa6, 0x58, 0x41, 0x69, 0x62, 0x56, 0xd8,
74 0xb3, 0x6a, 0x38, 0x76, 0x56, 0xea, 0x61, 0xb2, 0x32, 0x70, 0x1c, 0xb6,
75 0x4d, 0x10, 0x1d, 0xdc, 0x92, 0x8e, 0x52, 0xa5, 0x8a, 0x1d, 0xd9, 0x96,
76 0x5e, 0xc0, 0x62, 0x0b, 0xcf, 0x3a, 0x9d, 0x7f, 0xca, 0xbe, 0xa1, 0x41,
77 0x71, 0x85, 0x7a, 0x8b, 0x5d, 0xa9, 0x64, 0xd6, 0x66, 0xb4, 0xe9, 0x8d,
78 0x0c, 0x28, 0x43, 0xee, 0xa6, 0x64, 0xe8, 0x55, 0xf6, 0x1c, 0x19, 0x0b,
79 0xef, 0x99, 0x25, 0x1e, 0xdc, 0x78, 0xb3, 0xa7, 0xaa, 0x0d, 0x14, 0x58,
80 0x30, 0xe5, 0x37, 0x6a, 0x6d, 0xdb, 0x56, 0xac, 0xa3, 0xfc, 0x90, 0x7a,
81 0xb8, 0x66, 0x9c, 0x0e, 0xf6, 0xb7, 0x64, 0xd1,
Alexander Afanasyev5fa9e9a2013-12-24 19:45:07 -080082};
83
Junxiao Shi81206d52017-07-23 12:43:22 +000084BOOST_AUTO_TEST_CASE(DefaultConstructor)
85{
86 Data d;
87 BOOST_CHECK_EQUAL(d.hasWire(), false);
88 BOOST_CHECK_EQUAL(d.getName(), "/");
89 BOOST_CHECK_EQUAL(d.getContentType(), tlv::ContentType_Blob);
90 BOOST_CHECK_EQUAL(d.getFreshnessPeriod(), DEFAULT_FRESHNESS_PERIOD);
Junxiao Shi7d9039b2018-04-14 15:56:28 +000091 BOOST_CHECK(!d.getFinalBlock());
Davide Pesavento81bd6962020-06-17 16:03:23 -040092 BOOST_CHECK_EQUAL(d.hasContent(), false);
93 BOOST_CHECK_EQUAL(d.getContent().isValid(), false);
Junxiao Shi81206d52017-07-23 12:43:22 +000094 BOOST_CHECK_EQUAL(d.getContent().value_size(), 0);
Eric Newberrya3c8bd12020-05-15 17:27:07 -070095 BOOST_CHECK(!d.getSignatureInfo());
Davide Pesavento14c56cd2020-05-21 01:44:03 -040096 BOOST_CHECK_EQUAL(d.getSignatureType(), -1);
97 BOOST_CHECK(!d.getKeyLocator());
98 BOOST_CHECK_EQUAL(d.getSignatureValue().isValid(), false);
Junxiao Shi81206d52017-07-23 12:43:22 +000099}
100
101class DataSigningKeyFixture
102{
103protected:
104 DataSigningKeyFixture()
105 {
Davide Pesavento765abc92021-12-27 00:44:04 -0500106 m_privKey.loadPkcs1(PRIVATE_KEY_DER);
Junxiao Shi81206d52017-07-23 12:43:22 +0000107 auto buf = m_privKey.derivePublicKey();
Davide Pesavento765abc92021-12-27 00:44:04 -0500108 m_pubKey.loadPkcs8(*buf);
Junxiao Shi81206d52017-07-23 12:43:22 +0000109 }
110
111protected:
112 security::transform::PrivateKey m_privKey;
113 security::transform::PublicKey m_pubKey;
114
115private:
116 static const uint8_t PRIVATE_KEY_DER[632];
Alexander Afanasyev5fa9e9a2013-12-24 19:45:07 -0800117};
118
Junxiao Shi81206d52017-07-23 12:43:22 +0000119const uint8_t DataSigningKeyFixture::PRIVATE_KEY_DER[] = {
120 0x30, 0x82, 0x02, 0x74, 0x02, 0x01, 0x00, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7,
121 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x04, 0x82, 0x02, 0x5e, 0x30, 0x82, 0x02, 0x5a, 0x02, 0x01,
122 0x00, 0x02, 0x81, 0x81, 0x00, 0x9e, 0x06, 0x3e, 0x47, 0x85, 0xb2, 0x34, 0x37, 0xaa, 0x85, 0x47,
123 0xac, 0x03, 0x24, 0x83, 0xb5, 0x9c, 0xa8, 0x05, 0x3a, 0x24, 0x1e, 0xeb, 0x89, 0x01, 0xbb, 0xe9,
124 0x9b, 0xb2, 0xc3, 0x22, 0xac, 0x68, 0xe3, 0xf0, 0x6c, 0x02, 0xce, 0x68, 0xa6, 0xc4, 0xd0, 0xa7,
125 0x06, 0x90, 0x9c, 0xaa, 0x1b, 0x08, 0x1d, 0x8b, 0x43, 0x9a, 0x33, 0x67, 0x44, 0x6d, 0x21, 0xa3,
126 0x1b, 0x88, 0x9a, 0x97, 0x5e, 0x59, 0xc4, 0x15, 0x0b, 0xd9, 0x2c, 0xbd, 0x51, 0x07, 0x61, 0x82,
127 0xad, 0xc1, 0xb8, 0xd7, 0xbf, 0x9b, 0xcf, 0x7d, 0x24, 0xc2, 0x63, 0xf3, 0x97, 0x17, 0xeb, 0xfe,
128 0x62, 0x25, 0xba, 0x5b, 0x4d, 0x8a, 0xc2, 0x7a, 0xbd, 0x43, 0x8a, 0x8f, 0xb8, 0xf2, 0xf1, 0xc5,
129 0x6a, 0x30, 0xd3, 0x50, 0x8c, 0xc8, 0x9a, 0xdf, 0xef, 0xed, 0x35, 0xe7, 0x7a, 0x62, 0xea, 0x76,
130 0x7c, 0xbb, 0x08, 0x26, 0xc7, 0x02, 0x01, 0x11, 0x02, 0x81, 0x80, 0x04, 0xa5, 0xd4, 0xa7, 0xc0,
131 0x2a, 0xe3, 0x6b, 0x0c, 0x8b, 0x73, 0x0c, 0x96, 0xae, 0x40, 0x1b, 0xee, 0x04, 0xf1, 0x18, 0x4c,
132 0x5b, 0x43, 0x29, 0xad, 0x3a, 0x3b, 0x93, 0xa3, 0x60, 0x17, 0x9b, 0xa8, 0xbb, 0x68, 0xf4, 0x1e,
133 0x33, 0x3f, 0x50, 0x32, 0xf7, 0x13, 0xf8, 0xa9, 0xe6, 0x7d, 0x79, 0x44, 0x00, 0xde, 0x72, 0xed,
134 0xf2, 0x73, 0xfa, 0x7b, 0xae, 0x2a, 0x71, 0xc0, 0x40, 0xc8, 0x37, 0x6f, 0x38, 0xb2, 0x69, 0x1f,
135 0xa8, 0x83, 0x7b, 0x42, 0x00, 0x73, 0x46, 0xe6, 0x4c, 0x91, 0x7f, 0x13, 0x06, 0x69, 0x06, 0xd8,
136 0x3f, 0x22, 0x15, 0x75, 0xf6, 0xde, 0xcd, 0xb0, 0xbc, 0x66, 0x61, 0x91, 0x08, 0x9b, 0x2b, 0xb2,
137 0x00, 0xa9, 0x67, 0x05, 0x39, 0x40, 0xb9, 0x37, 0x85, 0x88, 0x4f, 0x76, 0x79, 0x63, 0xc0, 0x88,
138 0x3c, 0x86, 0xa8, 0x12, 0x94, 0x5f, 0xe4, 0x36, 0x3d, 0xea, 0xb9, 0x02, 0x41, 0x00, 0xb6, 0x2e,
139 0xbb, 0xcd, 0x2f, 0x3a, 0x99, 0xe0, 0xa1, 0xa5, 0x44, 0x77, 0xea, 0x0b, 0xbe, 0x16, 0x95, 0x0e,
140 0x64, 0xa7, 0x68, 0xd7, 0x4b, 0x15, 0x15, 0x23, 0xe2, 0x1e, 0x4e, 0x00, 0x2c, 0x22, 0x97, 0xae,
141 0xb0, 0x74, 0xa6, 0x99, 0xd0, 0x5d, 0xb7, 0x1b, 0x10, 0x34, 0x13, 0xd2, 0x5f, 0x6e, 0x56, 0xad,
142 0x85, 0x4a, 0xdb, 0xf0, 0x78, 0xbd, 0xf4, 0x8c, 0xb7, 0x9a, 0x3e, 0x99, 0xef, 0xb9, 0x02, 0x41,
143 0x00, 0xde, 0x0d, 0xa7, 0x48, 0x75, 0x90, 0xad, 0x11, 0xa1, 0xac, 0xee, 0xcb, 0x41, 0x81, 0xc6,
144 0xc8, 0x7f, 0xe7, 0x25, 0x94, 0xa1, 0x2a, 0x21, 0xa8, 0x57, 0xfe, 0x84, 0xf2, 0x5e, 0xb4, 0x96,
145 0x35, 0xaf, 0xef, 0x2e, 0x7a, 0xf8, 0xda, 0x3f, 0xac, 0x8a, 0x3c, 0x1c, 0x9c, 0xbd, 0x44, 0xd6,
146 0x90, 0xb5, 0xce, 0x1b, 0x12, 0xf9, 0x3b, 0x8c, 0x69, 0xf6, 0xa9, 0x02, 0x93, 0x48, 0x35, 0x0a,
147 0x7f, 0x02, 0x40, 0x6b, 0x2a, 0x8c, 0x96, 0xd0, 0x7c, 0xd2, 0xfc, 0x9b, 0x52, 0x28, 0x46, 0x89,
148 0xac, 0x8d, 0xef, 0x2a, 0x80, 0xef, 0xea, 0x01, 0x6f, 0x95, 0x93, 0xee, 0x51, 0x57, 0xd5, 0x97,
149 0x4b, 0x65, 0x41, 0x86, 0x66, 0xc2, 0x26, 0x80, 0x1e, 0x3e, 0x55, 0x3e, 0x88, 0x63, 0xe2, 0x66,
150 0x03, 0x47, 0x31, 0xd8, 0xa2, 0x4e, 0x68, 0x45, 0x24, 0x0a, 0xca, 0x17, 0x61, 0xd5, 0x69, 0xca,
151 0x78, 0xab, 0x21, 0x02, 0x41, 0x00, 0x8f, 0xae, 0x7b, 0x4d, 0x00, 0xc7, 0x06, 0x92, 0xf0, 0x24,
152 0x9a, 0x83, 0x84, 0xbd, 0x62, 0x81, 0xbc, 0x2c, 0x27, 0x60, 0x2c, 0x0c, 0x33, 0xe5, 0x66, 0x1d,
153 0x28, 0xd9, 0x10, 0x1a, 0x7f, 0x4f, 0xea, 0x4f, 0x78, 0x6d, 0xb0, 0x14, 0xbf, 0xc9, 0xff, 0x17,
154 0xd6, 0x47, 0x4d, 0x4a, 0xa8, 0xf4, 0x39, 0x67, 0x3e, 0xb1, 0xec, 0x8f, 0xf1, 0x71, 0xbd, 0xb8,
155 0xa7, 0x50, 0x3d, 0xc7, 0xf7, 0xbb, 0x02, 0x40, 0x0d, 0x85, 0x32, 0x73, 0x9f, 0x0a, 0x33, 0x2f,
156 0x4b, 0xa2, 0xbd, 0xd1, 0xb1, 0x42, 0xf0, 0x72, 0xa8, 0x7a, 0xc8, 0x15, 0x37, 0x1b, 0xde, 0x76,
157 0x70, 0xce, 0xfd, 0x69, 0x20, 0x00, 0x4d, 0xc9, 0x4f, 0x35, 0x6f, 0xd1, 0x35, 0xa1, 0x04, 0x95,
158 0x30, 0xe8, 0x3b, 0xd5, 0x03, 0x5a, 0x50, 0x21, 0x6d, 0xa0, 0x84, 0x39, 0xe9, 0x2e, 0x1e, 0xfc,
159 0xe4, 0x82, 0x43, 0x20, 0x46, 0x7d, 0x0a, 0xb6
160};
161
Davide Pesavento905d40f2020-06-09 21:33:25 -0400162BOOST_AUTO_TEST_SUITE(Encode)
163
164BOOST_AUTO_TEST_CASE(NotSigned)
Junxiao Shi81206d52017-07-23 12:43:22 +0000165{
Davide Pesavento905d40f2020-06-09 21:33:25 -0400166 Data d;
167 BOOST_CHECK_EXCEPTION(d.wireEncode(), tlv::Error, [] (const auto& e) {
168 return e.what() == "Requested wire format, but Data has not been signed"s;
169 });
170}
171
172BOOST_AUTO_TEST_CASE(Minimal)
173{
174 Data d;
175 d.setSignatureInfo(SignatureInfo(tlv::DigestSha256));
176 d.setSignatureValue(std::make_shared<Buffer>());
Davide Pesavento81bd6962020-06-17 16:03:23 -0400177 BOOST_CHECK_EQUAL(d.wireEncode(), "060B 0700 1400 16031B0100 1700"_block);
Davide Pesavento905d40f2020-06-09 21:33:25 -0400178}
179
180BOOST_FIXTURE_TEST_CASE(Full, DataSigningKeyFixture)
181{
182 Data d("/local/ndn/prefix");
Junxiao Shi81206d52017-07-23 12:43:22 +0000183 d.setContentType(tlv::ContentType_Blob);
Davide Pesavento0f830802018-01-16 23:58:58 -0500184 d.setFreshnessPeriod(10_s);
Junxiao Shi81206d52017-07-23 12:43:22 +0000185 d.setContent(CONTENT1, sizeof(CONTENT1));
186
Davide Pesavento14c56cd2020-05-21 01:44:03 -0400187 SignatureInfo signatureInfo;
188 signatureInfo.setSignatureType(tlv::SignatureSha256WithRsa);
189 signatureInfo.setKeyLocator(Name("/test/key/locator"));
190 d.setSignatureInfo(signatureInfo);
Junxiao Shi81206d52017-07-23 12:43:22 +0000191
192 OBufferStream sig;
193 {
194 namespace tr = security::transform;
195
196 tr::StepSource input;
197 input >> tr::signerFilter(DigestAlgorithm::SHA256, m_privKey) >> tr::streamSink(sig);
198
Davide Pesavento765abc92021-12-27 00:44:04 -0500199 input.write({d.getName(). wireEncode().wire(), d.getName(). wireEncode().size()});
200 input.write({d.getMetaInfo().wireEncode().wire(), d.getMetaInfo().wireEncode().size()});
201 input.write({d.getContent(). wire(), d.getContent(). size()});
202 input.write({signatureInfo. wireEncode().wire(), signatureInfo. wireEncode().size()});
Junxiao Shi81206d52017-07-23 12:43:22 +0000203 input.end();
204 }
Davide Pesavento14c56cd2020-05-21 01:44:03 -0400205 d.setSignatureValue(sig.buf());
Junxiao Shi81206d52017-07-23 12:43:22 +0000206
207 Block dataBlock(d.wireEncode());
208 BOOST_CHECK_EQUAL_COLLECTIONS(DATA1, DATA1 + sizeof(DATA1),
209 dataBlock.begin(), dataBlock.end());
210}
211
Davide Pesavento905d40f2020-06-09 21:33:25 -0400212BOOST_AUTO_TEST_SUITE_END() // Encode
Junxiao Shi81206d52017-07-23 12:43:22 +0000213
Davide Pesavento905d40f2020-06-09 21:33:25 -0400214class DecodeFixture
Junxiao Shi7d9039b2018-04-14 15:56:28 +0000215{
216protected:
Davide Pesavento905d40f2020-06-09 21:33:25 -0400217 DecodeFixture()
Junxiao Shi7d9039b2018-04-14 15:56:28 +0000218 {
219 // initialize all elements to non-empty, to verify wireDecode clears them
220 d.setName("/A");
221 d.setContentType(tlv::ContentType_Key);
Davide Pesavento905d40f2020-06-09 21:33:25 -0400222 d.setFreshnessPeriod(123_s);
223 d.setFinalBlock(name::Component::fromNumber(42));
Junxiao Shi7d9039b2018-04-14 15:56:28 +0000224 d.setContent("1504C0C1C2C3"_block);
Eric Newberrya3c8bd12020-05-15 17:27:07 -0700225 d.setSignatureInfo(SignatureInfo("160A 1B0101 1C050703080142"_block));
Davide Pesavento14c56cd2020-05-21 01:44:03 -0400226 d.setSignatureValue(fromHex("B48F1707A3BCA3CFC5F32DE51D9B46C32D7D262A21544EBDA88C3B415D637503"
227 "FC9BEF20F88202A56AF9831E0D30205FD4154B08502BCDEE860267A5C3E03D8E"
228 "A6CB74BE391C01E0A57B991B4404FC11B7D777F1B700A4B65F201118CF1840A8"
229 "30A2A7C17DB4B7A8777E58515121AF9E2498627F8475414CDFD9801B8152AD5B"));
Junxiao Shi7d9039b2018-04-14 15:56:28 +0000230 }
231
232protected:
233 Data d;
234};
235
Davide Pesavento905d40f2020-06-09 21:33:25 -0400236BOOST_FIXTURE_TEST_SUITE(Decode, DecodeFixture)
237
238BOOST_AUTO_TEST_CASE(NotData)
239{
240 BOOST_CHECK_EXCEPTION(d.wireDecode("4202CAFE"_block), tlv::Error, [] (const auto& e) {
241 return e.what() == "Expecting Data element, but TLV has type 66"s;
242 });
243}
Junxiao Shi7d9039b2018-04-14 15:56:28 +0000244
Junxiao Shi7d9039b2018-04-14 15:56:28 +0000245BOOST_AUTO_TEST_CASE(Minimal)
246{
Davide Pesavento905d40f2020-06-09 21:33:25 -0400247 d.wireDecode("062C 0703(080144) 1603(1B0100) "
Junxiao Shi7d9039b2018-04-14 15:56:28 +0000248 "1720612A79399E60304A9F701C1ECAC7956BF2F1B046E6C6F0D6C29B3FE3A29BAD76"_block);
249 BOOST_CHECK_EQUAL(d.getName(), "/D");
Davide Pesaventoef654dd2019-07-18 20:02:44 -0400250 BOOST_CHECK_EQUAL(d.getContentType(), tlv::ContentType_Blob);
251 BOOST_CHECK_EQUAL(d.getFreshnessPeriod(), 0_ms);
252 BOOST_CHECK_EQUAL(d.getFinalBlock().has_value(), false);
Davide Pesavento81bd6962020-06-17 16:03:23 -0400253 BOOST_CHECK_EQUAL(d.hasContent(), false);
Junxiao Shi7d9039b2018-04-14 15:56:28 +0000254 BOOST_CHECK_EQUAL(d.getContent().value_size(), 0);
Davide Pesavento14c56cd2020-05-21 01:44:03 -0400255 BOOST_CHECK_EQUAL(d.getSignatureType(), tlv::DigestSha256);
256 BOOST_CHECK_EQUAL(d.getKeyLocator().has_value(), false);
Eric Newberrya3c8bd12020-05-15 17:27:07 -0700257 BOOST_CHECK_EQUAL(d.getSignatureValue().value_size(), 32);
Junxiao Shi7d9039b2018-04-14 15:56:28 +0000258
259 // encode without modification: retain original wire encoding
Davide Pesavento905d40f2020-06-09 21:33:25 -0400260 BOOST_CHECK_EQUAL(d.hasWire(), true);
Junxiao Shi7d9039b2018-04-14 15:56:28 +0000261 BOOST_CHECK_EQUAL(d.wireEncode().value_size(), 44);
262
Davide Pesavento905d40f2020-06-09 21:33:25 -0400263 // modify then re-encode
Junxiao Shi7d9039b2018-04-14 15:56:28 +0000264 d.setName("/E");
Davide Pesavento905d40f2020-06-09 21:33:25 -0400265 BOOST_CHECK_EQUAL(d.hasWire(), false);
Junxiao Shi72c0c642018-04-20 15:41:09 +0000266 BOOST_CHECK_EQUAL(d.wireEncode(),
Davide Pesavento81bd6962020-06-17 16:03:23 -0400267 "062E 0703(080145) 1400 1603(1B0100) "
Davide Pesavento905d40f2020-06-09 21:33:25 -0400268 "1720612A79399E60304A9F701C1ECAC7956BF2F1B046E6C6F0D6C29B3FE3A29BAD76"_block);
Junxiao Shi7d9039b2018-04-14 15:56:28 +0000269}
270
Eric Newberrya3c8bd12020-05-15 17:27:07 -0700271BOOST_AUTO_TEST_CASE(MinimalEmptyName)
272{
Davide Pesavento905d40f2020-06-09 21:33:25 -0400273 d.wireDecode("0609 0700 1603(1B0100) 1700"_block);
Eric Newberrya3c8bd12020-05-15 17:27:07 -0700274 BOOST_CHECK_EQUAL(d.getName(), "/"); // empty Name is allowed in Data
275 BOOST_CHECK_EQUAL(d.getContentType(), tlv::ContentType_Blob);
276 BOOST_CHECK_EQUAL(d.getFreshnessPeriod(), 0_ms);
277 BOOST_CHECK_EQUAL(d.getFinalBlock().has_value(), false);
Davide Pesavento81bd6962020-06-17 16:03:23 -0400278 BOOST_CHECK_EQUAL(d.hasContent(), false);
Eric Newberrya3c8bd12020-05-15 17:27:07 -0700279 BOOST_CHECK_EQUAL(d.getContent().value_size(), 0);
Davide Pesavento14c56cd2020-05-21 01:44:03 -0400280 BOOST_CHECK_EQUAL(d.getSignatureType(), tlv::DigestSha256);
281 BOOST_CHECK_EQUAL(d.getKeyLocator().has_value(), false);
Eric Newberrya3c8bd12020-05-15 17:27:07 -0700282 BOOST_CHECK_EQUAL(d.getSignatureValue().value_size(), 0);
283}
284
Junxiao Shi7d9039b2018-04-14 15:56:28 +0000285BOOST_AUTO_TEST_CASE(Full)
286{
Davide Pesavento905d40f2020-06-09 21:33:25 -0400287 d.wireDecode(Block(DATA1, sizeof(DATA1)));
288 BOOST_CHECK_EQUAL(d.getName(), "/local/ndn/prefix");
289 BOOST_CHECK_EQUAL(d.getContentType(), tlv::ContentType_Blob);
290 BOOST_CHECK_EQUAL(d.getFreshnessPeriod(), 10_s);
291 BOOST_CHECK_EQUAL(d.getFinalBlock().has_value(), false);
Davide Pesavento81bd6962020-06-17 16:03:23 -0400292 BOOST_CHECK_EQUAL(d.hasContent(), true);
Davide Pesavento905d40f2020-06-09 21:33:25 -0400293 BOOST_CHECK_EQUAL(std::string(reinterpret_cast<const char*>(d.getContent().value()),
294 d.getContent().value_size()), "SUCCESS!");
295 BOOST_CHECK_EQUAL(d.getSignatureType(), tlv::SignatureSha256WithRsa);
296 BOOST_REQUIRE(d.getKeyLocator().has_value());
297 BOOST_CHECK_EQUAL(d.getKeyLocator()->getName(), "/test/key/locator");
298 BOOST_CHECK_EQUAL(d.getSignatureValue().value_size(), 128);
299}
300
301BOOST_AUTO_TEST_CASE(UnrecognizedNonCriticalElements)
302{
303 d.wireDecode("063A 0703(080144) FC00 1400 FC00 1500 FC00 1603(1B0100) FC00 "
Junxiao Shi7d9039b2018-04-14 15:56:28 +0000304 "1720612A79399E60304A9F701C1ECAC7956BF2F1B046E6C6F0D6C29B3FE3A29BAD76 FC00"_block);
305 BOOST_CHECK_EQUAL(d.getName(), "/D");
Davide Pesaventoef654dd2019-07-18 20:02:44 -0400306 BOOST_CHECK_EQUAL(d.getContentType(), tlv::ContentType_Blob);
307 BOOST_CHECK_EQUAL(d.getFreshnessPeriod(), 0_ms);
308 BOOST_CHECK_EQUAL(d.getFinalBlock().has_value(), false);
Davide Pesavento81bd6962020-06-17 16:03:23 -0400309 BOOST_CHECK_EQUAL(d.hasContent(), true);
Junxiao Shi7d9039b2018-04-14 15:56:28 +0000310 BOOST_CHECK_EQUAL(d.getContent().value_size(), 0);
Davide Pesavento14c56cd2020-05-21 01:44:03 -0400311 BOOST_CHECK_EQUAL(d.getSignatureType(), tlv::DigestSha256);
312 BOOST_CHECK_EQUAL(d.getKeyLocator().has_value(), false);
Eric Newberrya3c8bd12020-05-15 17:27:07 -0700313 BOOST_CHECK_EQUAL(d.getSignatureValue().value_size(), 32);
Junxiao Shi7d9039b2018-04-14 15:56:28 +0000314
315 // encode without modification: retain original wire encoding
Davide Pesavento905d40f2020-06-09 21:33:25 -0400316 BOOST_CHECK_EQUAL(d.hasWire(), true);
Junxiao Shi8b753a22018-10-24 01:51:40 +0000317 BOOST_CHECK_EQUAL(d.wireEncode().value_size(), 58);
Junxiao Shi7d9039b2018-04-14 15:56:28 +0000318
Davide Pesavento905d40f2020-06-09 21:33:25 -0400319 // modify then re-encode
Junxiao Shi7d9039b2018-04-14 15:56:28 +0000320 d.setName("/E");
Davide Pesavento905d40f2020-06-09 21:33:25 -0400321 BOOST_CHECK_EQUAL(d.hasWire(), false);
Junxiao Shi72c0c642018-04-20 15:41:09 +0000322 BOOST_CHECK_EQUAL(d.wireEncode(),
Davide Pesavento905d40f2020-06-09 21:33:25 -0400323 "0630 0703080145 1400 1500 16031B0100 "
324 "1720612A79399E60304A9F701C1ECAC7956BF2F1B046E6C6F0D6C29B3FE3A29BAD76"_block);
Junxiao Shi7d9039b2018-04-14 15:56:28 +0000325}
326
327BOOST_AUTO_TEST_CASE(CriticalElementOutOfOrder)
328{
Davide Pesavento905d40f2020-06-09 21:33:25 -0400329 BOOST_CHECK_EXCEPTION(d.wireDecode(
Junxiao Shi7d9039b2018-04-14 15:56:28 +0000330 "0630 1400 0703080145 1500 16031B0100 "
331 "1720612A79399E60304A9F701C1ECAC7956BF2F1B046E6C6F0D6C29B3FE3A29BAD76"_block),
Davide Pesavento905d40f2020-06-09 21:33:25 -0400332 tlv::Error,
333 [] (const auto& e) { return e.what() == "Name element is missing or out of order"s; });
334 BOOST_CHECK_EXCEPTION(d.wireDecode(
Junxiao Shi7d9039b2018-04-14 15:56:28 +0000335 "0630 0703080145 1500 1400 16031B0100 "
336 "1720612A79399E60304A9F701C1ECAC7956BF2F1B046E6C6F0D6C29B3FE3A29BAD76"_block),
Davide Pesavento905d40f2020-06-09 21:33:25 -0400337 tlv::Error,
338 [] (const auto& e) { return e.what() == "MetaInfo element is out of order"s; });
339 BOOST_CHECK_EXCEPTION(d.wireDecode(
Junxiao Shi7d9039b2018-04-14 15:56:28 +0000340 "0630 0703080145 1400 16031B0100 1500 "
341 "1720612A79399E60304A9F701C1ECAC7956BF2F1B046E6C6F0D6C29B3FE3A29BAD76"_block),
Davide Pesavento905d40f2020-06-09 21:33:25 -0400342 tlv::Error,
343 [] (const auto& e) { return e.what() == "Content element is out of order"s; });
344 BOOST_CHECK_EXCEPTION(d.wireDecode(
Junxiao Shi7d9039b2018-04-14 15:56:28 +0000345 "0630 0703080145 1400 1500 "
346 "1720612A79399E60304A9F701C1ECAC7956BF2F1B046E6C6F0D6C29B3FE3A29BAD76 16031B0100"_block),
Davide Pesavento905d40f2020-06-09 21:33:25 -0400347 tlv::Error,
348 [] (const auto& e) { return e.what() == "SignatureInfo element is out of order"s; });
349 BOOST_CHECK_EXCEPTION(d.wireDecode(
Junxiao Shi7d9039b2018-04-14 15:56:28 +0000350 "0652 0703080145 1400 1500 16031B0100 "
351 "1720612A79399E60304A9F701C1ECAC7956BF2F1B046E6C6F0D6C29B3FE3A29BAD76"
352 "1720612A79399E60304A9F701C1ECAC7956BF2F1B046E6C6F0D6C29B3FE3A29BAD76"_block),
Davide Pesavento905d40f2020-06-09 21:33:25 -0400353 tlv::Error,
354 [] (const auto& e) { return e.what() == "SignatureValue element is out of order"s; });
Junxiao Shi7d9039b2018-04-14 15:56:28 +0000355}
356
Davide Pesavento905d40f2020-06-09 21:33:25 -0400357BOOST_AUTO_TEST_CASE(MissingName)
Junxiao Shi7d9039b2018-04-14 15:56:28 +0000358{
Davide Pesavento905d40f2020-06-09 21:33:25 -0400359 BOOST_CHECK_EXCEPTION(d.wireDecode("0607 16031B0100 1700"_block), tlv::Error,
360 [] (const auto& e) { return e.what() == "Name element is missing or out of order"s; });
Junxiao Shi7d9039b2018-04-14 15:56:28 +0000361}
362
Davide Pesavento905d40f2020-06-09 21:33:25 -0400363BOOST_AUTO_TEST_CASE(MissingSignatureInfo)
Junxiao Shi7d9039b2018-04-14 15:56:28 +0000364{
Davide Pesavento905d40f2020-06-09 21:33:25 -0400365 BOOST_CHECK_EXCEPTION(d.wireDecode("0607 0703080144 1700"_block), tlv::Error,
366 [] (const auto& e) { return e.what() == "SignatureInfo element is missing"s; });
Eric Newberrya3c8bd12020-05-15 17:27:07 -0700367}
368
Davide Pesavento905d40f2020-06-09 21:33:25 -0400369BOOST_AUTO_TEST_CASE(MissingSignatureValue)
Eric Newberrya3c8bd12020-05-15 17:27:07 -0700370{
Davide Pesavento905d40f2020-06-09 21:33:25 -0400371 BOOST_CHECK_EXCEPTION(d.wireDecode("0607 0700 16031B0100"_block), tlv::Error,
372 [] (const auto& e) { return e.what() == "SignatureValue element is missing"s; });
Junxiao Shi7d9039b2018-04-14 15:56:28 +0000373}
374
Junxiao Shi8b753a22018-10-24 01:51:40 +0000375BOOST_AUTO_TEST_CASE(UnrecognizedNonCriticalElementBeforeName)
376{
Davide Pesavento905d40f2020-06-09 21:33:25 -0400377 BOOST_CHECK_EXCEPTION(d.wireDecode(
378 "062E FC00 0703080144 16031B0100 "
379 "1720612A79399E60304A9F701C1ECAC7956BF2F1B046E6C6F0D6C29B3FE3A29BAD76"_block),
380 tlv::Error,
381 [] (const auto& e) { return e.what() == "Name element is missing or out of order"s; });
Junxiao Shi8b753a22018-10-24 01:51:40 +0000382}
383
Junxiao Shi7d9039b2018-04-14 15:56:28 +0000384BOOST_AUTO_TEST_CASE(UnrecognizedCriticalElement)
385{
Davide Pesavento905d40f2020-06-09 21:33:25 -0400386 BOOST_CHECK_EXCEPTION(d.wireDecode(
387 "0632 0703080145 FB00 1400 1500 16031B0100 "
388 "1720612A79399E60304A9F701C1ECAC7956BF2F1B046E6C6F0D6C29B3FE3A29BAD76"_block),
389 tlv::Error,
390 [] (const auto& e) { return e.what() == "Unrecognized element of critical type 251"s; });
Junxiao Shi7d9039b2018-04-14 15:56:28 +0000391}
392
Davide Pesavento905d40f2020-06-09 21:33:25 -0400393BOOST_AUTO_TEST_SUITE_END() // Decode
Junxiao Shi7d9039b2018-04-14 15:56:28 +0000394
Davide Pesavento4c1ad4c2020-11-16 21:12:02 -0500395BOOST_FIXTURE_TEST_CASE(FullName, KeyChainFixture)
Junxiao Shi81206d52017-07-23 12:43:22 +0000396{
397 Data d(Name("/local/ndn/prefix"));
398 d.setContentType(tlv::ContentType_Blob);
Davide Pesavento0f830802018-01-16 23:58:58 -0500399 d.setFreshnessPeriod(10_s);
Junxiao Shi81206d52017-07-23 12:43:22 +0000400 d.setContent(CONTENT1, sizeof(CONTENT1));
401 BOOST_CHECK_THROW(d.getFullName(), Data::Error); // FullName is unavailable without signing
402
403 m_keyChain.sign(d);
404 BOOST_CHECK_EQUAL(d.hasWire(), true);
405 Name fullName = d.getFullName(); // FullName is available after signing
406
407 BOOST_CHECK_EQUAL(d.getName().size() + 1, fullName.size());
408 BOOST_CHECK_EQUAL_COLLECTIONS(d.getName().begin(), d.getName().end(),
409 fullName.begin(), fullName.end() - 1);
410 BOOST_CHECK_EQUAL(fullName.get(-1).value_size(), util::Sha256::DIGEST_SIZE);
411
412 // FullName should be cached, so value() pointer points to same memory location
413 BOOST_CHECK_EQUAL(fullName.get(-1).value(), d.getFullName().get(-1).value());
414
Davide Pesavento0f830802018-01-16 23:58:58 -0500415 d.setFreshnessPeriod(100_s); // invalidates FullName
Junxiao Shi81206d52017-07-23 12:43:22 +0000416 BOOST_CHECK_THROW(d.getFullName(), Data::Error);
417
418 Data d1(Block(DATA1, sizeof(DATA1)));
419 BOOST_CHECK_EQUAL(d1.getFullName(),
420 "/local/ndn/prefix/"
421 "sha256digest=28bad4b5275bd392dbb670c75cf0b66f13f7942b21e80f55c0e86b374753a548");
422}
423
Davide Pesavento905d40f2020-06-09 21:33:25 -0400424BOOST_AUTO_TEST_CASE(SetName)
425{
426 Data d;
427 d.setName("/first");
428 BOOST_CHECK_EQUAL(d.getName(), "/first");
429 BOOST_CHECK_EQUAL(d.hasWire(), false);
430
431 d.setSignatureInfo(SignatureInfo(tlv::DigestSha256));
432 d.setSignatureValue(std::make_shared<Buffer>());
433 d.wireEncode();
434 BOOST_CHECK_EQUAL(d.hasWire(), true);
435 d.setName("/first");
436 BOOST_CHECK_EQUAL(d.getName(), "/first");
437 BOOST_CHECK_EQUAL(d.hasWire(), true);
438
439 d.setName("/second");
440 BOOST_CHECK_EQUAL(d.getName(), "/second");
441 BOOST_CHECK_EQUAL(d.hasWire(), false);
442}
443
444BOOST_AUTO_TEST_CASE(SetContentType)
445{
446 Data d;
447 d.setContentType(tlv::ContentType_Key);
448 BOOST_CHECK_EQUAL(d.getContentType(), tlv::ContentType_Key);
449 BOOST_CHECK_EQUAL(d.hasWire(), false);
450
451 d.setSignatureInfo(SignatureInfo(tlv::DigestSha256));
452 d.setSignatureValue(std::make_shared<Buffer>());
453 d.wireEncode();
454 BOOST_CHECK_EQUAL(d.hasWire(), true);
455 d.setContentType(tlv::ContentType_Key);
456 BOOST_CHECK_EQUAL(d.getContentType(), tlv::ContentType_Key);
457 BOOST_CHECK_EQUAL(d.hasWire(), true);
458
459 d.setContentType(tlv::ContentType_PrefixAnn);
460 BOOST_CHECK_EQUAL(d.getContentType(), tlv::ContentType_PrefixAnn);
461 BOOST_CHECK_EQUAL(d.hasWire(), false);
462}
463
464BOOST_AUTO_TEST_CASE(SetFreshnessPeriod)
465{
466 Data d;
467 d.setFreshnessPeriod(15_min);
468 BOOST_CHECK_EQUAL(d.getFreshnessPeriod(), 15_min);
469 BOOST_CHECK_EQUAL(d.hasWire(), false);
470
471 d.setSignatureInfo(SignatureInfo(tlv::DigestSha256));
472 d.setSignatureValue(std::make_shared<Buffer>());
473 d.wireEncode();
474 BOOST_CHECK_EQUAL(d.hasWire(), true);
475 d.setFreshnessPeriod(15_min);
476 BOOST_CHECK_EQUAL(d.getFreshnessPeriod(), 15_min);
477 BOOST_CHECK_EQUAL(d.hasWire(), true);
478
479 d.setFreshnessPeriod(1_h);
480 BOOST_CHECK_EQUAL(d.getFreshnessPeriod(), 1_h);
481 BOOST_CHECK_EQUAL(d.hasWire(), false);
482}
483
484BOOST_AUTO_TEST_CASE(SetFinalBlock)
485{
486 Data d;
487 d.setFinalBlock(name::Component("foo"));
488 BOOST_CHECK(d.getFinalBlock() == name::Component("foo"));
489 BOOST_CHECK_EQUAL(d.hasWire(), false);
490
491 d.setSignatureInfo(SignatureInfo(tlv::DigestSha256));
492 d.setSignatureValue(std::make_shared<Buffer>());
493 d.wireEncode();
494 BOOST_CHECK_EQUAL(d.hasWire(), true);
495 d.setFinalBlock(name::Component("foo"));
496 BOOST_CHECK(d.getFinalBlock() == name::Component("foo"));
497 BOOST_CHECK_EQUAL(d.hasWire(), true);
498
499 d.setFinalBlock(name::Component("bar"));
500 BOOST_CHECK(d.getFinalBlock() == name::Component("bar"));
501 BOOST_CHECK_EQUAL(d.hasWire(), false);
502}
503
504BOOST_AUTO_TEST_CASE(SetContent)
Davide Pesavento14c56cd2020-05-21 01:44:03 -0400505{
506 Data d;
Davide Pesavento81bd6962020-06-17 16:03:23 -0400507 BOOST_CHECK_EQUAL(d.hasContent(), false);
508 BOOST_CHECK_EQUAL(d.getContent().type(), tlv::Invalid);
Davide Pesavento14c56cd2020-05-21 01:44:03 -0400509 BOOST_CHECK_EQUAL(d.getContent().value_size(), 0);
510
Davide Pesavento81bd6962020-06-17 16:03:23 -0400511 // Block overload, used directly as Content
Davide Pesavento14c56cd2020-05-21 01:44:03 -0400512 const uint8_t direct[] = {0xca, 0xfe};
Davide Pesavento81bd6962020-06-17 16:03:23 -0400513 d.setContent("1502CAFE"_block);
514 BOOST_CHECK_EQUAL(d.hasContent(), true);
Davide Pesavento14c56cd2020-05-21 01:44:03 -0400515 BOOST_CHECK_EQUAL(d.getContent().type(), tlv::Content);
516 BOOST_CHECK_EQUAL_COLLECTIONS(d.getContent().value_begin(), d.getContent().value_end(),
517 direct, direct + sizeof(direct));
518
Davide Pesavento81bd6962020-06-17 16:03:23 -0400519 // Block overload, nested inside Content element
Davide Pesavento14c56cd2020-05-21 01:44:03 -0400520 const uint8_t nested[] = {0x99, 0x02, 0xca, 0xfe};
Davide Pesavento81bd6962020-06-17 16:03:23 -0400521 d.setContent(Block(nested, sizeof(nested)));
522 BOOST_CHECK_EQUAL(d.hasContent(), true);
Davide Pesavento14c56cd2020-05-21 01:44:03 -0400523 BOOST_CHECK_EQUAL(d.getContent().type(), tlv::Content);
524 BOOST_CHECK_EQUAL_COLLECTIONS(d.getContent().value_begin(), d.getContent().value_end(),
525 nested, nested + sizeof(nested));
526
Davide Pesavento81bd6962020-06-17 16:03:23 -0400527 // Block overload, default constructed (invalid)
528 BOOST_CHECK_THROW(d.setContent(Block{}), std::invalid_argument);
529
530 // raw buffer overload
531 d.setContent(nested, sizeof(nested));
532 BOOST_CHECK_EQUAL(d.hasContent(), true);
Davide Pesavento14c56cd2020-05-21 01:44:03 -0400533 BOOST_CHECK_EQUAL(d.getContent().type(), tlv::Content);
534 BOOST_CHECK_EQUAL_COLLECTIONS(d.getContent().value_begin(), d.getContent().value_end(),
535 nested, nested + sizeof(nested));
Davide Pesavento81bd6962020-06-17 16:03:23 -0400536 d.setContent(nullptr, 0);
537 BOOST_CHECK_EQUAL(d.hasContent(), true);
Davide Pesavento14c56cd2020-05-21 01:44:03 -0400538 BOOST_CHECK_EQUAL(d.getContent().type(), tlv::Content);
539 BOOST_CHECK_EQUAL(d.getContent().value_size(), 0);
Davide Pesavento81bd6962020-06-17 16:03:23 -0400540 BOOST_CHECK_THROW(d.setContent(nullptr, 1), std::invalid_argument);
Davide Pesavento14c56cd2020-05-21 01:44:03 -0400541
Davide Pesavento81bd6962020-06-17 16:03:23 -0400542 // ConstBufferPtr overload
543 d.setContent(std::make_shared<Buffer>(direct, sizeof(direct)));
544 BOOST_CHECK_EQUAL(d.hasContent(), true);
545 BOOST_CHECK_EQUAL(d.getContent().type(), tlv::Content);
546 BOOST_CHECK_EQUAL_COLLECTIONS(d.getContent().value_begin(), d.getContent().value_end(),
547 direct, direct + sizeof(direct));
548 d.setContent(std::make_shared<Buffer>());
549 BOOST_CHECK_EQUAL(d.hasContent(), true);
550 BOOST_CHECK_EQUAL(d.getContent().type(), tlv::Content);
551 BOOST_CHECK_EQUAL(d.getContent().value_size(), 0);
Davide Pesavento14c56cd2020-05-21 01:44:03 -0400552 BOOST_CHECK_THROW(d.setContent(nullptr), std::invalid_argument);
Davide Pesavento81bd6962020-06-17 16:03:23 -0400553
554 // unset
555 d.unsetContent();
556 BOOST_CHECK_EQUAL(d.hasContent(), false);
557 BOOST_CHECK_EQUAL(d.getContent().type(), tlv::Invalid);
558 BOOST_CHECK_EQUAL(d.getContent().value_size(), 0);
Davide Pesavento14c56cd2020-05-21 01:44:03 -0400559}
560
Davide Pesavento905d40f2020-06-09 21:33:25 -0400561BOOST_AUTO_TEST_CASE(SetSignatureValue)
Davide Pesavento14c56cd2020-05-21 01:44:03 -0400562{
563 Data d;
564 BOOST_CHECK_EQUAL(d.getSignatureValue().type(), tlv::Invalid);
565
566 d.setSignatureValue(fromHex("FACADE"));
567 BOOST_CHECK_EQUAL(d.getSignatureValue().type(), tlv::SignatureValue);
568 BOOST_CHECK_EQUAL(d.getSignatureValue().value_size(), 3);
569
570 d.setSignatureValue(std::make_shared<Buffer>()); // empty buffer
571 BOOST_CHECK_EQUAL(d.getSignatureValue().type(), tlv::SignatureValue);
572 BOOST_CHECK_EQUAL(d.getSignatureValue().value_size(), 0);
573
574 BOOST_CHECK_THROW(d.setSignatureValue(nullptr), std::invalid_argument);
575}
576
Davide Pesavento4c1ad4c2020-11-16 21:12:02 -0500577BOOST_FIXTURE_TEST_CASE(ExtractSignedRanges, KeyChainFixture)
Eric Newberrye36aae12020-08-31 22:23:13 -0700578{
579 Data d1("/test/prefix");
580 m_keyChain.sign(d1);
581 auto ranges1 = d1.extractSignedRanges();
582 BOOST_REQUIRE_EQUAL(ranges1.size(), 1);
583 const Block& wire1 = d1.wireEncode();
584 const auto& sigInfoWire1 = wire1.find(tlv::SignatureInfo);
585 BOOST_REQUIRE(sigInfoWire1 != wire1.elements_end());
Davide Pesavento765abc92021-12-27 00:44:04 -0500586 BOOST_CHECK_EQUAL_COLLECTIONS(ranges1.front().begin(), ranges1.front().end(),
Eric Newberrye36aae12020-08-31 22:23:13 -0700587 wire1.value_begin(), sigInfoWire1->value_end());
588
589 // Test with decoded Data and ensure excludes elements after SignatureValue
590 const uint8_t WIRE[] = {
591 0x06, 0x0B, // Data
592 0x07, 0x00, // Name
593 0x16, 0x03, // SignatureInfo
594 0x1B, 0x01, // SignatureType
595 0x00,
596 0x17, 0x00, // SignatureValue
597 0xAA, 0x00 // Unrecognized non-critical element
598 };
599 Block wire2(WIRE, sizeof(WIRE));
600 Data d2(wire2);
601 auto ranges2 = d2.extractSignedRanges();
602 BOOST_REQUIRE_EQUAL(ranges2.size(), 1);
Davide Pesavento765abc92021-12-27 00:44:04 -0500603 BOOST_CHECK_EQUAL_COLLECTIONS(ranges2.front().begin(), ranges2.front().end(), &WIRE[2], &WIRE[9]);
Eric Newberrye36aae12020-08-31 22:23:13 -0700604}
605
Junxiao Shi81206d52017-07-23 12:43:22 +0000606BOOST_AUTO_TEST_CASE(Equality)
Alexander Afanasyevff2d08f2014-04-07 18:28:25 -0700607{
Alexander Afanasyevff2d08f2014-04-07 18:28:25 -0700608 Data a;
609 Data b;
610 BOOST_CHECK_EQUAL(a == b, true);
611 BOOST_CHECK_EQUAL(a != b, false);
612
Davide Pesavento14c56cd2020-05-21 01:44:03 -0400613 a.setName("/A");
Alexander Afanasyevff2d08f2014-04-07 18:28:25 -0700614 BOOST_CHECK_EQUAL(a == b, false);
615 BOOST_CHECK_EQUAL(a != b, true);
616
Davide Pesavento14c56cd2020-05-21 01:44:03 -0400617 b.setName("/B");
Alexander Afanasyevff2d08f2014-04-07 18:28:25 -0700618 BOOST_CHECK_EQUAL(a == b, false);
619 BOOST_CHECK_EQUAL(a != b, true);
620
Davide Pesavento14c56cd2020-05-21 01:44:03 -0400621 b.setName("/A");
Alexander Afanasyevff2d08f2014-04-07 18:28:25 -0700622 BOOST_CHECK_EQUAL(a == b, true);
623 BOOST_CHECK_EQUAL(a != b, false);
624
Davide Pesavento0f830802018-01-16 23:58:58 -0500625 a.setFreshnessPeriod(10_s);
Alexander Afanasyevff2d08f2014-04-07 18:28:25 -0700626 BOOST_CHECK_EQUAL(a == b, false);
627 BOOST_CHECK_EQUAL(a != b, true);
628
Davide Pesavento0f830802018-01-16 23:58:58 -0500629 b.setFreshnessPeriod(10_s);
Alexander Afanasyevff2d08f2014-04-07 18:28:25 -0700630 BOOST_CHECK_EQUAL(a == b, true);
631 BOOST_CHECK_EQUAL(a != b, false);
632
633 static const uint8_t someData[] = "someData";
634 a.setContent(someData, sizeof(someData));
635 BOOST_CHECK_EQUAL(a == b, false);
636 BOOST_CHECK_EQUAL(a != b, true);
637
638 b.setContent(someData, sizeof(someData));
639 BOOST_CHECK_EQUAL(a == b, true);
640 BOOST_CHECK_EQUAL(a != b, false);
641
Eric Newberrya3c8bd12020-05-15 17:27:07 -0700642 a.setSignatureInfo(SignatureInfo(tlv::SignatureSha256WithRsa));
Alexander Afanasyevff2d08f2014-04-07 18:28:25 -0700643 BOOST_CHECK_EQUAL(a == b, false);
644 BOOST_CHECK_EQUAL(a != b, true);
645
Eric Newberrya3c8bd12020-05-15 17:27:07 -0700646 b.setSignatureInfo(SignatureInfo(tlv::SignatureSha256WithRsa));
Alexander Afanasyevff2d08f2014-04-07 18:28:25 -0700647 BOOST_CHECK_EQUAL(a == b, true);
648 BOOST_CHECK_EQUAL(a != b, false);
649}
650
Junxiao Shi81206d52017-07-23 12:43:22 +0000651BOOST_AUTO_TEST_CASE(Print)
Alexander Afanasyevff2d08f2014-04-07 18:28:25 -0700652{
Davide Pesavento81bd6962020-06-17 16:03:23 -0400653 Data d1(Block(DATA1, sizeof(DATA1)));
654 BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(d1),
Alexander Afanasyeva0c5f832014-06-19 13:27:56 -0700655 "Name: /local/ndn/prefix\n"
Davide Pesavento81bd6962020-06-17 16:03:23 -0400656 "MetaInfo: [ContentType: 0, FreshnessPeriod: 10000 milliseconds]\n"
657 "Content: [8 bytes]\n"
658 "Signature: [type: SignatureSha256WithRsa, length: 128]\n");
659
660 Data d2("/foo");
661 BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(d2),
662 "Name: /foo\n"
663 "MetaInfo: [ContentType: 0]\n"
664 "Signature: [type: Unknown(65535), length: 0]\n");
Alexander Afanasyev5fa9e9a2013-12-24 19:45:07 -0800665}
666
Davide Pesaventoeee3e822016-11-26 19:19:34 +0100667BOOST_AUTO_TEST_SUITE_END() // TestData
Alexander Afanasyev0abb2da2014-01-30 18:07:57 -0800668
Spyridon Mastorakis429634f2015-02-19 17:35:33 -0800669} // namespace tests
Alexander Afanasyev0abb2da2014-01-30 18:07:57 -0800670} // namespace ndn