Repository: mandiant/capa
File: capa/features/extractors/dnfile/helpers.py (Python)

Code before:
            member_forward_table = impl_map.MemberForwarded.table.number
        member_forward_row: int = impl_map.MemberForwarded.row_index

        # ECMA says "Each row of the ImplMap table associates a row in the MethodDef table (MemberForwarded) with the
        # name of a routine (ImportName) in some unmanaged DLL (ImportScope)"; so we calculate and map the MemberForwarded
        # MethodDef table token to help us later record native import method calls made from CIL
        token: int = calculate_dotnet_token_value(member_forward_table, member_forward_row)

        # like Kernel32.dll
        if module and "." in module:
            module = module.split(".")[0]

        # like kernel32.CreateFileA
        yield DnUnmanagedMethod(token, module, method)

def get_nested_class_table(pe):
    nested_class_table = {}
    
    # Used to find nested classes in typedef
    for rid, nestedclass in iter_dotnet_table(pe, dnfile.mdtable.NestedClass.number):
        assert isinstance(nestedclass, dnfile.mdtable.NestedClassRow)
        nested_class_table[nestedclass.NestedClass.row_index] = nestedclass.EnclosingClass.row_index

    return nested_class_table

def typedef_helper(index, nested_class_table, typedef_class_table, typedef_name, name):
    # Append the current typeref name
    typedef_name.append(name)
    
    while nested_class_table[index] in nested_class_table:
        name = typedef_class_table[nested_class_table[index]-1].TypeName
        typedef_name.append(name)
        index = nested_class_table[index]
        
    # Document the root enclosing details
    enclosing_name = typedef_class_table[nested_class_table[index]-1].TypeName
    typedef_name.append(enclosing_name)
    namespace = typedef_class_table[nested_class_table[index]-1].TypeNamespace
    
    return namespace, tuple(typedef_name[::-1])

def typeref_helper(index, typeref_table, typeref_name, name):
    # Not appending the current typeref name to avoid potential duplicate
    
    while type(typeref_table[index - 1].ResolutionScope.table) is dnfile.mdtable.TypeRef:
        # Recursively call helper function with enclosing typeref details
        typeref_name.append(name)
        name = typeref_table[index - 1].TypeName
        index = typeref_table[index - 1].ResolutionScope.row_index
    
    # Document the root enclosing details

Review comment (suggestion):
Please give this function a more descriptive name, e.g. `resolve_nested_typedef_name`.

Code after:

def get_dotnet_table_row(pe: dnfile.dnPE, table_index: int, row_index: int) -> Optional[dnfile.base.MDTableRow]:
    assert pe.net is not None
    assert pe.net.mdtables is not None

    if row_index - 1 <= 0:
        return None

    try:
        table = pe.net.mdtables.tables.get(table_index, [])
        return table[row_index - 1]
    except IndexError:
        return None


def resolve_nested_typedef_name(
    nested_class_table: dict, index: int, typedef: dnfile.mdtable.TypeDefRow, pe: dnfile.dnPE
) -> Tuple[str, Tuple[str, ...]]:
    """Resolves all nested TypeDef class names. Returns the namespace as a str and the nested TypeRef name as a tuple"""

    if index in nested_class_table:
        typedef_name = []
        name = typedef.TypeName

        # Append the current typedef name
        typedef_name.append(name)

        while nested_class_table[index] in nested_class_table:
            # Iterate through the typedef table to resolve the nested name
            table_row = get_dotnet_table_row(pe, dnfile.mdtable.TypeDef.number, nested_class_table[index])
            if table_row is None:
                return typedef.TypeNamespace, tuple(typedef_name[::-1])

            name = table_row.TypeName
            typedef_name.append(name)
            index = nested_class_table[index]

        # Document the root enclosing details
        table_row = get_dotnet_table_row(pe, dnfile.mdtable.TypeDef.number, nested_class_table[index])
        if table_row is None:
            return typedef.TypeNamespace, tuple(typedef_name[::-1])

        enclosing_name = table_row.TypeName
        typedef_name.append(enclosing_name)

        return table_row.TypeNamespace, tuple(typedef_name[::-1])

    else:
        return typedef.TypeNamespace, (typedef.TypeName,)