initial commit

Author: joshchoo

.gitignore

@@ -0,0 +1 @@
+/target

Cargo.lock

@@ -0,0 +1,16 @@
+[package]
+name = "aosp-missing-blobs"
+version = "0.1.0"
+authors = ["Josh Choo <dev@joshuous.com>"]
+edition = "2018"
+description = """
+aosp-missing-blobs is a nifty tool to identify required blobs (.so) that are missing from AOSP ROM builds,
+and to show which existing blobs rely on them. This will be particularly useful for ROM developers who want
+to ensure that they have not missed out any required proprietary OEM blobs.
+"""
+license = "MIT"
+homepage = "https://github.com/joshuous/aosp-missing-blobs"
+repository = "https://github.com/joshuous/aosp-missing-blobs"
+
+[dependencies]
+goblin = "0.4"

Cargo.toml

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Josh Choo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

LICENSE

@@ -0,0 +1,98 @@
+## aosp-missing-blobs
+
+aosp-missing-blobs is a nifty tool to identify required blobs (.so) that are missing from AOSP ROM builds,
+and to show which existing blobs rely on them. This will be particularly useful for ROM developers who
+want to ensure that they have not missed out any required proprietary OEM blobs.
+
+### Concept
+
+Blobs (.so) and compiled binaries in Android need other blobs to work. It is possible to identify the
+dependencies for each blob by inspecting their ELF information:
+
+```
+$ readelf -d <name_of_blob.so> | grep "\(NEEDED\)" | sed -r "s/.*\[(.*)\]/\1/"
+```
+
+Example (finding the dependencies of `libqti_performance.so`):
+
+```
+$ readelf -d libqti_performance.so | grep "\(NEEDED\)" | sed -r "s/.*\[(.*)\]/\1/"
+libnativehelper.so
+liblog.so
+libcutils.so
+libutils.so
+libbase.so
+vendor.qti.hardware.iop@2.0.so
+libhidlbase.so
+libhidltransport.so
+libqti-perfd-client_system.so
+libhwui.so
+libc++.so
+libc.so
+libm.so
+libdl.so
+```
+
+From the example, we can see that `libqti_performance.so` depends on `libqti-perfd-client_system.so`
+and `vendor.qti.hardware.iop@2.0.so`.
+
+aosp-missing-blobs uses this idea to identify all the dependencies of a given list of blobs, and to
+check whether any of these dependencies are not present.
+
+### Building
+
+aosp-missing-blobs is written in Rust, hence you'll need [Rust to be installed](https://www.rust-lang.org) to build the project.
+
+In the root directory of the repo, execute:
+
+```
+$ git clone https://github.com/joshuous/aosp-missing-blobs
+$ cd aosp-missing-blobs
+$ cargo build --release
+
+$ ./target/release/aosp-missing-blobs
+```
+
+A runnable `aosp-missing-blobs` binary will be produced.
+
+### Usage
+
+This program takes as arguments a **list of directories** that contain compiled binaries and blobs (.so).
+
+```
+$ aosp-missing-blobs <blob directory1> <blob directory2> <blob directory3> <blob directoryN>
+```
+
+#### Example
+
+Assuming you have extracted the ROM's system.img and vendor.img to `~/system` and `~/vendor`, respectively, run the following:
+
+```
+$ aosp-missing-blobs ~/system/lib ~/vendor/lib
+```
+
+The program does the following:
+
+1. Search `~/system/lib` and `~/vendor/lib` directories for blobs.
+2. Identify dependencies of each blob found.
+3. Checks if required dependencies exist in `~/system/lib` and `~/vendor/lib`.
+4. Output a list of missing dependencies and existing blobs that need them.
+
+Depending on how wide your search scope is, the program may flag out missing dependencies 'incorrectly'.
+Some dependencies may exist in other directories besides what the examples have shown.
+Other directories with blobs include the following:
+
+- /system/bin
+- /system/lib[64]
+- /system/lib[64]/vndk-28
+- /system/lib[64]/vndk-sp-28
+- /vendor/bin
+- /vendor/lib[64]
+- /vendor/lib[64]/vndk
+- Etc.
+
+Take note that the more directories you specify as arguments, the longer the program will run for!
+
+### Downloads
+
+Binary downloads can be found in the [Releases](https://github.com/joshuous/AospMissingBlobs/releases).

README.md

@@ -0,0 +1,69 @@
+use goblin::{self, Object};
+use std::collections::HashMap;
+use std::path::Path;
+use std::{collections::HashSet, fs};
+
+pub fn run(paths: &[String]) -> goblin::error::Result<()> {
+    let mut dependencies: HashMap<String, Vec<String>> = HashMap::new();
+    let mut present: HashSet<String> = HashSet::new();
+
+    let dirs = paths
+        .iter()
+        .map(Path::new)
+        .filter(|path| path.is_dir())
+        .collect::<Vec<_>>();
+
+    for dir in dirs.iter() {
+        for entry in fs::read_dir(dir)? {
+            let path = entry?.path();
+
+            let filename = path
+                .file_name()
+                .expect("Could not get file name.")
+                .to_str()
+                .expect("Could not convert to string.")
+                .to_string();
+
+            present.insert(filename.clone());
+
+            if let Some(ext) = path.extension() {
+                if ext != "so" {
+                    continue;
+                }
+            } else {
+                continue;
+            }
+
+            let buffer = fs::read(&path)?;
+            let obj = goblin::Object::parse(&buffer);
+
+            if let Ok(Object::Elf(elf)) = obj {
+                for dep_str in elf.libraries {
+                    let dep = dep_str.to_string();
+                    match dependencies.get_mut(&dep) {
+                        Some(dependants) => {
+                            dependants.push(filename.clone());
+                        }
+                        None => {
+                            dependencies.insert(dep, vec![filename.clone()]);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    let mut missing: Vec<String> = vec![];
+
+    for (dep, _) in &dependencies {
+        if !present.contains(dep) {
+            missing.push(dep.to_string());
+        }
+    }
+
+    for m in missing {
+        println!("{} required by: {}", m, dependencies[&m].join("; "));
+    }
+
+    Ok(())
+}

src/lib.rs

@@ -0,0 +1,10 @@
+use std::env;
+
+use aosp_missing_blobs::run;
+
+fn main() {
+    let args: Vec<String> = env::args().collect();
+    let paths = &args[1..];
+
+    run(&paths).expect("An error occurred.");
+}