1/*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define TRACE_TAG ADB
18
19#include "sysdeps.h"
20
21#include <errno.h>
22#include <signal.h>
23#include <stdio.h>
24#include <stdlib.h>
25#include <getopt.h>
26#include <sys/prctl.h>
27
28#include <memory>
29
30#include <android-base/logging.h>
31#include <android-base/macros.h>
32#include <android-base/properties.h>
33#include <android-base/stringprintf.h>
34#include <libminijail.h>
35#include <log/log_properties.h>
36#include <scoped_minijail.h>
37
38#include <private/android_filesystem_config.h>
39#include "debuggerd/handler.h"
40#include "selinux/android.h"
41
42#include "adb.h"
43#include "adb_auth.h"
44#include "adb_listeners.h"
45#include "adb_utils.h"
46#include "transport.h"
47
48#include "mdns.h"
49
50static const char* root_seclabel = nullptr;
51
52static void drop_capabilities_bounding_set_if_needed(struct minijail *j) {
53#if defined(ALLOW_ADBD_ROOT)
54    if (__android_log_is_debuggable()) {
55        return;
56    }
57#endif
58    minijail_capbset_drop(j, CAP_TO_MASK(CAP_SETUID) | CAP_TO_MASK(CAP_SETGID));
59}
60
61static bool should_drop_privileges() {
62#if defined(ALLOW_ADBD_ROOT)
63    // The properties that affect `adb root` and `adb unroot` are ro.secure and
64    // ro.debuggable. In this context the names don't make the expected behavior
65    // particularly obvious.
66    //
67    // ro.debuggable:
68    //   Allowed to become root, but not necessarily the default. Set to 1 on
69    //   eng and userdebug builds.
70    //
71    // ro.secure:
72    //   Drop privileges by default. Set to 1 on userdebug and user builds.
73    bool ro_secure = android::base::GetBoolProperty("ro.secure", true);
74    bool ro_debuggable = __android_log_is_debuggable();
75
76    // Drop privileges if ro.secure is set...
77    bool drop = ro_secure;
78
79    // ... except "adb root" lets you keep privileges in a debuggable build.
80    std::string prop = android::base::GetProperty("service.adb.root", "");
81    bool adb_root = (prop == "1");
82    bool adb_unroot = (prop == "0");
83    if (ro_debuggable && adb_root) {
84        drop = false;
85    }
86    // ... and "adb unroot" lets you explicitly drop privileges.
87    if (adb_unroot) {
88        drop = true;
89    }
90
91    return drop;
92#else
93    return true; // "adb root" not allowed, always drop privileges.
94#endif // ALLOW_ADBD_ROOT
95}
96
97static void drop_privileges(int server_port) {
98    ScopedMinijail jail(minijail_new());
99
100    // Add extra groups:
101    // AID_ADB to access the USB driver
102    // AID_LOG to read system logs (adb logcat)
103    // AID_INPUT to diagnose input issues (getevent)
104    // AID_INET to diagnose network issues (ping)
105    // AID_NET_BT and AID_NET_BT_ADMIN to diagnose bluetooth (hcidump)
106    // AID_SDCARD_R to allow reading from the SD card
107    // AID_SDCARD_RW to allow writing to the SD card
108    // AID_NET_BW_STATS to read out qtaguid statistics
109    // AID_READPROC for reading /proc entries across UID boundaries
110    gid_t groups[] = {AID_ADB,      AID_LOG,       AID_INPUT,
111                      AID_INET,     AID_NET_BT,    AID_NET_BT_ADMIN,
112                      AID_SDCARD_R, AID_SDCARD_RW, AID_NET_BW_STATS,
113                      AID_READPROC};
114    minijail_set_supplementary_gids(jail.get(), arraysize(groups), groups);
115
116    // Don't listen on a port (default 5037) if running in secure mode.
117    // Don't run as root if running in secure mode.
118    if (should_drop_privileges()) {
119        drop_capabilities_bounding_set_if_needed(jail.get());
120
121        minijail_change_gid(jail.get(), AID_SHELL);
122        minijail_change_uid(jail.get(), AID_SHELL);
123        // minijail_enter() will abort if any priv-dropping step fails.
124        minijail_enter(jail.get());
125
126        D("Local port disabled");
127    } else {
128        // minijail_enter() will abort if any priv-dropping step fails.
129        minijail_enter(jail.get());
130
131        if (root_seclabel != nullptr) {
132            if (selinux_android_setcon(root_seclabel) < 0) {
133                LOG(FATAL) << "Could not set SELinux context";
134            }
135        }
136        std::string error;
137        std::string local_name =
138            android::base::StringPrintf("tcp:%d", server_port);
139        if (install_listener(local_name, "*smartsocket*", nullptr, 0, nullptr, &error)) {
140            LOG(FATAL) << "Could not install *smartsocket* listener: " << error;
141        }
142    }
143}
144
145static void setup_port(int port) {
146    local_init(port);
147    setup_mdns(port);
148}
149
150int adbd_main(int server_port) {
151    umask(0);
152
153    signal(SIGPIPE, SIG_IGN);
154
155    init_transport_registration();
156
157    // We need to call this even if auth isn't enabled because the file
158    // descriptor will always be open.
159    adbd_cloexec_auth_socket();
160
161    if (ALLOW_ADBD_NO_AUTH && !android::base::GetBoolProperty("ro.adb.secure", false)) {
162        auth_required = false;
163    }
164
165    adbd_auth_init();
166
167    // Our external storage path may be different than apps, since
168    // we aren't able to bind mount after dropping root.
169    const char* adb_external_storage = getenv("ADB_EXTERNAL_STORAGE");
170    if (adb_external_storage != nullptr) {
171        setenv("EXTERNAL_STORAGE", adb_external_storage, 1);
172    } else {
173        D("Warning: ADB_EXTERNAL_STORAGE is not set.  Leaving EXTERNAL_STORAGE"
174          " unchanged.\n");
175    }
176
177    drop_privileges(server_port);
178
179    bool is_usb = false;
180    if (access(USB_FFS_ADB_EP0, F_OK) == 0) {
181        // Listen on USB.
182        usb_init();
183        is_usb = true;
184    }
185
186    // If one of these properties is set, also listen on that port.
187    // If one of the properties isn't set and we couldn't listen on usb, listen
188    // on the default port.
189    std::string prop_port = android::base::GetProperty("service.adb.tcp.port", "");
190    if (prop_port.empty()) {
191        prop_port = android::base::GetProperty("persist.adb.tcp.port", "");
192    }
193
194    int port;
195    if (sscanf(prop_port.c_str(), "%d", &port) == 1 && port > 0) {
196        D("using port=%d", port);
197        // Listen on TCP port specified by service.adb.tcp.port property.
198        setup_port(port);
199    } else if (!is_usb) {
200        // Listen on default port.
201        setup_port(DEFAULT_ADB_LOCAL_TRANSPORT_PORT);
202    }
203
204    D("adbd_main(): pre init_jdwp()");
205    init_jdwp();
206    D("adbd_main(): post init_jdwp()");
207
208    D("Event loop starting");
209    fdevent_loop();
210
211    return 0;
212}
213
214int main(int argc, char** argv) {
215    while (true) {
216        static struct option opts[] = {
217            {"root_seclabel", required_argument, nullptr, 's'},
218            {"device_banner", required_argument, nullptr, 'b'},
219            {"version", no_argument, nullptr, 'v'},
220        };
221
222        int option_index = 0;
223        int c = getopt_long(argc, argv, "", opts, &option_index);
224        if (c == -1) {
225            break;
226        }
227
228        switch (c) {
229        case 's':
230            root_seclabel = optarg;
231            break;
232        case 'b':
233            adb_device_banner = optarg;
234            break;
235        case 'v':
236            printf("Android Debug Bridge Daemon version %d.%d.%d %s\n",
237                   ADB_VERSION_MAJOR, ADB_VERSION_MINOR, ADB_SERVER_VERSION,
238                   ADB_REVISION);
239            return 0;
240        default:
241            // getopt already prints "adbd: invalid option -- %c" for us.
242            return 1;
243        }
244    }
245
246    close_stdin();
247
248    debuggerd_init(nullptr);
249    adb_trace_init(argv);
250
251    D("Handling main()");
252    return adbd_main(DEFAULT_ADB_PORT);
253}
254