如何在共享库中隐藏导出的符号名称

Question

对于 VC，我可以编写一个 DEF 文件并使用“NONAME”指令在 dll 的导出表中只保留序号。

如何使用 gcc 和 ELF 格式的共享库做同样的事情？

或者，ELF 共享库中是否有类似 PE 格式 DLL 中的序号的东西？如果没有，我如何在共享库中隐藏导出符号的名称？

========================================

更新：一些附加说明：

在 Windows 中，您可以通过仅放置一个具有空名称的整数 ID（序数）来导出函数。

为了显示它，dll 导出表的正常布局如下所示：http://home.hiwaay.net/~georgech/WhitePapers/Exporting/HowTo22.gif。

“NONAME”看起来像这样：http://home.hiwaay.net/~georgech/WhitePapers/Exporting/HowTo23.gif。

请注意，第二张图片中的函数名称为“N/A”。这是一个完整的解释：hxxp://home.hiwaay.net/~georgech/WhitePapers/Exporting/Exp.htm。

========================================

更新：非常感谢所有给我建议的人。最后，我决定在 linux/posix 平台上继续使用静态库。 但是将小的“特殊部分”（它使用一些不适合静态库的功能，例如：TLS Slot 等）提取到普通的共享库。因为小型普通共享库只做很少的事情，而这些工作完全不敏感，所以没有必要隐藏/隐藏它的 API。

我认为这是解决我的问题的最简单方法：-D

Answer 1

当您想长期维护代码时，关于 attribute ((visibility ("hidden"))) 的先前答案很好，但是如果您只有几个符号想要可见并且想要快速修复...在您想要导出使用的符号上，添加

__attribute__ ((visibility ("default"))) 

然后你可以将-fvisibility=hidden 传递给编译器

这里有详尽的解释：

http://gcc.gnu.org/wiki/Visibility

编辑：另一种方法是构建静态库/存档（使用ar -cru mylib.a *.o 制作.a 存档）或根据此combine two GCC compiled .o object files into a third .o file 将对象组合成单个对象文件

如果您问“为什么要组合目标文件而不是仅仅制作静态库？” ...因为链接器将 .o 文件与 .a 文件区别对待（我不知道为什么，就是这样），特别是它允许您将 .o 文件链接到共享库或二进制文件中，即使所有符号都被隐藏了（即使是您正在使用的符号）这具有减少启动时间（少一个 DSO 和要查找的符号少得多）和二进制大小（符号通常占尺寸的约 20%，剥离只处理其中的一半——只是外部可见的部分）

对于二进制文件strip --strip-all -R .note -R .comment mybinary

图书馆strip --strip-unneeded -R .note -R .comment mylib.so

在此处详细了解静态链接的好处：http://sta.li/faq，但他们没有讨论许可问题，这是不使用静态库的主要原因，而且您想隐藏自己的 API ，这可能是个问题

现在我们知道有一个“符号干净”的对象，可以使用我们的组合对象通过链接 private.o 和 public.c 来构建 libpublic.so（它只别名/导出你想要的公共) 到共享库中。

此方法也很适合查找公共 API 中不需要的“额外代码”。如果您将 -fdata-sections -ffunction-sections 添加到您的对象构建中，当您与 -Wl,--gc-sections,--print-gc-sections 链接时，它将删除未使用的部分并打印已删除内容的输出。

编辑 2 - 或者您可以隐藏整个 API 并只为您要导出的函数设置别名

alias ("target")

alias 属性导致声明作为另一个符号的别名发出，必须指定。例如，

void __f () { /* Do something. */; }
void f () __attribute__ ((weak, alias ("__f")));

