Optimizations

New modules
Restructuring

Author: Netdex

app/src/main/java/cf/netdex/hidfuzzer/MainActivity.java

@@ -1,18 +1,17 @@
 package cf.netdex.hidfuzzer;
 
-import android.content.Context;
 import android.os.Bundle;
 import android.support.v7.app.AppCompatActivity;
 import android.widget.CompoundButton;
 import android.widget.Spinner;
-import android.widget.TextView;
 import android.widget.ToggleButton;
 
-import cf.netdex.hidfuzzer.hid.HID;
+import cf.netdex.hidfuzzer.task.PowershellTask;
+import cf.netdex.hidfuzzer.task.DownloadTask;
+import cf.netdex.hidfuzzer.task.WallpaperTask;
 import cf.netdex.hidfuzzer.task.FuzzerTask;
 import cf.netdex.hidfuzzer.task.HIDTask;
 import cf.netdex.hidfuzzer.task.TestTask;
-import cf.netdex.hidfuzzer.util.Func;
 
 public class MainActivity extends AppCompatActivity {
 
@@ -23,33 +22,36 @@ protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_main);
 
-        final TextView txtStatus = (TextView) findViewById(R.id.txtStatus);
+
         final ToggleButton btnPoll = (ToggleButton) findViewById(R.id.btnPoll);
         final Spinner spnTask = (Spinner) findViewById(R.id.spnTask);
 
-        final Func<HIDTask.RunState> updatef = new Func<HIDTask.RunState>() {
-            @Override
-            public void run(HIDTask.RunState... s) {
-                txtStatus.setText(s[0].name());
-            }
-        };
         btnPoll.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
             @Override
             public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
                 if (isChecked) {
                     String stask = (String) spnTask.getSelectedItem();
                     switch(stask){
                         case "Fuzzer":
-                            RUNNING_TASK = new FuzzerTask(MainActivity.this, updatef);
+                            RUNNING_TASK = new FuzzerTask(MainActivity.this);
                             break;
                         case "Test":
-                            RUNNING_TASK = new TestTask(MainActivity.this, updatef);
+                            RUNNING_TASK = new TestTask(MainActivity.this);
+                            break;
+                        case "Wallpaper":
+                            RUNNING_TASK = new WallpaperTask(MainActivity.this);
+                            break;
+                        case "Download":
+                            RUNNING_TASK = new DownloadTask(MainActivity.this);
+                            break;
+                        case "PowerShell":
+                            RUNNING_TASK = new PowershellTask(MainActivity.this);
                             break;
                     }
                     RUNNING_TASK.execute();
                 } else {
                     if (RUNNING_TASK != null)
-                        RUNNING_TASK.cancel(true);
+                        RUNNING_TASK.cancel(false);
                 }
             }
         });

app/src/main/java/cf/netdex/hidfuzzer/hid/HID.java

@@ -2,15 +2,21 @@
 
 import android.util.Log;
 
