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

Commit f571fcbe authored by Josh Gao's avatar Josh Gao
Browse files

adb: switch apacket over to a std::string payload. 

Test: python test_device.py with walleye/x86_64 emulator
Change-Id: I0a18941af1cb2279e5019a24ace25741def1202f
parent 2733708c

adb/adb.cpp

+19 −31
Original line number Diff line number Diff line
@@ -105,31 +105,27 @@ void fatal_errno(const char* fmt, ...) { 
}



uint32_t calculate_apacket_checksum(const apacket* p) {

    const unsigned char* x = reinterpret_cast<const unsigned char*>(p->data);

    uint32_t sum = 0;

    size_t count = p->msg.data_length;



    while (count-- > 0) {

        sum += *x++;

    for (size_t i = 0; i < p->msg.data_length; ++i) {

        sum += static_cast<uint8_t>(p->payload[i]);

    }



    return sum;

}



apacket* get_apacket(void)

{

    apacket* p = reinterpret_cast<apacket*>(malloc(sizeof(apacket)));

    apacket* p = new apacket();

    if (p == nullptr) {

      fatal("failed to allocate an apacket");

    }



    memset(p, 0, sizeof(apacket) - MAX_PAYLOAD);

    memset(&p->msg, 0, sizeof(p->msg));

    return p;

}



void put_apacket(apacket *p)

{

    free(p);

    delete p;

}



void handle_online(atransport *t)
@@ -155,8 +151,7 @@ void handle_offline(atransport *t) 
#define DUMPMAX 32

void print_packet(const char *label, apacket *p)

{

    char *tag;

    char *x;

    const char* tag;

    unsigned count;



    switch(p->msg.command){
@@ -173,7 +168,7 @@ void print_packet(const char *label, apacket *p) 
    fprintf(stderr, "%s: %s %08x %08x %04x \"",

            label, tag, p->msg.arg0, p->msg.arg1, p->msg.data_length);

    count = p->msg.data_length;

    x = (char*) p->data;

    const char* x = p->payload.data();

    if (count > DUMPMAX) {

        count = DUMPMAX;

        tag = "\n";
@@ -254,8 +249,8 @@ void send_connect(atransport* t) { 
                   << connection_str.length() << ")";

    }



    memcpy(cp->data, connection_str.c_str(), connection_str.length());

    cp->msg.data_length = connection_str.length();

    cp->payload = std::move(connection_str);

    cp->msg.data_length = cp->payload.size();



    send_packet(cp, t);

}
@@ -329,9 +324,7 @@ static void handle_new_connection(atransport* t, apacket* p) { 
    }



    t->update_version(p->msg.arg0, p->msg.arg1);

    std::string banner(reinterpret_cast<const char*>(p->data),

                       p->msg.data_length);

    parse_banner(banner, t);

    parse_banner(p->payload, t);



#if ADB_HOST

    handle_online(t);
@@ -354,6 +347,7 @@ void handle_packet(apacket *p, atransport *t) 
            ((char*) (&(p->msg.command)))[2],

            ((char*) (&(p->msg.command)))[3]);

    print_packet("recv", p);

    CHECK_EQ(p->payload.size(), p->msg.data_length);



    switch(p->msg.command){

    case A_SYNC:
@@ -380,11 +374,11 @@ void handle_packet(apacket *p, atransport *t) 
                if (t->GetConnectionState() == kCsOffline) {

                    t->SetConnectionState(kCsUnauthorized);

                }

                send_auth_response(p->data, p->msg.data_length, t);

                send_auth_response(p->payload.data(), p->msg.data_length, t);

                break;

#else

            case ADB_AUTH_SIGNATURE:

                if (adbd_auth_verify(t->token, sizeof(t->token), p->data, p->msg.data_length)) {

                if (adbd_auth_verify(t->token, sizeof(t->token), p->payload)) {

                    adbd_auth_verified(t);

                    t->failed_auth_attempts = 0;

                } else {
@@ -394,7 +388,7 @@ void handle_packet(apacket *p, atransport *t) 
                break;



            case ADB_AUTH_RSAPUBLICKEY:

                adbd_auth_confirm_key(p->data, p->msg.data_length, t);

                adbd_auth_confirm_key(p->payload.data(), p->msg.data_length, t);

                break;

#endif

            default:
@@ -406,9 +400,7 @@ void handle_packet(apacket *p, atransport *t) 


    case A_OPEN: /* OPEN(local-id, 0, "destination") */

        if (t->online && p->msg.arg0 != 0 && p->msg.arg1 == 0) {

            char *name = (char*) p->data;

            name[p->msg.data_length > 0 ? p->msg.data_length - 1 : 0] = 0;

            asocket* s = create_local_service_socket(name, t);

            asocket* s = create_local_service_socket(p->payload.c_str(), t);

            if (s == nullptr) {

                send_close(0, p->msg.arg0, t);

            } else {
@@ -474,11 +466,7 @@ void handle_packet(apacket *p, atransport *t) 
            asocket* s = find_local_socket(p->msg.arg1, p->msg.arg0);

            if (s) {

                unsigned rid = p->msg.arg0;



                // TODO: Convert apacket::data to a type that we can move out of.

                std::string copy(p->data, p->data + p->msg.data_length);



                if (s->enqueue(s, std::move(copy)) == 0) {

                if (s->enqueue(s, std::move(p->payload)) == 0) {

                    D("Enqueue the socket");

                    send_ready(s->id, rid, t);

                }

adb/adb.h

+1 −1
Original line number Diff line number Diff line
@@ -74,7 +74,7 @@ struct amessage { 


struct apacket {

    amessage msg;

    char data[MAX_PAYLOAD];

    std::string payload;

};



uint32_t calculate_apacket_checksum(const apacket* packet);

adb/adb_auth.h

+1 −1
Original line number Diff line number Diff line
@@ -49,7 +49,7 @@ void adbd_auth_init(void); 
void adbd_auth_verified(atransport *t);



void adbd_cloexec_auth_socket();

bool adbd_auth_verify(const char* token, size_t token_size, const char* sig, int sig_len);

bool adbd_auth_verify(const char* token, size_t token_size, const std::string& sig);

void adbd_auth_confirm_key(const char* data, size_t len, atransport* t);



void send_auth_request(atransport *t);

adb/adb_auth_host.cpp

+17 −10
Original line number Diff line number Diff line
@@ -299,20 +299,25 @@ std::deque<std::shared_ptr<RSA>> adb_auth_get_private_keys() { 
    return result;

}



static int adb_auth_sign(RSA* key, const char* token, size_t token_size, char* sig) {

static std::string adb_auth_sign(RSA* key, const char* token, size_t token_size) {

    if (token_size != TOKEN_SIZE) {

        D("Unexpected token size %zd", token_size);

        return 0;

    }



    std::string result;

    result.resize(MAX_PAYLOAD);



    unsigned int len;

    if (!RSA_sign(NID_sha1, reinterpret_cast<const uint8_t*>(token), token_size,

                  reinterpret_cast<uint8_t*>(sig), &len, key)) {

        return 0;

                  reinterpret_cast<uint8_t*>(&result[0]), &len, key)) {

        return std::string();

    }



    result.resize(len);



    D("adb_auth_sign len=%d", len);

    return (int)len;

    return result;

}



std::string adb_auth_get_userkey() {
@@ -446,13 +451,14 @@ static void send_auth_publickey(atransport* t) { 
    }



    apacket* p = get_apacket();

    memcpy(p->data, key.c_str(), key.size() + 1);



    p->msg.command = A_AUTH;

    p->msg.arg0 = ADB_AUTH_RSAPUBLICKEY;



    p->payload = std::move(key);



    // adbd expects a null-terminated string.

    p->msg.data_length = key.size() + 1;

    p->payload.push_back('\0');

    p->msg.data_length = p->payload.size();

    send_packet(p, t);

}
@@ -467,8 +473,8 @@ void send_auth_response(const char* token, size_t token_size, atransport* t) { 
    LOG(INFO) << "Calling send_auth_response";

    apacket* p = get_apacket();



    int ret = adb_auth_sign(key.get(), token, token_size, p->data);

    if (!ret) {

    std::string result = adb_auth_sign(key.get(), token, token_size);

    if (result.empty()) {

        D("Error signing the token");

        put_apacket(p);

        return;
@@ -476,6 +482,7 @@ void send_auth_response(const char* token, size_t token_size, atransport* t) { 


    p->msg.command = A_AUTH;

    p->msg.arg0 = ADB_AUTH_SIGNATURE;

    p->msg.data_length = ret;

    p->payload = std::move(result);

    p->msg.data_length = p->payload.size();

    send_packet(p, t);

}

adb/adbd_auth.cpp

+4 −3
Original line number Diff line number Diff line
@@ -46,7 +46,7 @@ static bool needs_retry = false; 


bool auth_required = true;



bool adbd_auth_verify(const char* token, size_t token_size, const char* sig, int sig_len) {

bool adbd_auth_verify(const char* token, size_t token_size, const std::string& sig) {

    static constexpr const char* key_paths[] = { "/adb_keys", "/data/misc/adb/adb_keys", nullptr };



    for (const auto& path : key_paths) {
@@ -80,7 +80,8 @@ bool adbd_auth_verify(const char* token, size_t token_size, const char* sig, int 


                bool verified =

                    (RSA_verify(NID_sha1, reinterpret_cast<const uint8_t*>(token), token_size,

                                reinterpret_cast<const uint8_t*>(sig), sig_len, key) == 1);

                                reinterpret_cast<const uint8_t*>(sig.c_str()), sig.size(),

                                key) == 1);

                RSA_free(key);

                if (verified) return true;

            }
@@ -210,10 +211,10 @@ void send_auth_request(atransport* t) { 
    }



    apacket* p = get_apacket();

    memcpy(p->data, t->token, sizeof(t->token));

    p->msg.command = A_AUTH;

    p->msg.arg0 = ADB_AUTH_TOKEN;

    p->msg.data_length = sizeof(t->token);

    p->payload.assign(t->token, t->token + sizeof(t->token));

    send_packet(p, t);

}