Weave Packet Receiver

components/proximity_auth/ble/bluetooth_low_energy_weave_packet_receiver_unittest.cc

+// 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);
+
+  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'};
+  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