+import java.util.Arrays;
 import java.util.concurrent.CountDownLatch;
 
 import eu.chainfire.libsuperuser.Shell;
 
 /**
+ * Native communication with HID devices
+ *
  * Created by netdex on 1/15/2017.
  */
 
 public class HID {
+    private static byte[] mouse_buf = new byte[4];
+    private static byte[] keyboard_buf = new byte[8];
+
     /**
      * A        B        C        D
      * XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX
@@ -23,41 +29,38 @@ public class HID {
      * @param sh     SU shell
      * @param dev    Mouse device (/dev/hidg1)
      * @param offset HID mouse bytes
-     * @return error code
+     * @return error c
      */
     public static int hid_mouse(Shell.Interactive sh, String dev, byte... offset) {
         if (offset.length > 4)
             throw new IllegalArgumentException("Your mouse can only move in two dimensions");
-        byte[] buf = new byte[4];
-        System.arraycopy(offset, 0, buf, 0, offset.length);
-        return write_bytes(sh, dev, buf);
+        Arrays.fill(mouse_buf, (byte) 0);
+        System.arraycopy(offset, 0, mouse_buf, 0, offset.length);
+        return write_bytes(sh, dev, mouse_buf);
     }
 
     /**
      * A        B        C        D        E        F        G        H
      * XXXXXXXX 00000000 XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX
      * <p>
-     * A: Key modifier mask
+     * A: K modifier mask
      * B: Reserved
-     * C: Key 1; D: Key 2; E: Key 3; F: Key 4; G: Key 5; H: Key 6;
+     * C: K 1; D: K 2; E: K 3; F: K 4; G: K 5; H: K 6;
      *
      * @param sh   SU shell
-     * @param dev  Keyboard device (/dev/hidg0)
+     * @param dev  KB device (/dev/hidg0)
      * @param keys HID keyboard bytes
-     * @return error code
+     * @return error c
      */
     public static int hid_keyboard(Shell.Interactive sh, String dev, byte... keys) {
         if (keys.length > 7)
             throw new IllegalArgumentException("Cannot send more than 6 keys");
-        byte[] buf = new byte[8];
-        if (keys.length > 0) buf[0] = keys[0];
-        if (keys.length > 1) System.arraycopy(keys, 1, buf, 2, keys.length - 1);
-        return write_bytes(sh, dev, buf);
+        Arrays.fill(keyboard_buf, (byte) 0);
+        if (keys.length > 0) keyboard_buf[0] = keys[0];
+        if (keys.length > 1) System.arraycopy(keys, 1, keyboard_buf, 2, keys.length - 1);
+        return write_bytes(sh, dev, keyboard_buf);
     }
 
-    // TODO read state of NUM_LOCK, CAPS_LOCK, and SCROLL_LOCK by reading /dev/hidg0
-    // lol you can create a serial line by flashing the num and caps lights, probably 10 baud though
-
     private static int write_bytes(Shell.Interactive sh, String dev, byte[] arr) {
         String bt = escapeBytes(arr);
         final Integer[] err = {-1};

app/src/main/java/cf/netdex/hidfuzzer/hid/HIDR.java

@@ -6,10 +6,11 @@
 import java.io.InputStream;
 
 import cf.netdex.hidfuzzer.MainActivity;
-import cf.netdex.hidfuzzer.util.SUExecute;
 import eu.chainfire.libsuperuser.Shell;
 
 /**
+ * Wrapper for HID class for ease of usage
+ *
  * Created by netdex on 1/16/2017.
  */
 
@@ -34,6 +35,10 @@ public void delay(long m) {
         }
     }
 
+    public int test(){
+        return hid_keyboard((byte) 0, Input.KB.K.VOLUME_UP.c);
+    }
+
     public int hid_mouse(byte... offset) {
         return HID.hid_mouse(mSU, mDevMouse, offset);
     }
@@ -49,21 +54,26 @@ public int press_keys(byte... keys) {
         return ec;
     }
 
-    /* String to code conversion tables */
+    /* Begin string to c conversion tables */
     private static final String MP_ALPHA = "abcdefghijklmnopqrstuvwxyz";        // 0x04
     private static final String MP_ALPHA_ALT = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";    // 0x04 SHIFT
     private static final String MP_NUM = "1234567890";                          // 0x1E
     private static final String MP_NUM_ALT = "!@#$%^&*()";                      // 0x1E SHIFT
     private static final String MP_SPEC = " -=[]\\#;'`,./";                     // 0x2C
     private static final String MP_SPEC_ALT = " _+{}| :\"~<>?";                 // 0x2C SHIFT
+    private static final String MP_SU_SPEC = "\n";                              // 0X28
 
-    private static final String[] AP_ATT = {MP_ALPHA, MP_ALPHA_ALT, MP_NUM, MP_NUM_ALT, MP_SPEC, MP_SPEC_ALT};
-    private static final boolean[] AP_SHIFT = {false, true, false, true, false, true};
-    private static final byte[] AP_OFFSET = {0x04, 0x04, 0x1E, 0x1E, 0x2C, 0x2C};
+    private static final String[] AP_ATT = {MP_ALPHA, MP_ALPHA_ALT, MP_NUM, MP_NUM_ALT, MP_SPEC, MP_SPEC_ALT, MP_SU_SPEC};
+    private static final boolean[] AP_SHIFT = {false, true, false, true, false, true, false};
+    private static final byte[] AP_OFFSET = {0x04, 0x04, 0x1E, 0x1E, 0x2C, 0x2C, 0x28};
 
-    public int send_string(String s) {
-        int ec = 0;
-        for (char c : s.toCharArray()) {
+    private static final byte[] AP_MAP_CODE = new byte[128];
+    private static final boolean[] AP_MAP_SHIFT = new boolean[128];
+
+    // build fast conversion tables from human readable data
+    static {
+        for (int i = 0; i < 128; i++) {
+            char c = (char) i;
             boolean shift = false;
             byte code = 0;
 
@@ -77,28 +87,57 @@ public int send_string(String s) {
                 }
                 idx++;
             }
-            if (idx == AP_ATT.length)
-                throw new IllegalArgumentException("Given string contains illegal characters");
+            if (idx == AP_ATT.length) {
+                AP_MAP_CODE[i] = -1;
+            } else {
+                AP_MAP_CODE[i] = code;
+                AP_MAP_SHIFT[i] = shift;
+            }
+        }
+    }
+    /* End string to c conversion tables */
+
+    public int send_string(String s) {
+        return send_string(s, 0);
+    }
 
-            ec |= hid_keyboard(shift ? Input.Keyboard.ModifierMask.LSHIFT.code : 0, code);
+    public int send_string(String s, int d) {
+        int ec = 0;
+        char lc = Character.MIN_VALUE;
+        for (char c : s.toCharArray()) {
+            byte cd = AP_MAP_CODE[(int) c];
+            boolean st = AP_MAP_SHIFT[(int) c];
+            if (cd == -1)
+                throw new IllegalArgumentException("Given string contains illegal characters");
+            if (c == lc)
+                ec |= hid_keyboard();
+            ec |= hid_keyboard(st ? Input.KB.M.LSHIFT.c : 0, cd);
+            if (d != 0)
+                delay(d);
+            lc = c;
         }
         ec |= hid_keyboard();
         return ec;
     }
 
-    public KeyboardLightListener getKeyboardLightListener(){
+    public KeyboardLightListener getKeyboardLightListener() {
         return mKeyboardLightListener;
     }
 
     public class KeyboardLightListener {
         private Process mKeyboardLightProc;
         private InputStream mKeyboardLightStream;
+        private int mLastLightState;
 
         public int start() {
             if (mKeyboardLightProc != null)
-                throw new IllegalArgumentException("Keyboard light proc already running");
+                throw new IllegalArgumentException("KB light proc already running");
 
-            mKeyboardLightProc = SUExecute.execute("cat " + mDevKeyboard);
+            try {
+                mKeyboardLightProc = Runtime.getRuntime().exec("cat " + mDevKeyboard);
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
             if (mKeyboardLightProc != null) {
                 mKeyboardLightStream = mKeyboardLightProc.getInputStream();
                 return 0;
@@ -118,23 +157,62 @@ public int start() {
         public int read() {
             try {
                 if (mKeyboardLightStream != null)
-                    return mKeyboardLightStream.read();
+                    return mLastLightState = mKeyboardLightStream.read();
                 return -1;
             } catch (IOException e) {
                 Log.d(MainActivity.TAG, "Light stream forcibly terminated");
                 return -1;
             }
         }
 
+        public int available() {
+            if (mKeyboardLightStream != null) {
+                try {
+                    return mKeyboardLightStream.available();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            return -1;
+        }
+
         public void kill() {
-            try {
+            // HACK don't stare at this for too long, or your eyes will burn out
+//                Field f = mKeyboardLightProc.getClass().getDeclaredField("pid");
+//                f.setAccessible(true);
+//                long pid = f.getLong(mKeyboardLightProc);
+//                f.setAccessible(false);
+//                String cmd = "pkill -KILL -P " + pid;
+//                Log.d("A", cmd);
+//                mSU.addCommand(cmd, 0, new Shell.OnCommandLineListener() {
+//                    @Override
+//                    public void onCommandResult(int commandCode, int exitCode) {
+//                        Log.d("A", commandCode + " " + exitCode);
+//                    }
+//
+//                    @Override
+//                    public void onLine(String line) {
+//                        Log.d("A", line);
+//                    }
+//                });
+            if (mKeyboardLightStream != null) {
+                try {
+                    mKeyboardLightStream.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+                mKeyboardLightStream = null;
+            }
+
+            // close the stream before killing the process
+            if (mKeyboardLightProc != null) {
                 mKeyboardLightProc.destroy();
                 mKeyboardLightProc = null;
-                mKeyboardLightStream.close();
-                mKeyboardLightStream = null;
-            } catch (IOException e) {
-                e.printStackTrace();
             }
         }
+
+        public int getLastLightState() {
+            return mLastLightState;
+        }
     }
 }

app/src/main/java/cf/netdex/hidfuzzer/hid/Input.java

@@ -6,21 +6,21 @@
 
 public class Input {
 
-    public static class Mouse {
-        public enum Buttons {
+    public static class M {
+        public enum B {
             BUTTON_LEFT(0x1),
             BUTTON_RIGHT(0x2),
             BUTTON_MIDDLE(0x4);
             public byte code;
 
-            Buttons(int code) {
+            B(int code) {
                 this.code = (byte) code;
             }
         }
     }
 
-    public static class Keyboard {
-        public enum ModifierMask {
+    public static class KB {
+        public enum M {
             LCTRL(0x1),
             LSHIFT(0x2),
             LALT(0x4),
@@ -30,14 +30,14 @@ public enum ModifierMask {
             RALT(0x40),
             RSUPER(0x80); // Windows key
 
-            public byte code;
+            public byte c;
 
-            ModifierMask(int code) {
-                this.code = (byte) code;
+            M(int c) {
+                this.c = (byte) c;
             }
         }
 
-        public enum Key {
+        public enum K {
             A(0X04),
             B(0X05),
             C(0X06),
@@ -180,10 +180,10 @@ public enum Key {
             VOLUME_UP(0x80),
             VOLUME_DOWN(0x81);
 
-            public byte code;
+            public byte c;
 
-            Key(int code) {
-                this.code = (byte) code;
+            K(int c) {
+                this.c = (byte) c;
             }
         }
     }