server/dns/DnsTlsTransport.cpp - platform/system/netd - Git at Google

 /*
  * Copyright (C) 2017 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.
  */

 #include "dns/DnsTlsTransport.h"

 #include <algorithm>
 #include <iterator>
 #include <arpa/inet.h>
 #include <arpa/nameser.h>
 #include <errno.h>
 #include <openssl/err.h>
 #include <stdlib.h>

 #define LOG_TAG "DnsTlsTransport"
 #define DBG 0

 #include "log/log.h"
 #include "Fwmark.h"
 #undef ADD  // already defined in nameser.h
 #include "NetdConstants.h"
 #include "Permission.h"

 namespace {

 // Returns a tuple of references to the elements of a.
 auto make_tie(const sockaddr_in& a) {
     return std::tie(a.sin_port, a.sin_addr.s_addr);
 }

 // Returns a tuple of references to the elements of a.
 auto make_tie(const sockaddr_in6& a) {
     // Skip flowinfo, which is not relevant.
     return std::tie(
         a.sin6_port,
         a.sin6_addr,
         a.sin6_scope_id
     );
 }

 } // namespace

 // These binary operators make sockaddr_storage comparable.  They need to be
 // in the global namespace so that the std::tuple < and == operators can see them.
 static bool operator <(const in6_addr& x, const in6_addr& y) {
     return std::lexicographical_compare(
             std::begin(x.s6_addr), std::end(x.s6_addr),
             std::begin(y.s6_addr), std::end(y.s6_addr));
 }

 static bool operator ==(const in6_addr& x, const in6_addr& y) {
     return std::equal(
             std::begin(x.s6_addr), std::end(x.s6_addr),
             std::begin(y.s6_addr), std::end(y.s6_addr));
 }

 static bool operator <(const sockaddr_storage& x, const sockaddr_storage& y) {
     if (x.ss_family != y.ss_family) {
         return x.ss_family < y.ss_family;
     }
     // Same address family.
     if (x.ss_family == AF_INET) {
         const sockaddr_in& x_sin = reinterpret_cast<const sockaddr_in&>(x);
         const sockaddr_in& y_sin = reinterpret_cast<const sockaddr_in&>(y);
         return make_tie(x_sin) < make_tie(y_sin);
     } else if (x.ss_family == AF_INET6) {
         const sockaddr_in6& x_sin6 = reinterpret_cast<const sockaddr_in6&>(x);
         const sockaddr_in6& y_sin6 = reinterpret_cast<const sockaddr_in6&>(y);
         return make_tie(x_sin6) < make_tie(y_sin6);
     }
     return false;  // Unknown address type.  This is an error.
 }

 static bool operator ==(const sockaddr_storage& x, const sockaddr_storage& y) {
     if (x.ss_family != y.ss_family) {
         return false;
     }
     // Same address family.
     if (x.ss_family == AF_INET) {
         const sockaddr_in& x_sin = reinterpret_cast<const sockaddr_in&>(x);
         const sockaddr_in& y_sin = reinterpret_cast<const sockaddr_in&>(y);
         return make_tie(x_sin) == make_tie(y_sin);
     } else if (x.ss_family == AF_INET6) {
         const sockaddr_in6& x_sin6 = reinterpret_cast<const sockaddr_in6&>(x);
         const sockaddr_in6& y_sin6 = reinterpret_cast<const sockaddr_in6&>(y);
         return make_tie(x_sin6) == make_tie(y_sin6);
     }
     return false;  // Unknown address type.  This is an error.
 }

 namespace android {
 namespace net {

 namespace {

 bool setNonBlocking(int fd, bool enabled) {
     int flags = fcntl(fd, F_GETFL);
     if (flags < 0) return false;

     if (enabled) {
         flags |= O_NONBLOCK;
     } else {
         flags &= ~O_NONBLOCK;
     }
     return (fcntl(fd, F_SETFL, flags) == 0);
 }

 int waitForReading(int fd) {
     fd_set fds;
     FD_ZERO(&fds);
     FD_SET(fd, &fds);
     const int ret = TEMP_FAILURE_RETRY(select(fd + 1, &fds, nullptr, nullptr, nullptr));
     if (DBG && ret <= 0) {
         ALOGD("select");
     }
     return ret;
 }

 int waitForWriting(int fd) {
     fd_set fds;
     FD_ZERO(&fds);
     FD_SET(fd, &fds);
     const int ret = TEMP_FAILURE_RETRY(select(fd + 1, nullptr, &fds, nullptr, nullptr));
     if (DBG && ret <= 0) {
         ALOGD("select");
     }
     return ret;
 }

 }  // namespace

 android::base::unique_fd DnsTlsTransport::makeConnectedSocket() const {
     if (DBG) {
         ALOGD("%u connecting TCP socket", mMark);
     }
     android::base::unique_fd fd;
     int type = SOCK_NONBLOCK | SOCK_CLOEXEC;
     switch (mServer.protocol) {
         case IPPROTO_TCP:
             type |= SOCK_STREAM;
             break;
         default:
             errno = EPROTONOSUPPORT;
             return fd;
     }

     fd.reset(socket(mServer.ss.ss_family, type, mServer.protocol));
     if (fd.get() == -1) {
         return fd;
     }

     const socklen_t len = sizeof(mMark);
     if (setsockopt(fd.get(), SOL_SOCKET, SO_MARK, &mMark, len) == -1) {
         fd.reset();
     } else if (connect(fd.get(),
             reinterpret_cast<const struct sockaddr *>(&mServer.ss), sizeof(mServer.ss)) != 0
         && errno != EINPROGRESS) {
         fd.reset();
     }

     if (!setNonBlocking(fd, false)) {
         ALOGE("Failed to disable nonblocking status on DNS-over-TLS fd");
         fd.reset();
     }

     return fd;
 }

 bool getSPKIDigest(const X509* cert, std::vector<uint8_t>* out) {
     int spki_len = i2d_X509_PUBKEY(X509_get_X509_PUBKEY(cert), NULL);
     unsigned char spki[spki_len];
     unsigned char* temp = spki;
     if (spki_len != i2d_X509_PUBKEY(X509_get_X509_PUBKEY(cert), &temp)) {
         ALOGW("SPKI length mismatch");
         return false;
     }
     out->resize(SHA256_SIZE);
     unsigned int digest_len = 0;
     int ret = EVP_Digest(spki, spki_len, out->data(), &digest_len, EVP_sha256(), NULL);
     if (ret != 1) {
         ALOGW("Server cert digest extraction failed");
         return false;
     }
     if (digest_len != out->size()) {
         ALOGW("Wrong digest length: %d", digest_len);
         return false;
     }
     return true;
 }

 // This comparison ignores ports and fingerprints.
 // TODO: respect IPv6 scope id (e.g. link-local addresses).
 bool AddressComparator::operator() (const DnsTlsTransport::Server& x,
         const DnsTlsTransport::Server& y) const {
     if (x.ss.ss_family != y.ss.ss_family) {
         return x.ss.ss_family < y.ss.ss_family;
     }
     // Same address family.
     if (x.ss.ss_family == AF_INET) {
         const sockaddr_in& x_sin = reinterpret_cast<const sockaddr_in&>(x.ss);
         const sockaddr_in& y_sin = reinterpret_cast<const sockaddr_in&>(y.ss);
         return x_sin.sin_addr.s_addr < y_sin.sin_addr.s_addr;
     } else if (x.ss.ss_family == AF_INET6) {
         const sockaddr_in6& x_sin6 = reinterpret_cast<const sockaddr_in6&>(x.ss);
         const sockaddr_in6& y_sin6 = reinterpret_cast<const sockaddr_in6&>(y.ss);
         return x_sin6.sin6_addr < y_sin6.sin6_addr;
     }
     return false;  // Unknown address type.  This is an error.
 }

 // Returns a tuple of references to the elements of s.
 auto make_tie(const DnsTlsTransport::Server& s) {
     return std::tie(
         s.ss,
         s.name,
         s.fingerprints,
         s.protocol
     );
 }

 bool DnsTlsTransport::Server::operator <(const DnsTlsTransport::Server& other) const {
     return make_tie(*this) < make_tie(other);
 }

 bool DnsTlsTransport::Server::operator ==(const DnsTlsTransport::Server& other) const {
     return make_tie(*this) == make_tie(other);
 }

 bool DnsTlsTransport::initialize() {
     mSslCtx.reset(SSL_CTX_new(TLS_method()));
     if (!mSslCtx) {
         return false;
     }
     SSL_CTX_sess_set_new_cb(mSslCtx.get(), DnsTlsTransport::newSessionCallback);
     SSL_CTX_sess_set_remove_cb(mSslCtx.get(), DnsTlsTransport::removeSessionCallback);
     return true;
 }

 bssl::UniquePtr<SSL> DnsTlsTransport::sslConnect(int fd) {
     // Check TLS context.
     if (!mSslCtx) {
         ALOGE("Internal error: context is null in ssl connect");
         return nullptr;
     }
     if (!SSL_CTX_set_max_proto_version(mSslCtx.get(), TLS1_3_VERSION) ||
         !SSL_CTX_set_min_proto_version(mSslCtx.get(), TLS1_2_VERSION)) {
         ALOGE("failed to min/max TLS versions");
         return nullptr;
     }

     bssl::UniquePtr<SSL> ssl(SSL_new(mSslCtx.get()));
     // This file descriptor is owned by a unique_fd, so don't let libssl close it.
     bssl::UniquePtr<BIO> bio(BIO_new_socket(fd, BIO_NOCLOSE));
     SSL_set_bio(ssl.get(), bio.get(), bio.get());
     bio.release();

     // Add this transport as the 0-index extra data for the socket.
     // This is used by newSessionCallback.
     if (SSL_set_ex_data(ssl.get(), 0, this) != 1) {
         ALOGE("failed to associate SSL socket to transport");
         return nullptr;
     }

     // Add this transport as the 0-index extra data for the context.
     // This is used by removeSessionCallback.
     if (SSL_CTX_set_ex_data(mSslCtx.get(), 0, this) != 1) {
         ALOGE("failed to associate SSL context to transport");
         return nullptr;
     }

     if (!mServer.name.empty()) {
         if (SSL_set_tlsext_host_name(ssl.get(), mServer.name.c_str()) != 1) {
             ALOGE("Failed to set SNI to %s", mServer.name.c_str());
             return nullptr;
         }
         X509_VERIFY_PARAM* param = SSL_get0_param(ssl.get());
         X509_VERIFY_PARAM_set1_host(param, mServer.name.c_str(), 0);
         // This will cause the handshake to fail if certificate verification fails.
         SSL_set_verify(ssl.get(), SSL_VERIFY_PEER, nullptr);
     }

     bssl::UniquePtr<SSL_SESSION> session;
     {
         std::lock_guard<std::mutex> guard(sLock);
         if (!mSessions.empty()) {
             session = std::move(mSessions.front());
             mSessions.pop_front();
         } else if (DBG) {
             ALOGD("Starting without session ticket.");
         }
     }
     if (session) {
         SSL_set_session(ssl.get(), session.get());
     }

     for (;;) {
         if (DBG) {
             ALOGD("%u Calling SSL_connect", mMark);
         }
         int ret = SSL_connect(ssl.get());
         if (DBG) {
             ALOGD("%u SSL_connect returned %d", mMark, ret);
         }
         if (ret == 1) break;  // SSL handshake complete;

         const int ssl_err = SSL_get_error(ssl.get(), ret);
         switch (ssl_err) {
             case SSL_ERROR_WANT_READ:
                 if (waitForReading(fd) != 1) {
                     ALOGW("SSL_connect read error");
                     return nullptr;
                 }
                 break;
             case SSL_ERROR_WANT_WRITE:
                 if (waitForWriting(fd) != 1) {
                     ALOGW("SSL_connect write error");
                     return nullptr;
                 }
                 break;
             default:
                 ALOGW("SSL_connect error %d, errno=%d", ssl_err, errno);
                 return nullptr;
         }
     }

     if (!mServer.fingerprints.empty()) {
         if (DBG) {
             ALOGD("Checking DNS over TLS fingerprint");
         }

         // We only care that the chain is internally self-consistent, not that
         // it chains to a trusted root, so we can ignore some kinds of errors.
         // TODO: Add a CA root verification mode that respects these errors.
         int verify_result = SSL_get_verify_result(ssl.get());
         switch (verify_result) {
             case X509_V_OK:
             case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
             case X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN:
             case X509_V_ERR_CERT_UNTRUSTED:
                 break;
             default:
                 ALOGW("Invalid certificate chain, error %d", verify_result);
                 return nullptr;
         }

         STACK_OF(X509) *chain = SSL_get_peer_cert_chain(ssl.get());
         if (!chain) {
             ALOGW("Server has null certificate");
             return nullptr;
         }
         // Chain and its contents are owned by ssl, so we don't need to free explicitly.
         bool matched = false;
         for (size_t i = 0; i < sk_X509_num(chain); ++i) {
             // This appears to be O(N^2), but there doesn't seem to be a straightforward
             // way to walk a STACK_OF nondestructively in linear time.
             X509* cert = sk_X509_value(chain, i);
             std::vector<uint8_t> digest;
             if (!getSPKIDigest(cert, &digest)) {
                 ALOGE("Digest computation failed");
                 return nullptr;
             }

             if (mServer.fingerprints.count(digest) > 0) {
                 matched = true;
                 break;
             }
         }

         if (!matched) {
             ALOGW("No matching fingerprint");
             return nullptr;
         }

         if (DBG) {
             ALOGD("DNS over TLS fingerprint is correct");
         }
     }

     if (DBG) {
         ALOGD("%u handshake complete", mMark);
     }

     return ssl;
 }

 // static
 int DnsTlsTransport::newSessionCallback(SSL* ssl, SSL_SESSION* session) {
     if (!session) {
         return 0;
     }
     if (DBG) {
         ALOGD("Recording session ticket");
     }
     DnsTlsTransport* xport = reinterpret_cast<DnsTlsTransport*>(
             SSL_get_ex_data(ssl, 0));
     if (!xport) {
         ALOGE("null transport in new session callback");
         return 0;
     }
     xport->recordSession(session);
     return 1;
 }

 void DnsTlsTransport::removeSessionCallback(SSL_CTX* ssl_ctx, SSL_SESSION* session) {
     if (DBG) {
         ALOGD("Removing session ticket");
     }
     DnsTlsTransport* xport = reinterpret_cast<DnsTlsTransport*>(
             SSL_CTX_get_ex_data(ssl_ctx, 0));
     if (!xport) {
         ALOGE("null transport in remove session callback");
         return;
     }
     xport->removeSession(session);
 }

 void DnsTlsTransport::recordSession(SSL_SESSION* session) {
     std::lock_guard<std::mutex> guard(sLock);
     mSessions.emplace_front(session);
     if (mSessions.size() > 5) {
         if (DBG) {
             ALOGD("Too many sessions; trimming");
         }
         mSessions.pop_back();
     }
 }

 void DnsTlsTransport::removeSession(SSL_SESSION* session) {
     std::lock_guard<std::mutex> guard(sLock);
     if (session) {
         // TODO: Consider implementing targeted removal.
         mSessions.clear();
     }
 }

 void DnsTlsTransport::sslDisconnect(bssl::UniquePtr<SSL> ssl, base::unique_fd fd) {
     if (ssl) {
         SSL_shutdown(ssl.get());
         ssl.reset();
     }
     fd.reset();
 }

 bool DnsTlsTransport::sslWrite(int fd, SSL *ssl, const uint8_t *buffer, int len) {
     if (DBG) {
         ALOGD("%u Writing %d bytes", mMark, len);
     }
     for (;;) {
         int ret = SSL_write(ssl, buffer, len);
         if (ret == len) break;  // SSL write complete;

         if (ret < 1) {
             const int ssl_err = SSL_get_error(ssl, ret);
             switch (ssl_err) {
                 case SSL_ERROR_WANT_WRITE:
                     if (waitForWriting(fd) != 1) {
                         if (DBG) {
                             ALOGW("SSL_write error");
                         }
                         return false;
                     }
                     continue;
                 case 0:
                     break;  // SSL write complete;
                 default:
                     if (DBG) {
                         ALOGW("SSL_write error %d", ssl_err);
                     }
                     return false;
             }
         }
     }
     if (DBG) {
         ALOGD("%u Wrote %d bytes", mMark, len);
     }
     return true;
 }

 // Read exactly len bytes into buffer or fail
 bool DnsTlsTransport::sslRead(int fd, SSL *ssl, uint8_t *buffer, int len) {
     int remaining = len;
     while (remaining > 0) {
         int ret = SSL_read(ssl, buffer + (len - remaining), remaining);
         if (ret == 0) {
             ALOGE("SSL socket closed with %i of %i bytes remaining", remaining, len);
             return false;
         }

         if (ret < 0) {
             const int ssl_err = SSL_get_error(ssl, ret);
             if (ssl_err == SSL_ERROR_WANT_READ) {
                 if (waitForReading(fd) != 1) {
                     if (DBG) {
                         ALOGW("SSL_read error");
                     }
                     return false;
                 }
                 continue;
             } else {
                 if (DBG) {
                     ALOGW("SSL_read error %d", ssl_err);
                 }
                 return false;
             }
         }

         remaining -= ret;
     }
     return true;
 }

 // static
 std::mutex DnsTlsTransport::sLock;
 std::map<DnsTlsTransport::Key, std::unique_ptr<DnsTlsTransport>> DnsTlsTransport::sStore;
 DnsTlsTransport::Response DnsTlsTransport::query(const Server& server, unsigned mark,
         const uint8_t *query, size_t qlen, uint8_t *response, size_t limit, int *resplen) {
     const Key key = std::make_pair(mark, server);
     DnsTlsTransport* xport;
     {
         std::lock_guard<std::mutex> guard(sLock);
         auto it = sStore.find(key);
         if (it == sStore.end()) {
             xport = new DnsTlsTransport(server, mark);
             if (!xport->initialize()) {
                 return DnsTlsTransport::Response::internal_error;
             }
             sStore[key].reset(xport);
         } else {
             xport = it->second.get();
         }
         ++xport->mUseCount;
     }

     Response res = xport->doQuery(query, qlen, response, limit, resplen);
     auto now = std::chrono::steady_clock::now();
     {
         std::lock_guard<std::mutex> guard(sLock);
         --xport->mUseCount;
         xport->mLastUsed = now;
         cleanup(now);
     }
     return res;
 }

 static constexpr std::chrono::minutes IDLE_TIMEOUT(5);
 std::chrono::time_point<std::chrono::steady_clock> DnsTlsTransport::sLastCleanup;
 void DnsTlsTransport::cleanup(std::chrono::time_point<std::chrono::steady_clock> now) {
     if (now - sLastCleanup < IDLE_TIMEOUT) {
         return;
     }
     for (auto it = sStore.begin(); it != sStore.end(); ) {
         auto& xport = it->second;
         if (xport->mUseCount == 0 && now - xport->mLastUsed > IDLE_TIMEOUT) {
             it = sStore.erase(it);
         } else {
             ++it;
         }
     }
     sLastCleanup = now;
 }

 DnsTlsTransport::Response DnsTlsTransport::doQuery(const uint8_t *query, size_t qlen,
         uint8_t *response, size_t limit, int *resplen) {
     android::base::unique_fd fd = makeConnectedSocket();
     if (fd.get() < 0) {
         ALOGD("%u makeConnectedSocket() failed with: %s", mMark, strerror(errno));
         return Response::network_error;
     }
     bssl::UniquePtr<SSL> ssl = sslConnect(fd.get());
     if (!ssl) {
         return Response::network_error;
     }

     Response res = sendQuery(fd.get(), ssl.get(), query, qlen);
     if (res == Response::success) {
         res = readResponse(fd.get(), ssl.get(), query, response, limit, resplen);
     }

     sslDisconnect(std::move(ssl), std::move(fd));
     return res;
 }

 DnsTlsTransport::Response DnsTlsTransport::sendQuery(int fd, SSL* ssl, const uint8_t *query, size_t qlen) {
     if (DBG) {
         ALOGD("sending query");
     }
     uint8_t queryHeader[2];
     queryHeader[0] = qlen >> 8;
     queryHeader[1] = qlen;
     if (!sslWrite(fd, ssl, queryHeader, 2)) {
         return Response::network_error;
     }
     if (!sslWrite(fd, ssl, query, qlen)) {
         return Response::network_error;
     }
     if (DBG) {
         ALOGD("%u SSL_write complete", mMark);
     }
     return Response::success;
 }

 DnsTlsTransport::Response DnsTlsTransport::readResponse(int fd, SSL* ssl, const uint8_t *query, uint8_t *response, size_t limit, int *resplen) {
     if (DBG) {
         ALOGD("reading response");
     }
     uint8_t responseHeader[2];
     if (!sslRead(fd, ssl, responseHeader, 2)) {
         if (DBG) {
             ALOGW("%u Failed to read 2-byte length header", mMark);
         }
         return Response::network_error;
     }
     const uint16_t responseSize = (responseHeader[0] << 8) | responseHeader[1];
     if (DBG) {
         ALOGD("%u Expecting response of size %i", mMark, responseSize);
     }
     if (responseSize > limit) {
         ALOGE("%u Response doesn't fit in output buffer: %i", mMark, responseSize);
         return Response::limit_error;
     }
     if (!sslRead(fd, ssl, response, responseSize)) {
         if (DBG) {
             ALOGW("%u Failed to read %i bytes", mMark, responseSize);
         }
         return Response::network_error;
     }
     if (DBG) {
         ALOGD("%u SSL_read complete", mMark);
     }

     if (response[0] != query[0] || response[1] != query[1]) {
         ALOGE("reply query ID != query ID");
         return Response::internal_error;
     }

     *resplen = responseSize;
     return Response::success;
 }

 // static
 bool DnsTlsTransport::validate(const Server& server, unsigned netid) {
     if (DBG) {
         ALOGD("Beginning validation on %u", netid);
     }
     // Generate "<random>-dnsotls-ds.metric.gstatic.com", which we will lookup through |ss| in
     // order to prove that it is actually a working DNS over TLS server.
     static const char kDnsSafeChars[] =
             "abcdefhijklmnopqrstuvwxyz"
             "ABCDEFHIJKLMNOPQRSTUVWXYZ"
             "0123456789";
     const auto c = [](uint8_t rnd) -> uint8_t {
         return kDnsSafeChars[(rnd % ARRAY_SIZE(kDnsSafeChars))];
     };
     uint8_t rnd[8];
     arc4random_buf(rnd, ARRAY_SIZE(rnd));
     // We could try to use res_mkquery() here, but it's basically the same.
     uint8_t query[] = {
         rnd[6], rnd[7],  // [0-1]   query ID
         1, 0,  // [2-3]   flags; query[2] = 1 for recursion desired (RD).
         0, 1,  // [4-5]   QDCOUNT (number of queries)
         0, 0,  // [6-7]   ANCOUNT (number of answers)
         0, 0,  // [8-9]   NSCOUNT (number of name server records)
         0, 0,  // [10-11] ARCOUNT (number of additional records)
         17, c(rnd[0]), c(rnd[1]), c(rnd[2]), c(rnd[3]), c(rnd[4]), c(rnd[5]),
             '-', 'd', 'n', 's', 'o', 't', 'l', 's', '-', 'd', 's',
         6, 'm', 'e', 't', 'r', 'i', 'c',
         7, 'g', 's', 't', 'a', 't', 'i', 'c',
         3, 'c', 'o', 'm',
         0,  // null terminator of FQDN (root TLD)
         0, ns_t_aaaa,  // QTYPE
         0, ns_c_in     // QCLASS
     };
     const int qlen = ARRAY_SIZE(query);

     const int kRecvBufSize = 4 * 1024;
     uint8_t recvbuf[kRecvBufSize];

     // At validation time, we only know the netId, so we have to guess/compute the
     // corresponding socket mark.
     Fwmark fwmark;
     fwmark.permission = PERMISSION_SYSTEM;
     fwmark.explicitlySelected = true;
     fwmark.protectedFromVpn = true;
     fwmark.netId = netid;
     unsigned mark = fwmark.intValue;
     int replylen = 0;
     DnsTlsTransport::query(server, mark, query, qlen, recvbuf, kRecvBufSize, &replylen);
     if (replylen == 0) {
         if (DBG) {
             ALOGD("query failed");
         }
         return false;
     }

     if (replylen < NS_HFIXEDSZ) {
         if (DBG) {
             ALOGW("short response: %d", replylen);
         }
         return false;
     }

     const int qdcount = (recvbuf[4] << 8) | recvbuf[5];
     if (qdcount != 1) {
         ALOGW("reply query count != 1: %d", qdcount);
         return false;
     }

     const int ancount = (recvbuf[6] << 8) | recvbuf[7];
     if (DBG) {
         ALOGD("%u answer count: %d", netid, ancount);
     }

     // TODO: Further validate the response contents (check for valid AAAA record, ...).
     // Note that currently, integration tests rely on this function accepting a
     // response with zero records.
 #if 0
     for (int i = 0; i < resplen; i++) {
         ALOGD("recvbuf[%d] = %d %c", i, recvbuf[i], recvbuf[i]);
     }
 #endif
     return true;
 }

 }  // namespace net
 }  // namespace android
	/*
	* Copyright (C) 2017 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.
	*/

	#include "dns/DnsTlsTransport.h"

	#include <algorithm>
	#include <iterator>
	#include <arpa/inet.h>
	#include <arpa/nameser.h>
	#include <errno.h>
	#include <openssl/err.h>
	#include <stdlib.h>

	#define LOG_TAG "DnsTlsTransport"
	#define DBG 0

	#include "log/log.h"
	#include "Fwmark.h"
	#undef ADD // already defined in nameser.h
	#include "NetdConstants.h"
	#include "Permission.h"

	namespace {

	// Returns a tuple of references to the elements of a.
	auto make_tie(const sockaddr_in& a) {
	return std::tie(a.sin_port, a.sin_addr.s_addr);
	}

	// Returns a tuple of references to the elements of a.
	auto make_tie(const sockaddr_in6& a) {
	// Skip flowinfo, which is not relevant.
	return std::tie(
	a.sin6_port,
	a.sin6_addr,
	a.sin6_scope_id
	);
	}

	} // namespace

	// These binary operators make sockaddr_storage comparable. They need to be
	// in the global namespace so that the std::tuple < and == operators can see them.
	static bool operator <(const in6_addr& x, const in6_addr& y) {
	return std::lexicographical_compare(
	std::begin(x.s6_addr), std::end(x.s6_addr),
	std::begin(y.s6_addr), std::end(y.s6_addr));
	}

	static bool operator ==(const in6_addr& x, const in6_addr& y) {
	return std::equal(
	std::begin(x.s6_addr), std::end(x.s6_addr),
	std::begin(y.s6_addr), std::end(y.s6_addr));
	}

	static bool operator <(const sockaddr_storage& x, const sockaddr_storage& y) {
	if (x.ss_family != y.ss_family) {
	return x.ss_family < y.ss_family;
	}
	// Same address family.
	if (x.ss_family == AF_INET) {
	const sockaddr_in& x_sin = reinterpret_cast<const sockaddr_in&>(x);
	const sockaddr_in& y_sin = reinterpret_cast<const sockaddr_in&>(y);
	return make_tie(x_sin) < make_tie(y_sin);
	} else if (x.ss_family == AF_INET6) {
	const sockaddr_in6& x_sin6 = reinterpret_cast<const sockaddr_in6&>(x);
	const sockaddr_in6& y_sin6 = reinterpret_cast<const sockaddr_in6&>(y);
	return make_tie(x_sin6) < make_tie(y_sin6);
	}
	return false; // Unknown address type. This is an error.
	}

	static bool operator ==(const sockaddr_storage& x, const sockaddr_storage& y) {
	if (x.ss_family != y.ss_family) {
	return false;
	}
	// Same address family.
	if (x.ss_family == AF_INET) {
	const sockaddr_in& x_sin = reinterpret_cast<const sockaddr_in&>(x);
	const sockaddr_in& y_sin = reinterpret_cast<const sockaddr_in&>(y);
	return make_tie(x_sin) == make_tie(y_sin);
	} else if (x.ss_family == AF_INET6) {
	const sockaddr_in6& x_sin6 = reinterpret_cast<const sockaddr_in6&>(x);
	const sockaddr_in6& y_sin6 = reinterpret_cast<const sockaddr_in6&>(y);
	return make_tie(x_sin6) == make_tie(y_sin6);
	}
	return false; // Unknown address type. This is an error.
	}

	namespace android {
	namespace net {

	namespace {

	bool setNonBlocking(int fd, bool enabled) {
	int flags = fcntl(fd, F_GETFL);
	if (flags < 0) return false;

	if (enabled) {
	flags \|= O_NONBLOCK;
	} else {
	flags &= ~O_NONBLOCK;
	}
	return (fcntl(fd, F_SETFL, flags) == 0);
	}

	int waitForReading(int fd) {
	fd_set fds;
	FD_ZERO(&fds);
	FD_SET(fd, &fds);
	const int ret = TEMP_FAILURE_RETRY(select(fd + 1, &fds, nullptr, nullptr, nullptr));
	if (DBG && ret <= 0) {
	ALOGD("select");
	}
	return ret;
	}

	int waitForWriting(int fd) {
	fd_set fds;
	FD_ZERO(&fds);
	FD_SET(fd, &fds);
	const int ret = TEMP_FAILURE_RETRY(select(fd + 1, nullptr, &fds, nullptr, nullptr));
	if (DBG && ret <= 0) {
	ALOGD("select");
	}
	return ret;
	}

	} // namespace

	android::base::unique_fd DnsTlsTransport::makeConnectedSocket() const {
	if (DBG) {
	ALOGD("%u connecting TCP socket", mMark);
	}
	android::base::unique_fd fd;
	int type = SOCK_NONBLOCK \| SOCK_CLOEXEC;
	switch (mServer.protocol) {
	case IPPROTO_TCP:
	type \|= SOCK_STREAM;
	break;
	default:
	errno = EPROTONOSUPPORT;
	return fd;
	}

	fd.reset(socket(mServer.ss.ss_family, type, mServer.protocol));
	if (fd.get() == -1) {
	return fd;
	}

	const socklen_t len = sizeof(mMark);
	if (setsockopt(fd.get(), SOL_SOCKET, SO_MARK, &mMark, len) == -1) {
	fd.reset();
	} else if (connect(fd.get(),
	reinterpret_cast<const struct sockaddr *>(&mServer.ss), sizeof(mServer.ss)) != 0
	&& errno != EINPROGRESS) {
	fd.reset();
	}

	if (!setNonBlocking(fd, false)) {
	ALOGE("Failed to disable nonblocking status on DNS-over-TLS fd");
	fd.reset();
	}

	return fd;
	}

	bool getSPKIDigest(const X509* cert, std::vector<uint8_t>* out) {
	int spki_len = i2d_X509_PUBKEY(X509_get_X509_PUBKEY(cert), NULL);
	unsigned char spki[spki_len];
	unsigned char* temp = spki;
	if (spki_len != i2d_X509_PUBKEY(X509_get_X509_PUBKEY(cert), &temp)) {
	ALOGW("SPKI length mismatch");
	return false;
	}
	out->resize(SHA256_SIZE);
	unsigned int digest_len = 0;
	int ret = EVP_Digest(spki, spki_len, out->data(), &digest_len, EVP_sha256(), NULL);
	if (ret != 1) {
	ALOGW("Server cert digest extraction failed");
	return false;
	}
	if (digest_len != out->size()) {
	ALOGW("Wrong digest length: %d", digest_len);
	return false;
	}
	return true;
	}

	// This comparison ignores ports and fingerprints.
	// TODO: respect IPv6 scope id (e.g. link-local addresses).
	bool AddressComparator::operator() (const DnsTlsTransport::Server& x,
	const DnsTlsTransport::Server& y) const {
	if (x.ss.ss_family != y.ss.ss_family) {
	return x.ss.ss_family < y.ss.ss_family;
	}
	// Same address family.
	if (x.ss.ss_family == AF_INET) {
	const sockaddr_in& x_sin = reinterpret_cast<const sockaddr_in&>(x.ss);
	const sockaddr_in& y_sin = reinterpret_cast<const sockaddr_in&>(y.ss);
	return x_sin.sin_addr.s_addr < y_sin.sin_addr.s_addr;
	} else if (x.ss.ss_family == AF_INET6) {
	const sockaddr_in6& x_sin6 = reinterpret_cast<const sockaddr_in6&>(x.ss);
	const sockaddr_in6& y_sin6 = reinterpret_cast<const sockaddr_in6&>(y.ss);
	return x_sin6.sin6_addr < y_sin6.sin6_addr;
	}
	return false; // Unknown address type. This is an error.
	}

	// Returns a tuple of references to the elements of s.
	auto make_tie(const DnsTlsTransport::Server& s) {
	return std::tie(
	s.ss,
	s.name,
	s.fingerprints,
	s.protocol
	);
	}

	bool DnsTlsTransport::Server::operator <(const DnsTlsTransport::Server& other) const {
	return make_tie(*this) < make_tie(other);
	}

	bool DnsTlsTransport::Server::operator ==(const DnsTlsTransport::Server& other) const {
	return make_tie(*this) == make_tie(other);
	}

	bool DnsTlsTransport::initialize() {
	mSslCtx.reset(SSL_CTX_new(TLS_method()));
	if (!mSslCtx) {
	return false;
	}
	SSL_CTX_sess_set_new_cb(mSslCtx.get(), DnsTlsTransport::newSessionCallback);
	SSL_CTX_sess_set_remove_cb(mSslCtx.get(), DnsTlsTransport::removeSessionCallback);
	return true;
	}

	bssl::UniquePtr<SSL> DnsTlsTransport::sslConnect(int fd) {
	// Check TLS context.
	if (!mSslCtx) {
	ALOGE("Internal error: context is null in ssl connect");
	return nullptr;
	}
	if (!SSL_CTX_set_max_proto_version(mSslCtx.get(), TLS1_3_VERSION) \|\|
	!SSL_CTX_set_min_proto_version(mSslCtx.get(), TLS1_2_VERSION)) {
	ALOGE("failed to min/max TLS versions");
	return nullptr;
	}

	bssl::UniquePtr<SSL> ssl(SSL_new(mSslCtx.get()));
	// This file descriptor is owned by a unique_fd, so don't let libssl close it.
	bssl::UniquePtr<BIO> bio(BIO_new_socket(fd, BIO_NOCLOSE));
	SSL_set_bio(ssl.get(), bio.get(), bio.get());
	bio.release();

	// Add this transport as the 0-index extra data for the socket.
	// This is used by newSessionCallback.
	if (SSL_set_ex_data(ssl.get(), 0, this) != 1) {
	ALOGE("failed to associate SSL socket to transport");
	return nullptr;
	}

	// Add this transport as the 0-index extra data for the context.
	// This is used by removeSessionCallback.
	if (SSL_CTX_set_ex_data(mSslCtx.get(), 0, this) != 1) {
	ALOGE("failed to associate SSL context to transport");
	return nullptr;
	}

	if (!mServer.name.empty()) {
	if (SSL_set_tlsext_host_name(ssl.get(), mServer.name.c_str()) != 1) {
	ALOGE("Failed to set SNI to %s", mServer.name.c_str());
	return nullptr;
	}
	X509_VERIFY_PARAM* param = SSL_get0_param(ssl.get());
	X509_VERIFY_PARAM_set1_host(param, mServer.name.c_str(), 0);
	// This will cause the handshake to fail if certificate verification fails.
	SSL_set_verify(ssl.get(), SSL_VERIFY_PEER, nullptr);
	}

	bssl::UniquePtr<SSL_SESSION> session;
	{
	std::lock_guard<std::mutex> guard(sLock);
	if (!mSessions.empty()) {
	session = std::move(mSessions.front());
	mSessions.pop_front();
	} else if (DBG) {
	ALOGD("Starting without session ticket.");
	}
	}
	if (session) {
	SSL_set_session(ssl.get(), session.get());
	}

	for (;;) {
	if (DBG) {
	ALOGD("%u Calling SSL_connect", mMark);
	}
	int ret = SSL_connect(ssl.get());
	if (DBG) {
	ALOGD("%u SSL_connect returned %d", mMark, ret);
	}
	if (ret == 1) break; // SSL handshake complete;

	const int ssl_err = SSL_get_error(ssl.get(), ret);
	switch (ssl_err) {
	case SSL_ERROR_WANT_READ:
	if (waitForReading(fd) != 1) {
	ALOGW("SSL_connect read error");
	return nullptr;
	}
	break;
	case SSL_ERROR_WANT_WRITE:
	if (waitForWriting(fd) != 1) {
	ALOGW("SSL_connect write error");
	return nullptr;
	}
	break;
	default:
	ALOGW("SSL_connect error %d, errno=%d", ssl_err, errno);
	return nullptr;
	}
	}

	if (!mServer.fingerprints.empty()) {
	if (DBG) {
	ALOGD("Checking DNS over TLS fingerprint");
	}

	// We only care that the chain is internally self-consistent, not that
	// it chains to a trusted root, so we can ignore some kinds of errors.
	// TODO: Add a CA root verification mode that respects these errors.
	int verify_result = SSL_get_verify_result(ssl.get());
	switch (verify_result) {
	case X509_V_OK:
	case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
	case X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN:
	case X509_V_ERR_CERT_UNTRUSTED:
	break;
	default:
	ALOGW("Invalid certificate chain, error %d", verify_result);
	return nullptr;
	}

	STACK_OF(X509) *chain = SSL_get_peer_cert_chain(ssl.get());
	if (!chain) {
	ALOGW("Server has null certificate");
	return nullptr;
	}
	// Chain and its contents are owned by ssl, so we don't need to free explicitly.
	bool matched = false;
	for (size_t i = 0; i < sk_X509_num(chain); ++i) {
	// This appears to be O(N^2), but there doesn't seem to be a straightforward
	// way to walk a STACK_OF nondestructively in linear time.
	X509* cert = sk_X509_value(chain, i);
	std::vector<uint8_t> digest;
	if (!getSPKIDigest(cert, &digest)) {
	ALOGE("Digest computation failed");
	return nullptr;
	}

	if (mServer.fingerprints.count(digest) > 0) {
	matched = true;
	break;
	}
	}

	if (!matched) {
	ALOGW("No matching fingerprint");
	return nullptr;
	}

	if (DBG) {
	ALOGD("DNS over TLS fingerprint is correct");
	}
	}

	if (DBG) {
	ALOGD("%u handshake complete", mMark);
	}

	return ssl;
	}

	// static
	int DnsTlsTransport::newSessionCallback(SSL* ssl, SSL_SESSION* session) {
	if (!session) {
	return 0;
	}
	if (DBG) {
	ALOGD("Recording session ticket");
	}
	DnsTlsTransport* xport = reinterpret_cast<DnsTlsTransport*>(
	SSL_get_ex_data(ssl, 0));
	if (!xport) {
	ALOGE("null transport in new session callback");
	return 0;
	}
	xport->recordSession(session);
	return 1;
	}

	void DnsTlsTransport::removeSessionCallback(SSL_CTX* ssl_ctx, SSL_SESSION* session) {
	if (DBG) {
	ALOGD("Removing session ticket");
	}
	DnsTlsTransport* xport = reinterpret_cast<DnsTlsTransport*>(
	SSL_CTX_get_ex_data(ssl_ctx, 0));
	if (!xport) {
	ALOGE("null transport in remove session callback");
	return;
	}
	xport->removeSession(session);
	}

	void DnsTlsTransport::recordSession(SSL_SESSION* session) {
	std::lock_guard<std::mutex> guard(sLock);
	mSessions.emplace_front(session);
	if (mSessions.size() > 5) {
	if (DBG) {
	ALOGD("Too many sessions; trimming");
	}
	mSessions.pop_back();
	}
	}

	void DnsTlsTransport::removeSession(SSL_SESSION* session) {
	std::lock_guard<std::mutex> guard(sLock);
	if (session) {
	// TODO: Consider implementing targeted removal.
	mSessions.clear();
	}
	}

	void DnsTlsTransport::sslDisconnect(bssl::UniquePtr<SSL> ssl, base::unique_fd fd) {
	if (ssl) {
	SSL_shutdown(ssl.get());
	ssl.reset();
	}
	fd.reset();
	}

	bool DnsTlsTransport::sslWrite(int fd, SSL ssl, const uint8_t buffer, int len) {
	if (DBG) {
	ALOGD("%u Writing %d bytes", mMark, len);
	}
	for (;;) {
	int ret = SSL_write(ssl, buffer, len);
	if (ret == len) break; // SSL write complete;

	if (ret < 1) {
	const int ssl_err = SSL_get_error(ssl, ret);
	switch (ssl_err) {
	case SSL_ERROR_WANT_WRITE:
	if (waitForWriting(fd) != 1) {
	if (DBG) {
	ALOGW("SSL_write error");
	}
	return false;
	}
	continue;
	case 0:
	break; // SSL write complete;
	default:
	if (DBG) {
	ALOGW("SSL_write error %d", ssl_err);
	}
	return false;
	}
	}
	}
	if (DBG) {
	ALOGD("%u Wrote %d bytes", mMark, len);
	}
	return true;
	}

	// Read exactly len bytes into buffer or fail
	bool DnsTlsTransport::sslRead(int fd, SSL ssl, uint8_t buffer, int len) {
	int remaining = len;
	while (remaining > 0) {
	int ret = SSL_read(ssl, buffer + (len - remaining), remaining);
	if (ret == 0) {
	ALOGE("SSL socket closed with %i of %i bytes remaining", remaining, len);
	return false;
	}

	if (ret < 0) {
	const int ssl_err = SSL_get_error(ssl, ret);
	if (ssl_err == SSL_ERROR_WANT_READ) {
	if (waitForReading(fd) != 1) {
	if (DBG) {
	ALOGW("SSL_read error");
	}
	return false;
	}
	continue;
	} else {
	if (DBG) {
	ALOGW("SSL_read error %d", ssl_err);
	}
	return false;
	}
	}

	remaining -= ret;
	}
	return true;
	}

	// static
	std::mutex DnsTlsTransport::sLock;
	std::map<DnsTlsTransport::Key, std::unique_ptr<DnsTlsTransport>> DnsTlsTransport::sStore;
	DnsTlsTransport::Response DnsTlsTransport::query(const Server& server, unsigned mark,
	const uint8_t query, size_t qlen, uint8_t response, size_t limit, int *resplen) {
	const Key key = std::make_pair(mark, server);
	DnsTlsTransport* xport;
	{
	std::lock_guard<std::mutex> guard(sLock);
	auto it = sStore.find(key);
	if (it == sStore.end()) {
	xport = new DnsTlsTransport(server, mark);
	if (!xport->initialize()) {
	return DnsTlsTransport::Response::internal_error;
	}
	sStore[key].reset(xport);
	} else {
	xport = it->second.get();
	}
	++xport->mUseCount;
	}

	Response res = xport->doQuery(query, qlen, response, limit, resplen);
	auto now = std::chrono::steady_clock::now();
	{
	std::lock_guard<std::mutex> guard(sLock);
	--xport->mUseCount;
	xport->mLastUsed = now;
	cleanup(now);
	}
	return res;
	}

	static constexpr std::chrono::minutes IDLE_TIMEOUT(5);
	std::chrono::time_point<std::chrono::steady_clock> DnsTlsTransport::sLastCleanup;
	void DnsTlsTransport::cleanup(std::chrono::time_point<std::chrono::steady_clock> now) {
	if (now - sLastCleanup < IDLE_TIMEOUT) {
	return;
	}
	for (auto it = sStore.begin(); it != sStore.end(); ) {
	auto& xport = it->second;
	if (xport->mUseCount == 0 && now - xport->mLastUsed > IDLE_TIMEOUT) {
	it = sStore.erase(it);
	} else {
	++it;
	}
	}
	sLastCleanup = now;
	}

	DnsTlsTransport::Response DnsTlsTransport::doQuery(const uint8_t *query, size_t qlen,
	uint8_t response, size_t limit, int resplen) {
	android::base::unique_fd fd = makeConnectedSocket();
	if (fd.get() < 0) {
	ALOGD("%u makeConnectedSocket() failed with: %s", mMark, strerror(errno));
	return Response::network_error;
	}
	bssl::UniquePtr<SSL> ssl = sslConnect(fd.get());
	if (!ssl) {
	return Response::network_error;
	}

	Response res = sendQuery(fd.get(), ssl.get(), query, qlen);
	if (res == Response::success) {
	res = readResponse(fd.get(), ssl.get(), query, response, limit, resplen);
	}

	sslDisconnect(std::move(ssl), std::move(fd));
	return res;
	}

	DnsTlsTransport::Response DnsTlsTransport::sendQuery(int fd, SSL* ssl, const uint8_t *query, size_t qlen) {
	if (DBG) {
	ALOGD("sending query");
	}
	uint8_t queryHeader[2];
	queryHeader[0] = qlen >> 8;
	queryHeader[1] = qlen;
	if (!sslWrite(fd, ssl, queryHeader, 2)) {
	return Response::network_error;
	}
	if (!sslWrite(fd, ssl, query, qlen)) {
	return Response::network_error;
	}
	if (DBG) {
	ALOGD("%u SSL_write complete", mMark);
	}
	return Response::success;
	}

	DnsTlsTransport::Response DnsTlsTransport::readResponse(int fd, SSL* ssl, const uint8_t query, uint8_t response, size_t limit, int *resplen) {
	if (DBG) {
	ALOGD("reading response");
	}
	uint8_t responseHeader[2];
	if (!sslRead(fd, ssl, responseHeader, 2)) {
	if (DBG) {
	ALOGW("%u Failed to read 2-byte length header", mMark);
	}
	return Response::network_error;
	}
	const uint16_t responseSize = (responseHeader[0] << 8) \| responseHeader[1];
	if (DBG) {
	ALOGD("%u Expecting response of size %i", mMark, responseSize);
	}
	if (responseSize > limit) {
	ALOGE("%u Response doesn't fit in output buffer: %i", mMark, responseSize);
	return Response::limit_error;
	}
	if (!sslRead(fd, ssl, response, responseSize)) {
	if (DBG) {
	ALOGW("%u Failed to read %i bytes", mMark, responseSize);
	}
	return Response::network_error;
	}
	if (DBG) {
	ALOGD("%u SSL_read complete", mMark);
	}

	if (response[0] != query[0] \|\| response[1] != query[1]) {
	ALOGE("reply query ID != query ID");
	return Response::internal_error;
	}

	*resplen = responseSize;
	return Response::success;
	}

	// static
	bool DnsTlsTransport::validate(const Server& server, unsigned netid) {
	if (DBG) {
	ALOGD("Beginning validation on %u", netid);
	}
	// Generate "<random>-dnsotls-ds.metric.gstatic.com", which we will lookup through \|ss\| in
	// order to prove that it is actually a working DNS over TLS server.
	static const char kDnsSafeChars[] =
	"abcdefhijklmnopqrstuvwxyz"
	"ABCDEFHIJKLMNOPQRSTUVWXYZ"
	"0123456789";
	const auto c = [](uint8_t rnd) -> uint8_t {
	return kDnsSafeChars[(rnd % ARRAY_SIZE(kDnsSafeChars))];
	};
	uint8_t rnd[8];
	arc4random_buf(rnd, ARRAY_SIZE(rnd));
	// We could try to use res_mkquery() here, but it's basically the same.
	uint8_t query[] = {
	rnd[6], rnd[7], // [0-1] query ID
	1, 0, // [2-3] flags; query[2] = 1 for recursion desired (RD).
	0, 1, // [4-5] QDCOUNT (number of queries)
	0, 0, // [6-7] ANCOUNT (number of answers)
	0, 0, // [8-9] NSCOUNT (number of name server records)
	0, 0, // [10-11] ARCOUNT (number of additional records)
	17, c(rnd[0]), c(rnd[1]), c(rnd[2]), c(rnd[3]), c(rnd[4]), c(rnd[5]),
	'-', 'd', 'n', 's', 'o', 't', 'l', 's', '-', 'd', 's',
	6, 'm', 'e', 't', 'r', 'i', 'c',
	7, 'g', 's', 't', 'a', 't', 'i', 'c',
	3, 'c', 'o', 'm',
	0, // null terminator of FQDN (root TLD)
	0, ns_t_aaaa, // QTYPE
	0, ns_c_in // QCLASS
	};
	const int qlen = ARRAY_SIZE(query);

	const int kRecvBufSize = 4 * 1024;
	uint8_t recvbuf[kRecvBufSize];

	// At validation time, we only know the netId, so we have to guess/compute the
	// corresponding socket mark.
	Fwmark fwmark;
	fwmark.permission = PERMISSION_SYSTEM;
	fwmark.explicitlySelected = true;
	fwmark.protectedFromVpn = true;
	fwmark.netId = netid;
	unsigned mark = fwmark.intValue;
	int replylen = 0;
	DnsTlsTransport::query(server, mark, query, qlen, recvbuf, kRecvBufSize, &replylen);
	if (replylen == 0) {
	if (DBG) {
	ALOGD("query failed");
	}
	return false;
	}

	if (replylen < NS_HFIXEDSZ) {
	if (DBG) {
	ALOGW("short response: %d", replylen);
	}
	return false;
	}

	const int qdcount = (recvbuf[4] << 8) \| recvbuf[5];
	if (qdcount != 1) {
	ALOGW("reply query count != 1: %d", qdcount);
	return false;
	}

	const int ancount = (recvbuf[6] << 8) \| recvbuf[7];
	if (DBG) {
	ALOGD("%u answer count: %d", netid, ancount);
	}

	// TODO: Further validate the response contents (check for valid AAAA record, ...).
	// Note that currently, integration tests rely on this function accepting a
	// response with zero records.
	#if 0
	for (int i = 0; i < resplen; i++) {
	ALOGD("recvbuf[%d] = %d %c", i, recvbuf[i], recvbuf[i]);
	}
	#endif
	return true;
	}

	} // namespace net
	} // namespace android