定义f' to be a weak alias for __f'。在 C++ 中，必须使用目标的错位名称。如果 `__f' 没有在同一个翻译单元中定义，则会出错。

并非所有目标机器都支持此属性。

Answer 2

您可以考虑使用GCC function attribute 来提高可见性并将其隐藏，即在头文件的许多适当位置添加__attribute__((visibility ("hidden")))。

^{然后您将隐藏无用的符号，并保留好的符号。}

这是一个 GCC 扩展（可能被 Clang 或 Icc 等其他编译器支持）。

附录

在 Linux 世界中，共享库应按名称导出函数（或者可能是全局数据），如在头文件中发布的那样。否则，不要将这些函数称为“导出”——它们不是！

如果您绝对希望在共享库中拥有一个函数，该函数可访问但不能导出，您可以通过某种方式注册它（例如，将函数全局数据（例如数组）的某个槽中的指针），这意味着您拥有（或提供）一些函数注册机制。但这不再是导出函数了。

更具体地说，您可以在主程序中拥有一个全局函数指针数组

 // in a global header.h
  // signature of some functions
 typedef void signature_t(int, char*);
 #define MAX_NBFUN 100
 // global array of function pointers
 extern signature_t *funtab[MAX_NBFUN];

然后在您的程序的main.c 文件中

 signature_t *funtab[MAX_NBFUN];

然后在你的共享对象中（例如在myshared.c 文件中编译成libmyshared.so）一个构造函数：

 static my_constructor(void) __attribute__((constructor));

 static myfun(int, char*); // defined elsewhere is the same file
 static void 
 my_constructor(void) { // called at shared object initialization
    funtab[3] = myfun;
 }

稍后在您的主程序（或其他一些共享对象）上可能会调用

 funtab[3](124, "foo");

但我永远不会将这样的东西称为“导出”函数，只有 可访问 函数。

另见 C++ 软件，如 Qt、FLTK、RefPerSys、GCC、GTKmm、FOX-Toolkit、Clang 等......它们都可以通过 plugins 或callbacks 或 closures（在内部，一个好的 C++ 编译器会发出并优化对 C++ lambda expressions 的闭包的调用）。还可以查看 Python、fish、Lua 或 GNU guile 等解释器内部，您可以使用 C++ 代码对其进行扩展。

考虑同时生成机器代码并在您的程序中使用它。 asmjit 或 libgccjit 或 LLVM 或 GNU lightning 之类的库可能会有所帮助。

在 Linux 上，您可能会在运行时生成一些 C++ 代码到 /tmp/generated.cc，通过分叉（可能使用 system(3) 或 popen(3)...）一些命令，例如 g++ -Wall -O -fPIC -shared /tmp/generated.cc -o /tmp/generated-plugin.so，将该代码编译成 /tmp/generated-plugin.so 插件然后使用dlopen(3) 和dlsym(3)。然后使用extern "C" 函数，并查看C++ dlopen minihowto。您可能对__attribute__((constructor)) 感兴趣。

我的个人经验（在过去的项目中，我在这里不允许提及，但在我的网页上提及）是您可以在 Linux 上生成数十万个插件。我仍然敢于提及我的manydl.c 程序（其 GPLv3+ 许可证允许您将其改编为 C++）。

在概念层面，阅读GC handbook 可能会有所帮助。垃圾收集代码（或插件）存在一个微妙的问题。

另请阅读 Drepper 的论文 How to write shared libraries，参见 elf(5)，ld(1)，nm(1)，readelf(1)，ldd(1)，execve(2)，mmap(2)，dlopen(3)，execve(2)，@98765434 @、Advanced Linux Programming、Program Library HOWTO、C++ dlopen mini-howto 和 Ian Taylor 的 libbacktrace。

Answer 3

要在 UNIX 上隐藏导出函数的含义，您可以使用#defines 简单地重命名来混淆它们的名称。像这样：

#define YourGoodFunction_CreateSomething              MeaninglessFunction1
#define YourGoodFunction_AddSomethingElseToSomething  lxstat__
#define YourGoodFunction_SaveSomething                GoAway_Cracker
#define YourGoodFunction_ReleaseSomething             Abracadabra

等等。

在一些功能的情况下，它可以手动完成。如果需要数千个，则应使用代码生成。

1. 获取您的真实函数名称列表，使用 grep、awk、cut 等。
2. 准备一本无意义名称的字典
3. 编写一个脚本（或二进制）生成器，该生成器将输出带有 #defines 的 C 头文件，如上所示。

唯一的问题是如何获取字典。好吧，我在这里看到了几个选项：

• 您可以让您的同事在他们的键盘上随机输入 ;-)
• 生成一个随机字符串，如：read(/dev/urandom, 10-20 bytes) | base64
• 使用一些真正的字典（通用英语，特定领域）
• 收集真实的系统 API 名称并稍作更改：__lxstat -> lxstat__

这仅限于您的想象力。

Answer 4

您可以编写一个版本脚本并将其传递给链接器来执行此操作。

一个简单的脚本如下所示：

testfile.exp:

{
global:
  myExportedFunction1;
  myExportedFunction2;

local: *;
}

然后使用以下选项链接您的可执行文件：

  -Wl,--version-script=testfile.exp

当应用于共享库时，它仍会列出 .so 文件中的符号以进行调试，但无法从库外部访问它们。

Answer 5

我正在寻找相同问题的解决方案。所以，到目前为止，我找不到一个强大的解决方案。但是，作为概念证明，我使用 objcopy 来达到预期的效果。基本上，在编译一个目标文件后，我重新定义了它的一些符号。然后使用翻译后的目标文件构建最终的共享目标文件或可执行文件。结果，可以用作对我的算法进行逆向工程的提示的类/方法名称完全被一些无意义的名称 m1、m2、m3 重命名。

这是我用来确保这个想法有效的测试：

生成文件：

all: libshared_object.so executable.exe

clean:
    rm *.o *.so *.exe

libshared_object.so : shared_object.o
    g++ -fPIC --shared -O2 $< -o $@
    strip $@

shared_object.o : shared_object.cpp interface.h
    g++ -fPIC -O2 $< -c -o $@
    objcopy --redefine-sym _ZN17MyVerySecretClass14secret_method1Ev=m1 \
            --redefine-sym _ZN17MyVerySecretClass14secret_method2Ev=m2 \
            --redefine-sym _ZN17MyVerySecretClass14secret_method3Ev=m3 $@


executable.exe : executable.o libshared_object.so
    g++ -O2 -lshared_object -L. $< -o $@
    strip $@

executable.o : executable.cpp interface.h
    g++ -O2 -lshared_object -L. $< -c -o $@
    objcopy --redefine-sym _ZN17MyVerySecretClass14secret_method1Ev=m1 \
            --redefine-sym _ZN17MyVerySecretClass14secret_method2Ev=m2 \
            --redefine-sym _ZN17MyVerySecretClass14secret_method3Ev=m3 $@

run: all
    LD_LIBRARY_PATH=. ./executable.exe

interface.h

class MyVerySecretClass
{
private:
    int secret_var;
public:
    MyVerySecretClass();
    ~MyVerySecretClass();
    void secret_method1();
    void secret_method2();
    void secret_method3();
};

shared_object.cpp

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>

#include "interface.h"

MyVerySecretClass::MyVerySecretClass()
    : secret_var(0)
{}

MyVerySecretClass::~MyVerySecretClass()
{
    secret_var = -1;
}

void MyVerySecretClass::secret_method1()
{
    ++secret_var;
}

void MyVerySecretClass::secret_method2()
{
    printf("The value of secret variable is %d\n", secret_var);
}

void MyVerySecretClass::secret_method3()
{
    char cmdln[128];
    sprintf( cmdln, "pstack %d", getpid() );
    system( cmdln );
}

executable.cpp

#include "interface.h"

int main ( void )
{
    MyVerySecretClass o;
    o.secret_method1();
    o.secret_method2();
    o.secret_method1();
    o.secret_method2();
    o.secret_method1();
    o.secret_method2();
    o.secret_method3();
    return 0;
}