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

Commit a3612f32 authored by Yifan Hong's avatar Yifan Hong Committed by Gerrit Code Review
Browse files

Merge changes Ifaea4598,I78b4d2b1,I6c1f0f88,I6b4d0ebc,I5c17f464 

* changes:
  binder: CertificateFormat -> RpcCertificateFormat.
  binder: Support DER format certificates.
  binder: implement simple TLS verification for testing
  binder: X509 are serialized to vector<uint8_t>
  binder: delegate cert verification to RpcCertificateVerifier
parents e9b2010f 9734cfc7

libs/binder/Android.bp

+1 −0
Original line number Original line Diff line number Diff line
@@ -262,6 +262,7 @@ cc_defaults { 
    ],

    ],

    srcs: [

    srcs: [

        "RpcTransportTls.cpp",

        "RpcTransportTls.cpp",

        "RpcCertificateUtils.cpp",

    ],

    ],

}

}

libs/binder/RpcCertificateUtils.cpp

0 → 100644
+78 −0
Original line number Original line Diff line number Diff line 
/*

 * Copyright (C) 2021 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#define LOG_TAG "RpcCertificateUtils"

#include <log/log.h>



#include <binder/RpcCertificateUtils.h>



#include "Utils.h"



namespace android {



namespace {



bssl::UniquePtr<X509> fromPem(const std::vector<uint8_t>& cert) {

    if (cert.size() > std::numeric_limits<int>::max()) return nullptr;

    bssl::UniquePtr<BIO> certBio(BIO_new_mem_buf(cert.data(), static_cast<int>(cert.size())));

    return bssl::UniquePtr<X509>(PEM_read_bio_X509(certBio.get(), nullptr, nullptr, nullptr));

}



bssl::UniquePtr<X509> fromDer(const std::vector<uint8_t>& cert) {

    if (cert.size() > std::numeric_limits<long>::max()) return nullptr;

    const unsigned char* data = cert.data();

    auto expectedEnd = data + cert.size();

    bssl::UniquePtr<X509> ret(d2i_X509(nullptr, &data, static_cast<long>(cert.size())));

    if (data != expectedEnd) {

        ALOGE("%s: %td bytes remaining!", __PRETTY_FUNCTION__, expectedEnd - data);

        return nullptr;

    }

    return ret;

}



} // namespace



bssl::UniquePtr<X509> deserializeCertificate(const std::vector<uint8_t>& cert,

                                             RpcCertificateFormat format) {

    switch (format) {

        case RpcCertificateFormat::PEM:

            return fromPem(cert);

        case RpcCertificateFormat::DER:

            return fromDer(cert);

    }

    LOG_ALWAYS_FATAL("Unsupported format %d", static_cast<int>(format));

}



std::vector<uint8_t> serializeCertificate(X509* x509, RpcCertificateFormat format) {

    bssl::UniquePtr<BIO> certBio(BIO_new(BIO_s_mem()));

    switch (format) {

        case RpcCertificateFormat::PEM: {

            TEST_AND_RETURN({}, PEM_write_bio_X509(certBio.get(), x509));

        } break;

        case RpcCertificateFormat::DER: {

            TEST_AND_RETURN({}, i2d_X509_bio(certBio.get(), x509));

        } break;

        default: {

            LOG_ALWAYS_FATAL("Unsupported format %d", static_cast<int>(format));

        }

    }

    const uint8_t* data;

    size_t len;

    TEST_AND_RETURN({}, BIO_mem_contents(certBio.get(), &data, &len));

    return std::vector<uint8_t>(data, data + len);

}



} // namespace android

libs/binder/RpcServer.cpp

+1 −1
Original line number Original line Diff line number Diff line
@@ -141,7 +141,7 @@ sp<IBinder> RpcServer::getRootObject() { 
    return ret;

    return ret;

}

}





std::string RpcServer::getCertificate(CertificateFormat format) {

std::vector<uint8_t> RpcServer::getCertificate(RpcCertificateFormat format) {

    std::lock_guard<std::mutex> _l(mLock);

    std::lock_guard<std::mutex> _l(mLock);

    return mCtx->getCertificate(format);

    return mCtx->getCertificate(format);

}

}

libs/binder/RpcSession.cpp

+1 −1
Original line number Original line Diff line number Diff line
@@ -703,7 +703,7 @@ bool RpcSession::removeIncomingConnection(const sp<RpcConnection>& connection) { 
    return false;

    return false;

}

}





std::string RpcSession::getCertificate(CertificateFormat format) {

std::vector<uint8_t> RpcSession::getCertificate(RpcCertificateFormat format) {

    return mCtx->getCertificate(format);

    return mCtx->getCertificate(format);

}

}

libs/binder/RpcTransportRaw.cpp

+1 −1
Original line number Original line Diff line number Diff line
@@ -111,7 +111,7 @@ public: 
    std::unique_ptr<RpcTransport> newTransport(android::base::unique_fd fd, FdTrigger*) const {

    std::unique_ptr<RpcTransport> newTransport(android::base::unique_fd fd, FdTrigger*) const {

        return std::make_unique<RpcTransportRaw>(std::move(fd));

        return std::make_unique<RpcTransportRaw>(std::move(fd));

    }

    }

    std::string getCertificate(CertificateFormat) const override { return {}; }

    std::vector<uint8_t> getCertificate(RpcCertificateFormat) const override { return {}; }

};

};





} // namespace

} // namespace