1 /* 2 * Copyright (C) 2012 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 an 14 * limitations under the License. 15 */ 16 17 package com.android.server.usb; 18 19 import android.content.ActivityNotFoundException; 20 import android.content.Context; 21 import android.content.Intent; 22 import android.net.LocalSocket; 23 import android.net.LocalSocketAddress; 24 import android.os.Handler; 25 import android.os.HandlerThread; 26 import android.os.Environment; 27 import android.os.FileUtils; 28 import android.os.Looper; 29 import android.os.Message; 30 import android.os.Process; 31 import android.os.SystemClock; 32 import android.util.Slog; 33 import android.util.Base64; 34 35 import java.lang.Thread; 36 import java.io.File; 37 import java.io.FileDescriptor; 38 import java.io.FileOutputStream; 39 import java.io.IOException; 40 import java.io.InputStream; 41 import java.io.OutputStream; 42 import java.io.PrintWriter; 43 import java.security.MessageDigest; 44 import java.util.Arrays; 45 46 public class UsbDebuggingManager implements Runnable { 47 private static final String TAG = "UsbDebuggingManager"; 48 private static final boolean DEBUG = false; 49 50 private final String ADBD_SOCKET = "adbd"; 51 private final String ADB_DIRECTORY = "misc/adb"; 52 private final String ADB_KEYS_FILE = "adb_keys"; 53 private final int BUFFER_SIZE = 4096; 54 55 private final Context mContext; 56 private final Handler mHandler; 57 private final HandlerThread mHandlerThread; 58 private Thread mThread; 59 private boolean mAdbEnabled = false; 60 private String mFingerprints; 61 private LocalSocket mSocket = null; 62 private OutputStream mOutputStream = null; 63 64 public UsbDebuggingManager(Context context) { 65 mHandlerThread = new HandlerThread("UsbDebuggingHandler"); 66 mHandlerThread.start(); 67 mHandler = new UsbDebuggingHandler(mHandlerThread.getLooper()); 68 mContext = context; 69 } 70 71 private void listenToSocket() throws IOException { 72 try { 73 byte[] buffer = new byte[BUFFER_SIZE]; 74 LocalSocketAddress address = new LocalSocketAddress(ADBD_SOCKET, 75 LocalSocketAddress.Namespace.RESERVED); 76 InputStream inputStream = null; 77 78 mSocket = new LocalSocket(); 79 mSocket.connect(address); 80 81 mOutputStream = mSocket.getOutputStream(); 82 inputStream = mSocket.getInputStream(); 83 84 while (true) { 85 int count = inputStream.read(buffer); 86 if (count < 0) { 87 Slog.e(TAG, "got " + count + " reading"); 88 break; 89 } 90 91 if (buffer[0] == 'P' && buffer[1] == 'K') { 92 String key = new String(Arrays.copyOfRange(buffer, 2, count)); 93 Slog.d(TAG, "Received public key: " + key); 94 Message msg = mHandler.obtainMessage(UsbDebuggingHandler.MESSAGE_ADB_CONFIRM); 95 msg.obj = key; 96 mHandler.sendMessage(msg); 97 } 98 else { 99 Slog.e(TAG, "Wrong message: " + (new String(Arrays.copyOfRange(buffer, 0, 2)))); 100 break; 101 } 102 } 103 } catch (IOException ex) { 104 Slog.e(TAG, "Communication error: ", ex); 105 throw ex; 106 } finally { 107 closeSocket(); 108 } 109 } 110 111 @Override 112 public void run() { 113 while (mAdbEnabled) { 114 try { 115 listenToSocket(); 116 } catch (Exception e) { 117 /* Don't loop too fast if adbd dies, before init restarts it */ 118 SystemClock.sleep(1000); 119 } 120 } 121 } 122 123 private void closeSocket() { 124 try { 125 mOutputStream.close(); 126 } catch (IOException e) { 127 Slog.e(TAG, "Failed closing output stream: " + e); 128 } 129 130 try { 131 mSocket.close(); 132 } catch (IOException ex) { 133 Slog.e(TAG, "Failed closing socket: " + ex); 134 } 135 } 136 137 private void sendResponse(String msg) { 138 if (mOutputStream != null) { 139 try { 140 mOutputStream.write(msg.getBytes()); 141 } 142 catch (IOException ex) { 143 Slog.e(TAG, "Failed to write response:", ex); 144 } 145 } 146 } 147 148 class UsbDebuggingHandler extends Handler { 149 private static final int MESSAGE_ADB_ENABLED = 1; 150 private static final int MESSAGE_ADB_DISABLED = 2; 151 private static final int MESSAGE_ADB_ALLOW = 3; 152 private static final int MESSAGE_ADB_DENY = 4; 153 private static final int MESSAGE_ADB_CONFIRM = 5; 154 private static final int MESSAGE_ADB_CLEAR = 6; 155 156 public UsbDebuggingHandler(Looper looper) { 157 super(looper); 158 } 159 160 public void handleMessage(Message msg) { 161 switch (msg.what) { 162 case MESSAGE_ADB_ENABLED: 163 if (mAdbEnabled) 164 break; 165 166 mAdbEnabled = true; 167 168 mThread = new Thread(UsbDebuggingManager.this); 169 mThread.start(); 170 171 break; 172 173 case MESSAGE_ADB_DISABLED: 174 if (!mAdbEnabled) 175 break; 176 177 mAdbEnabled = false; 178 closeSocket(); 179 180 try { 181 mThread.join(); 182 } catch (Exception ex) { 183 } 184 185 mThread = null; 186 mOutputStream = null; 187 mSocket = null; 188 break; 189 190 case MESSAGE_ADB_ALLOW: { 191 String key = (String)msg.obj; 192 String fingerprints = getFingerprints(key); 193 194 if (!fingerprints.equals(mFingerprints)) { 195 Slog.e(TAG, "Fingerprints do not match. Got " 196 + fingerprints + ", expected " + mFingerprints); 197 break; 198 } 199 200 if (msg.arg1 == 1) { 201 writeKey(key); 202 } 203 204 sendResponse("OK"); 205 break; 206 } 207 208 case MESSAGE_ADB_DENY: 209 sendResponse("NO"); 210 break; 211 212 case MESSAGE_ADB_CONFIRM: { 213 String key = (String)msg.obj; 214 mFingerprints = getFingerprints(key); 215 showConfirmationDialog(key, mFingerprints); 216 break; 217 } 218 219 case MESSAGE_ADB_CLEAR: 220 deleteKeyFile(); 221 break; 222 } 223 } 224 } 225 226 private String getFingerprints(String key) { 227 String hex = "0123456789ABCDEF"; 228 StringBuilder sb = new StringBuilder(); 229 MessageDigest digester; 230 231 try { 232 digester = MessageDigest.getInstance("MD5"); 233 } catch (Exception ex) { 234 Slog.e(TAG, "Error getting digester: " + ex); 235 return ""; 236 } 237 238 byte[] base64_data = key.split("\\s+")[0].getBytes(); 239 byte[] digest = digester.digest(Base64.decode(base64_data, Base64.DEFAULT)); 240 241 for (int i = 0; i < digest.length; i++) { 242 sb.append(hex.charAt((digest[i] >> 4) & 0xf)); 243 sb.append(hex.charAt(digest[i] & 0xf)); 244 if (i < digest.length - 1) 245 sb.append(":"); 246 } 247 return sb.toString(); 248 } 249 250 private void showConfirmationDialog(String key, String fingerprints) { 251 Intent dialogIntent = new Intent(); 252 253 dialogIntent.setClassName("com.android.systemui", 254 "com.android.systemui.usb.UsbDebuggingActivity"); 255 dialogIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); 256 dialogIntent.putExtra("key", key); 257 dialogIntent.putExtra("fingerprints", fingerprints); 258 try { 259 mContext.startActivity(dialogIntent); 260 } catch (ActivityNotFoundException e) { 261 Slog.e(TAG, "unable to start UsbDebuggingActivity"); 262 } 263 } 264 265 private File getUserKeyFile() { 266 File dataDir = Environment.getDataDirectory(); 267 File adbDir = new File(dataDir, ADB_DIRECTORY); 268 269 if (!adbDir.exists()) { 270 Slog.e(TAG, "ADB data directory does not exist"); 271 return null; 272 } 273 274 return new File(adbDir, ADB_KEYS_FILE); 275 } 276 277 private void writeKey(String key) { 278 try { 279 File keyFile = getUserKeyFile(); 280 281 if (keyFile == null) { 282 return; 283 } 284 285 if (!keyFile.exists()) { 286 keyFile.createNewFile(); 287 FileUtils.setPermissions(keyFile.toString(), 288 FileUtils.S_IRUSR | FileUtils.S_IWUSR | 289 FileUtils.S_IRGRP, -1, -1); 290 } 291 292 FileOutputStream fo = new FileOutputStream(keyFile, true); 293 fo.write(key.getBytes()); 294 fo.write('\n'); 295 fo.close(); 296 } 297 catch (IOException ex) { 298 Slog.e(TAG, "Error writing key:" + ex); 299 } 300 } 301 302 private void deleteKeyFile() { 303 File keyFile = getUserKeyFile(); 304 if (keyFile != null) { 305 keyFile.delete(); 306 } 307 } 308 309 public void setAdbEnabled(boolean enabled) { 310 mHandler.sendEmptyMessage(enabled ? UsbDebuggingHandler.MESSAGE_ADB_ENABLED 311 : UsbDebuggingHandler.MESSAGE_ADB_DISABLED); 312 } 313 314 public void allowUsbDebugging(boolean alwaysAllow, String publicKey) { 315 Message msg = mHandler.obtainMessage(UsbDebuggingHandler.MESSAGE_ADB_ALLOW); 316 msg.arg1 = alwaysAllow ? 1 : 0; 317 msg.obj = publicKey; 318 mHandler.sendMessage(msg); 319 } 320 321 public void denyUsbDebugging() { 322 mHandler.sendEmptyMessage(UsbDebuggingHandler.MESSAGE_ADB_DENY); 323 } 324 325 public void clearUsbDebuggingKeys() { 326 mHandler.sendEmptyMessage(UsbDebuggingHandler.MESSAGE_ADB_CLEAR); 327 } 328 329 public void dump(FileDescriptor fd, PrintWriter pw) { 330 pw.println(" USB Debugging State:"); 331 pw.println(" Connected to adbd: " + (mOutputStream != null)); 332 pw.println(" Last key received: " + mFingerprints); 333 pw.println(" User keys:"); 334 try { 335 pw.println(FileUtils.readTextFile(new File("/data/misc/adb/adb_keys"), 0, null)); 336 } catch (IOException e) { 337 pw.println("IOException: " + e); 338 } 339 pw.println(" System keys:"); 340 try { 341 pw.println(FileUtils.readTextFile(new File("/adb_keys"), 0, null)); 342 } catch (IOException e) { 343 pw.println("IOException: " + e); 344 } 345 } 346 } 347
