working linker check

Author: caden-kline

src/penguin/config_patchers.py

@@ -1642,10 +1642,6 @@ class LinkerSymbolSearch(PatchGenerator):
     key->value mappings from libraries exporting some common nvram
     defaults symbols ("Nvrams", "router_defaults") - add these to our
     nvram config if we have any.
-
-    TODO: if we find multiple nvram source files here, we should generate multiple patches.
-    Then we should consider these during search. For now we just take non-conflicting values
-    from largest to smallest source files. More realistic might be to try each file individually.
     '''
 
     def __init__(self, library_info, archid):
@@ -1659,11 +1655,17 @@ def generate(self, patches):
         if not len(sources):
             return
         linkers_without_preload = []
+        linkers = self.linker_paths.copy()
+
         for file in sources.keys():
             if file in self.linker_paths.keys():
-                self.linker_paths.pop('file')
+                self.linker_paths.pop(file)
                 if not ("_dl_preload" in sources[file] or "handle_ld_preload" in sources[file]):
                     linkers_without_preload.append(file)
-        print(linkers_without_preload)
-            
-
+                    for x in sources[file]:
+                        if "GLIBC_" in x:
+                            linkers_without_preload.remove(file)
+                            break
+        if not len(linkers_without_preload):
+            return
+        logger.critical(f"The following linkers are missing PRELOAD capabilites: {linkers_without_preload} out of {linkers.keys()}")

src/penguin/gen_config.py

@@ -94,6 +94,8 @@ def run_static_analyses(self, output_dir, extracted_dir, static_dir_name="static
             # If we have results, store on disk. Always store in results dict, even if empty
             if this_result:
                 with open(results_dir / f"{analysis.__name__}.yaml", "w") as f:
+                    if analysis == STATIC.ArchId:
+                        this_result = this_result[0]
                     yaml.dump(this_result, f)
 
         return results

src/penguin/static_analyses.py

@@ -102,15 +102,17 @@ def run(self, extracted_fs, prior_results):
                             logger.warning(f"Failed to parse ELF file {path}: {e}. Ignoring")
                             continue
                         info = arch_filter(ef)
+                        for segment in ef.iter_segments():
+                            try:
+                                name = segment.get_interp_name()
+                                if name is not None:
+                                    loaders[name] = loaders.get(name, 0) + 1
+                            except AttributeError:
+                                continue
                     if info.bits is None or info.arch is None:
                         arch_counts["unknown"] += 1
                     else:
                         arch_counts[info.bits][info.arch] += 1
-                    # Search for PT_INTERP
-                    for segment in ef.iter_segments(type=0x3):
-                        name = segment.get_interp_name()
-                        if name is not None:
-                            loaders[name] = loaders.get(name, 0) + 1
 
         # If there is at least one intel and non-intel arch,
         # filter out all the intel ones.
@@ -660,6 +662,7 @@ class LibrarySymbols(StaticAnalysis):
     def run(self, extract_dir, prior_results):
         self.extract_dir = extract_dir
         self.archend = arch_end(prior_results['ArchId'][0])
+        self.linkers = prior_results['ArchId'][1]
 
         if any([x is None for x in self.archend]):
             self.enabled = False
@@ -755,6 +758,7 @@ def _analyze_library(elf_path, archend):
 
         symbols = {}  # Symbol name -> relative(?) address
         nvram_data = {}  # key -> value (may be empty string)
+
         def _is_elf(filename):
             try:
                 with open(filename, "rb") as f: