1 // Copyright 2023 The Pigweed Authors
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License"); you may not
4 // use this file except in compliance with the License. You may obtain a copy of
5 // the License at
6 //
7 // https://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
11 // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
12 // License for the specific language governing permissions and limitations under
13 // the License.
14
15 #include "pw_bluetooth_sapphire/internal/host/sm/packet.h"
16
17 #include "pw_bluetooth_sapphire/internal/host/common/byte_buffer.h"
18 #include "pw_unit_test/framework.h"
19
20 namespace bt::sm {
21 namespace {
22
TEST(PacketTest,ParseValidPacket)23 TEST(PacketTest, ParseValidPacket) {
24 StaticByteBuffer kValidPacket(kPairingFailed, ErrorCode::kEncryptionKeySize);
25 ByteBufferPtr valid_packet_ptr =
26 std::make_unique<DynamicByteBuffer>(kValidPacket);
27 fit::result<ErrorCode, ValidPacketReader> maybe_reader =
28 ValidPacketReader::ParseSdu(valid_packet_ptr);
29 ASSERT_TRUE(maybe_reader.is_ok());
30 ValidPacketReader reader = maybe_reader.value();
31 ASSERT_EQ(reader.code(), kPairingFailed);
32 ErrorCode payload = reader.payload<ErrorCode>();
33 ASSERT_EQ(payload, ErrorCode::kEncryptionKeySize);
34 }
35
TEST(PacketTest,EmptyPacketGivesError)36 TEST(PacketTest, EmptyPacketGivesError) {
37 ByteBufferPtr empty_packet_ptr = std::make_unique<DynamicByteBuffer>();
38 fit::result<ErrorCode, ValidPacketReader> maybe_reader =
39 ValidPacketReader::ParseSdu(empty_packet_ptr);
40 ASSERT_TRUE(maybe_reader.is_error());
41 ErrorCode ecode = maybe_reader.error_value();
42 ASSERT_EQ(ecode, ErrorCode::kInvalidParameters);
43 }
44
TEST(PacketTest,UnknownSMPCodeGivesError)45 TEST(PacketTest, UnknownSMPCodeGivesError) {
46 StaticByteBuffer kUnknownCodePacket(
47 0xFF, // Not a valid SMP packet header code.
48 ErrorCode::kEncryptionKeySize);
49 ByteBufferPtr unknown_code_packet_ptr =
50 std::make_unique<DynamicByteBuffer>(kUnknownCodePacket);
51 fit::result<ErrorCode, ValidPacketReader> maybe_reader =
52 ValidPacketReader::ParseSdu(unknown_code_packet_ptr);
53 ASSERT_TRUE(maybe_reader.is_error());
54 ErrorCode ecode = maybe_reader.error_value();
55 ASSERT_EQ(ecode, ErrorCode::kCommandNotSupported);
56 }
57
58 // This tests a case where the `size_t` packet size was stored into a `uint8_t`.
59 // If the packet size modulo 2^8 was 0, the length would overflow the `uint8_t`
60 // and the packet would be incorrectly recognized as having 0 length, leading to
61 // the wrong error being returned (and logged).
TEST(PacketTest,Mod256Equals0LengthPacketGivesCorrectError)62 TEST(PacketTest, Mod256Equals0LengthPacketGivesCorrectError) {
63 constexpr size_t k2ToThe8Size = 256;
64 Code kInvalidSmpCode = 0xFF;
65 StaticByteBuffer<k2ToThe8Size> unfortunately_sized_packet;
66 PacketWriter(kInvalidSmpCode, &unfortunately_sized_packet);
67 ByteBufferPtr p =
68 std::make_unique<DynamicByteBuffer>(unfortunately_sized_packet);
69 fit::result<ErrorCode, ValidPacketReader> maybe_reader =
70 ValidPacketReader::ParseSdu(p);
71 ASSERT_TRUE(maybe_reader.is_error());
72 ErrorCode ecode = maybe_reader.error_value();
73 ASSERT_EQ(ecode, ErrorCode::kCommandNotSupported);
74 }
75
TEST(PacketTest,PayloadSizeDoesNotMatchHeaderGivesError)76 TEST(PacketTest, PayloadSizeDoesNotMatchHeaderGivesError) {
77 // The PairingFailed code is expected to have a one byte error code as
78 // payload, not three bytes.
79 StaticByteBuffer kMalformedPacket(kPairingFailed, 0x01, 0x01, 0x01);
80 ByteBufferPtr malformed_packet_ptr =
81 std::make_unique<DynamicByteBuffer>(kMalformedPacket);
82 fit::result<ErrorCode, ValidPacketReader> maybe_reader =
83 ValidPacketReader::ParseSdu(malformed_packet_ptr);
84 ASSERT_TRUE(maybe_reader.is_error());
85 ErrorCode ecode = maybe_reader.error_value();
86 ASSERT_EQ(ecode, ErrorCode::kInvalidParameters);
87 }
88
89 } // namespace
90 } // namespace bt::sm
91