Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit b7bc2bc2 authored by Fabien Sanglard's avatar Fabien Sanglard
Browse files

Use libadb_auth to start/stop adbd wifi 

Problem: There is a race condition between AdbService and adbd.
AdbService starts adbd wifi using a system property. Depending how fast
adbd responds, the TLS server can be up before AdbDebuggingManager had
a chance to toggle off ADB Wifi (if user has no granted access to the
current Wifi network.

Solution: Leverage libadb_auth to send message from AdbService to adbd.
This allows AdbService to start adbd wifi only after user has granted
access.

Test: Manual
Bug: 414682912
Flag: EXEMPT (Bug fix)
Change-Id: Ia548e1ae2c34ade9acd751e206e811b754a7174b
parent b3372d53

libs/adbd_auth/adbd_auth.cpp

+57 −9
Original line number Diff line number Diff line
@@ -27,6 +27,7 @@ 
#include <chrono>

#include <deque>

#include <optional>

#include <set>

#include <string>

#include <string_view>

#include <tuple>
@@ -45,7 +46,9 @@ 


using android::base::unique_fd;



static constexpr uint32_t kAuthVersion = 1;

static constexpr uint32_t kAuthVersion = 2;



static std::set<AdbdAuthFeature> supported_features = {AdbdAuthFeature::WifiLifeCycle};



struct AdbdAuthPacketAuthenticated {

    std::string public_key;
@@ -87,7 +90,6 @@ struct AdbdAuthContext { 


public:

  explicit AdbdAuthContext(AdbdAuthCallbacksV1* callbacks) : next_id_(0), callbacks_(*callbacks) {

        InitFrameworkHandlers();

        epoll_fd_.reset(epoll_create1(EPOLL_CLOEXEC));

        if (epoll_fd_ == -1) {

            PLOG(FATAL) << "adbd_auth: failed to create epoll fd";
@@ -116,6 +118,8 @@ public: 
        }

    }



    virtual ~AdbdAuthContext(){}



    AdbdAuthContext(const AdbdAuthContext& copy) = delete;

    AdbdAuthContext(AdbdAuthContext&& move) = delete;

    AdbdAuthContext& operator=(const AdbdAuthContext& copy) = delete;
@@ -502,7 +506,7 @@ public: 
        }

    }



    void InitFrameworkHandlers() {

    virtual void InitFrameworkHandlers() {

        // Framework wants to disconnect from a secured wifi device

        framework_handlers_.emplace_back(

                FrameworkPktHandler{
@@ -547,15 +551,60 @@ public: 
    std::vector<FrameworkPktHandler> framework_handlers_;

};



class AdbdAuthContextV2 : public AdbdAuthContext {

 public:

  explicit AdbdAuthContextV2(AdbdAuthCallbacksV2* callbacks) : AdbdAuthContext(callbacks),

                                                               callbacks_v2_(*callbacks) {}



  virtual void InitFrameworkHandlers() {

        AdbdAuthContext::InitFrameworkHandlers();

        // Framework requires ADB Wifi to start

        framework_handlers_.emplace_back(

                FrameworkPktHandler{

                    .code = "W1",

                    .cb = std::bind(&AdbdAuthContextV2::StartAdbWifi, this, std::placeholders::_1)});



        // Framework requires ADB Wifi to stop

        framework_handlers_.emplace_back(

                FrameworkPktHandler{

                     .code = "W0",

                     .cb = std::bind(&AdbdAuthContextV2::StopAdbWifi, this, std::placeholders::_1)});

  }





  void StartAdbWifi(std::string_view buf) EXCLUDES(mutex_) {

        CHECK(buf.empty());

        callbacks_v2_.start_adbd_wifi();

    }



    void StopAdbWifi(std::string_view buf) EXCLUDES(mutex_) {

        CHECK(buf.empty());

        callbacks_v2_.stop_adbd_wifi();

    }



 private:

  AdbdAuthCallbacksV2 callbacks_v2_;

};



AdbdAuthContext* adbd_auth_new(AdbdAuthCallbacks* callbacks) {

    if (callbacks->version == 1) {

        return new AdbdAuthContext(reinterpret_cast<AdbdAuthCallbacksV1*>(callbacks));

    } else {

    switch (callbacks->version) {

      case 1: {

        AdbdAuthContext* ctx = new AdbdAuthContext (reinterpret_cast<AdbdAuthCallbacksV1*>(callbacks));

        ctx->InitFrameworkHandlers();

        return ctx;

      }

      case kAuthVersion: {

        AdbdAuthContextV2* ctx2 = new AdbdAuthContextV2(reinterpret_cast<AdbdAuthCallbacksV2*>(callbacks));

        ctx2->InitFrameworkHandlers();

        return ctx2;

      }

      default : {

        LOG(ERROR) << "adbd_auth: received unknown AdbdAuthCallbacks version "

                   << callbacks->version;

        return nullptr;

      }

    }

}



void adbd_auth_delete(AdbdAuthContext* ctx) {

    delete ctx;
@@ -607,8 +656,7 @@ uint32_t adbd_auth_get_max_version() { 
}



bool adbd_auth_supports_feature(AdbdAuthFeature f) {

    UNUSED(f);

    return false;

  return supported_features.contains(f);

}



void adbd_auth_send_tls_server_port(AdbdAuthContext* ctx, uint16_t port) {

libs/adbd_auth/adbd_auth_test.cpp

+9 −2
Original line number Diff line number Diff line
@@ -21,16 +21,23 @@ 


#include "adbd_auth.h"



void start_wifi() {}

void stop_wifi() {}



class AdbAuthTest: public ::testing::Test {

   public:

    void SetUp() {

        AdbdAuthCallbacks callbacks = {.version = 1};

        AdbdAuthCallbacksV2 callbacks;

        callbacks.version = 2;

        callbacks.start_adbd_wifi = start_wifi;

        callbacks.stop_adbd_wifi = stop_wifi;

        context = adbd_auth_new(&callbacks);

    }



    void TearDown() {

      adbd_auth_delete(context);

    }



 protected:

  AdbdAuthContext* context;

};

libs/adbd_auth/include/adbd_auth.h

+9 −0
Original line number Diff line number Diff line
@@ -49,6 +49,14 @@ struct AdbdAuthCallbacksV1 : AdbdAuthCallbacks { 
    void (*key_removed)(const char* public_key, size_t length);

};



struct AdbdAuthCallbacksV2 : AdbdAuthCallbacksV1 {

    // The framework wants adbd to start adb wifi (TCP / TLS)

    void (*start_adbd_wifi)();



    // The framework wants adbd to stop adb wifi (TCP / TLS)

    void (*stop_adbd_wifi)();

};



struct AdbdAuthContext;

typedef struct AdbdAuthContext AdbdAuthContext;
@@ -177,6 +185,7 @@ void adbd_auth_tls_device_disconnected(AdbdAuthContext* ctx, 
uint32_t adbd_auth_get_max_version(void) __INTRODUCED_IN(30);



enum AdbdAuthFeature : int32_t {

  WifiLifeCycle, // Framework can request ADB Wifi TLS server to start/stop.

};



/**