Weave Packet Receiver

components/proximity_auth/ble/bluetooth_low_energy_weave_packet_receiver_unittest.cc

Index: components/proximity_auth/ble/bluetooth_low_energy_weave_packet_receiver_unittest.cc
diff --git a/components/proximity_auth/ble/bluetooth_low_energy_weave_packet_receiver_unittest.cc b/components/proximity_auth/ble/bluetooth_low_energy_weave_packet_receiver_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..3ad25dd9f0fc25edac5949f02f1bbc1a062132d2
--- /dev/null
+++ b/components/proximity_auth/ble/bluetooth_low_energy_weave_packet_receiver_unittest.cc
@@ -0,0 +1,348 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/proximity_auth/ble/bluetooth_low_energy_weave_packet_receiver.h"
+
+#include <algorithm>
+#include <string>
+
+#include "base/logging.h"
+#include "components/proximity_auth/ble/bluetooth_low_energy_weave_packet_generator.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using proximity_auth::BluetoothLowEnergyWeavePacketGenerator;
+using proximity_auth::BluetoothLowEnergyWeavePacketReceiver;
+
+namespace {
+typedef BluetoothLowEnergyWeavePacketReceiver::State State;
+typedef BluetoothLowEnergyWeavePacketReceiver::ReceiverType ReceiverType;
+typedef BluetoothLowEnergyWeavePacketGenerator::ReasonForClose ReasonForClose;
+
+}  // namespace
+
+namespace proximity_auth {
+
+class ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest
+    : public testing::Test {
+ protected:
+  ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest() {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(
+      ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest);
+};
+
+TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
+       WellBehavingServerPacketsNoControlDataTest) {
+  std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
+      (new BluetoothLowEnergyWeavePacketReceiver::Factory())
+          ->NewInstance(ReceiverType::SERVER);
+
+  // TODO(jingxuy): put comments on hex values

[Kyle Horimoto, 2016/06/20 23:25:40]

Please also describe what the other values are. For example, below you have
{0x80, 1, 0, 1, 0, 0, 0}, but it is unclear what any of these values mean.
People who read your code should be able to tell what this means without
cross-referencing the spec.

[jingxuy, 2016/06/21 01:19:15]

Done.

[Kyle Horimoto, 2016/06/21 02:10:27]

You still need to use constants for the last two 0's.

[Kyle Horimoto, 2016/06/21 18:13:38]

Ping.

[jingxuy, 2016/06/22 01:42:23]

Done.

+  std::vector<uint8_t> p0{0x80, 1, 0, 1, 0, 0, 0};
+  receiver->ReceivePacket(p0);
+  EXPECT_EQ(State::WAITING, receiver->GetState());
+
+  std::vector<uint8_t> p1{0x18, 'a', 'b'};

[Kyle Horimoto, 2016/06/20 23:25:40]

If a packet is NOT the last packet in a message, it should be full (i.e., its
length should be the maximum allowed length).

While it is also good to handle this situation gracefully, this is more of an
edge case than the base case which should be tested. You should write a small
test which ensures that these types of packets are handled correctly, but the
majority of your tests should test what we actually expect to happen in
practice.

[jingxuy, 2016/06/21 01:19:15]

Done.

+  receiver->ReceivePacket(p1);
+  EXPECT_EQ(State::RECEIVING_DATA, receiver->GetState());
+
+  std::vector<uint8_t> p2{0x24, 'c', 'd'};
+  receiver->ReceivePacket(p2);
+  EXPECT_EQ(State::DATA_READY, receiver->GetState());
+  EXPECT_EQ("abcd", receiver->GetDataMessage());
+
+  std::vector<uint8_t> p3{0x3C, 'g', 'o', 'o', 'g', 'l', 'e'};
+  receiver->ReceivePacket(p3);
+  EXPECT_EQ(State::DATA_READY, receiver->GetState());
+  EXPECT_EQ("google", receiver->GetDataMessage());
+
+  std::vector<uint8_t> p4{0xC2, 0x80, 0x00};
+  receiver->ReceivePacket(p4);
+  EXPECT_EQ(State::CONNECTION_CLOSED, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::APPLICATION_ERROR, receiver->GetReasonForClose());
+}
+
+TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
+       WellBehavingServerPacketsWithControlDataTest) {
+  std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
+      (new BluetoothLowEnergyWeavePacketReceiver::Factory())
+          ->NewInstance(ReceiverType::SERVER);
+
+  std::vector<uint8_t> p0{0x80, 1, 0, 1, 0, 0, 0, 'a', 'b', 'c', 'd'};
+  receiver->ReceivePacket(p0);
+  EXPECT_EQ(State::DATA_READY, receiver->GetState());
+  EXPECT_EQ("abcd", receiver->GetDataMessage());
+
+  std::vector<uint8_t> p1{0x18, 'e', 'f'};
+  receiver->ReceivePacket(p1);
+  EXPECT_EQ(State::RECEIVING_DATA, receiver->GetState());
+
+  std::vector<uint8_t> p2{0x24, 'g', 'h'};
+  receiver->ReceivePacket(p2);
+  EXPECT_EQ(State::DATA_READY, receiver->GetState());
+  EXPECT_EQ("efgh", receiver->GetDataMessage());
+
+  std::vector<uint8_t> p3{0xB2, 0x00, 0x00};
+  receiver->ReceivePacket(p3);
+  EXPECT_EQ(State::CONNECTION_CLOSED, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::CLOSE_WITHOUT_ERROR, receiver->GetReasonForClose());
+}
+
+TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
+       WellBehavingClientPacketsNoControlDataTest) {
+  std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
+      (new BluetoothLowEnergyWeavePacketReceiver::Factory())
+          ->NewInstance(ReceiverType::CLIENT);
+
+  std::vector<uint8_t> p0{0x81, 1, 0, 30, 0};
+  receiver->ReceivePacket(p0);
+  EXPECT_EQ(State::WAITING, receiver->GetState());
+  EXPECT_EQ((uint32_t)30, receiver->GetMaxPacketSize());
+
+  std::vector<uint8_t> p1{0x1C, 'g', 'o', 'o', 'g', 'l', 'e'};
+  receiver->ReceivePacket(p1);
+  EXPECT_EQ(State::DATA_READY, receiver->GetState());
+  EXPECT_EQ("google", receiver->GetDataMessage());
+
+  std::vector<uint8_t> p2{0xA2, 0x80, 0x00};
+  receiver->ReceivePacket(p2);
+  EXPECT_EQ(State::CONNECTION_CLOSED, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::APPLICATION_ERROR, receiver->GetReasonForClose());
+}
+
+TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
+       WellBehavingClientPacketsWithControlDataTest) {
+  std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
+      (new BluetoothLowEnergyWeavePacketReceiver::Factory())
+          ->NewInstance(ReceiverType::CLIENT);
+
+  std::vector<uint8_t> p0{0x81, 1, 0, 20, 0, 'a', 'b', 'c', 'd'};
+  receiver->ReceivePacket(p0);
+  EXPECT_EQ(State::DATA_READY, receiver->GetState());
+  EXPECT_EQ("abcd", receiver->GetDataMessage());
+
+  std::vector<uint8_t> p1{0x1C, 'g', 'o', 'o', 'g', 'l', 'e'};
+  receiver->ReceivePacket(p1);
+  EXPECT_EQ(State::DATA_READY, receiver->GetState());
+  EXPECT_EQ("google", receiver->GetDataMessage());
+
+  std::vector<uint8_t> p2{0xA2, 0x00, 0x00};
+  receiver->ReceivePacket(p2);
+  EXPECT_EQ(State::CONNECTION_CLOSED, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::CLOSE_WITHOUT_ERROR, receiver->GetReasonForClose());
+}
+
+TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
+       ShortPacketTest) {
+  BluetoothLowEnergyWeavePacketReceiver::Factory factory =
+      BluetoothLowEnergyWeavePacketReceiver::Factory();
+
+  std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
+      factory.NewInstance(ReceiverType::CLIENT);
+
+  std::vector<uint8_t> p0{0x81, 1, 0, 20, 0};
+  receiver->ReceivePacket(p0);
+  EXPECT_EQ(State::WAITING, receiver->GetState());
+
+  std::vector<uint8_t> p1{0x1C};
+  receiver->ReceivePacket(p1);
+  EXPECT_EQ(State::DATA_READY, receiver->GetState());
+  EXPECT_EQ("", receiver->GetDataMessage());
+
+  std::vector<uint8_t> p2;
+  receiver->ReceivePacket(p2);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
+}
+
+TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
+       InappropriateConnectingTypeTest) {
+  BluetoothLowEnergyWeavePacketReceiver::Factory factory =
+      BluetoothLowEnergyWeavePacketReceiver::Factory();
+
+  // Server receives connection response.
+  std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
+      factory.NewInstance(ReceiverType::SERVER);
+  std::vector<uint8_t> p0{0x81, 1, 0, 20, 0};
+  receiver->ReceivePacket(p0);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
+
+  // Client receives connection request.
+  receiver = factory.NewInstance(ReceiverType::CLIENT);
+  std::vector<uint8_t> p1{0x80, 1, 0, 1, 0, 0, 0};
+  receiver->ReceivePacket(p1);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
+
+  // Receiving connection close as the first packet.
+  receiver = factory.NewInstance(ReceiverType::SERVER);
+  std::vector<uint8_t> p2{0x82, 0, 0};
+  receiver->ReceivePacket(p2);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
+
+  // Receiving data packet as the first packet.
+  receiver = factory.NewInstance(ReceiverType::SERVER);
+  std::vector<uint8_t> p3{0x08, 'a', 'b', 'c', 'd'};
+  receiver->ReceivePacket(p3);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
+}
+
+TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
+       ControlPacketSizeTest) {
+  BluetoothLowEnergyWeavePacketReceiver::Factory factory =
+      BluetoothLowEnergyWeavePacketReceiver::Factory();
+
+  // Connection request missing a byte.
+  std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
+      factory.NewInstance(ReceiverType::SERVER);
+  std::vector<uint8_t> p0{0x80, 1, 0, 1, 0, 0};
+  receiver->ReceivePacket(p0);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
+
+  // Connection response missing a byte.
+  receiver = factory.NewInstance(ReceiverType::CLIENT);
+  std::vector<uint8_t> p1{0x81, 1, 0, 20};
+  receiver->ReceivePacket(p1);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
+
+  // Max length connection request is accepted.
+  receiver = factory.NewInstance(ReceiverType::SERVER);
+  std::vector<uint8_t> p2(20, 0);
+  p2[0] = 0x80;
+  p2[1] = 1;
+  p2[3] = 1;
+  receiver->ReceivePacket(p2);
+  EXPECT_EQ(State::DATA_READY, receiver->GetState());
+
+  // Connection request that's a byte too long.
+  receiver = factory.NewInstance(ReceiverType::SERVER);
+  p2.push_back(0);
+  receiver->ReceivePacket(p2);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
+
+  // Max length connection response is accepted.
+  receiver = factory.NewInstance(ReceiverType::CLIENT);
+  std::vector<uint8_t> p3(20, 0);
+  p3[0] = 0x81;
+  p3[1] = 1;
+  p3[3] = 20;
+  receiver->ReceivePacket(p3);
+  EXPECT_EQ(State::DATA_READY, receiver->GetState());
+
+  // Connection response that's a byte too long.
+  receiver = factory.NewInstance(ReceiverType::CLIENT);
+  p3.push_back(0);
+  receiver->ReceivePacket(p3);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
+}
+
+TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
+       WrongFirstLastBitTest) {
+  BluetoothLowEnergyWeavePacketReceiver::Factory factory =
+      BluetoothLowEnergyWeavePacketReceiver::Factory();
+
+  // First bit is not set when it's supposed to be with last bit not set.
+  std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
+      factory.NewInstance(ReceiverType::SERVER);
+  std::vector<uint8_t> p0{0x80, 1, 0, 1, 0, 0, 0};
+  receiver->ReceivePacket(p0);
+  EXPECT_EQ(State::WAITING, receiver->GetState());
+
+  std::vector<uint8_t> p1{0x10};
+  receiver->ReceivePacket(p1);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::RECEIVED_PACKET_OUT_OF_SEQUENCE,
+            receiver->GetReasonToClose());
+
+  // First bit is not set when it's supposed to be when last bit is set.
+  receiver = factory.NewInstance(ReceiverType::SERVER);
+  receiver->ReceivePacket(p0);
+  EXPECT_EQ(State::WAITING, receiver->GetState());
+
+  std::vector<uint8_t> p2{0x14};
+  receiver->ReceivePacket(p1);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::RECEIVED_PACKET_OUT_OF_SEQUENCE,
+            receiver->GetReasonToClose());
+}
+
+TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
+       OutOfOrderPacketTest) {
+  BluetoothLowEnergyWeavePacketReceiver::Factory factory =
+      BluetoothLowEnergyWeavePacketReceiver::Factory();
+
+  // Skip a packet in number.
+  std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
+      factory.NewInstance(ReceiverType::SERVER);
+  std::vector<uint8_t> p0{0x80, 1, 0, 1, 0, 0, 0};
+  receiver->ReceivePacket(p0);
+  EXPECT_EQ(State::WAITING, receiver->GetState());
+
+  std::vector<uint8_t> p1{0x20};
+  receiver->ReceivePacket(p1);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::RECEIVED_PACKET_OUT_OF_SEQUENCE,
+            receiver->GetReasonToClose());
+}
+
+TEST_F(ProximityAuthBluetoothLowEnergyWeavePacketReceiverTest,
+       IncorrectValuesInControlPacketTest) {
+  BluetoothLowEnergyWeavePacketReceiver::Factory factory =
+      BluetoothLowEnergyWeavePacketReceiver::Factory();
+
+  // Invalid version in request.
+  std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> receiver =
+      factory.NewInstance(ReceiverType::SERVER);
+  std::vector<uint8_t> p0{0x80, 2, 0, 1, 0, 0, 0};
+  receiver->ReceivePacket(p0);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::NO_COMMON_VERSION_SUPPORTED,
+            receiver->GetReasonToClose());
+
+  // Invalid max packet size in request.
+  receiver = factory.NewInstance(ReceiverType::SERVER);
+  std::vector<uint8_t> p1{0x80, 1, 0, 1, 0, 19, 0};
+  receiver->ReceivePacket(p1);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
+
+  // Invalid selected version in response.
+  receiver = factory.NewInstance(ReceiverType::CLIENT);
+  std::vector<uint8_t> p2{0x81, 0, 1, 20, 0};
+  receiver->ReceivePacket(p2);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::NO_COMMON_VERSION_SUPPORTED,
+            receiver->GetReasonToClose());
+
+  // Invalid selected max packet size in response.
+  receiver = factory.NewInstance(ReceiverType::CLIENT);
+  std::vector<uint8_t> p3{0x81, 1, 0, 19, 0};
+  receiver->ReceivePacket(p3);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
+
+  // Invalid reason for close.
+  receiver = factory.NewInstance(ReceiverType::CLIENT);
+  std::vector<uint8_t> p4{0x81, 1, 0, 20, 0};
+  receiver->ReceivePacket(p4);
+  EXPECT_EQ(State::WAITING, receiver->GetState());
+
+  std::vector<uint8_t> p5{0x92, 0x05, 0x00};
+  receiver->ReceivePacket(p5);
+  EXPECT_EQ(State::ERROR, receiver->GetState());
+  EXPECT_EQ(ReasonForClose::UNKNOWN_ERROR, receiver->GetReasonToClose());
+}
+
+// TODO(jingxuy): test for other malicious headers
+
+}  // namespace proximity_auth