Comment masquer les symboles exportés nom dans une bibliothèque partagée

Les réponses précédentes concernant attribut ((visibilité ("caché"))) est bon lorsque vous souhaitez conserver le code à long terme, mais si vous n'avez que quelques symboles que vous voulez visible et veulent une solution rapide... Sur les symboles que vous voulez à l'usage de l'exportation, ajouter

__attribute__ ((visibility ("default"))) 

Ensuite, vous pouvez passer -fvisibility=hidden pour le compilateur

Il y a une explication détaillée ici:

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

Edit: Une autre solution serait de construire une bibliothèque statique/archive (en faire .une archive avec ar -cru mylib.a *.o) ou de combiner les objets dans un seul fichier de l'objet en fonction de ce combiner deux GCC compiler .o fichiers objets dans un troisième .o fichier

Si vous posez la question "Pourquoi combiner les fichiers objets au lieu de simplement faire une bibliothèque statique?" ... parce que l'éditeur de liens traiter .o fichiers différemment .un des fichiers (je ne sais pas pourquoi, c'est juste que c'est le cas), plus précisément, il permet de relier un .o fichier dans une bibliothèque partagée ou binaire, même si tous des symboles cachés (même ceux que vous utilisez), Ce qui a l'avantage de réduire les temps de démarrage (un de moins ASM et beaucoup moins de symboles de regarder en haut) et de la taille du binaire (les symboles représentent généralement environ 20% de la taille et de décapage ne s'occupe que de la moitié environ de celle - juste à l'extérieur des parties visibles)

pour les fichiers binaires strip --strip-all -R .note -R .comment mybinary

pour les bibliothèques strip --strip-unneeded -R .note -R .comment mylib.so

Plus sur les avantages de la liaison statique ici: http://sta.li/faq mais ils n'ont pas de discuter des questions de licences, qui sont la principale raison pas à utiliser une bibliothèque statique et puisque vous êtes désireux de cacher votre API, qui peut être un problème de

Maintenant que nous savons qu'ils ont un objet qui est "symbole propre", il est possible d'utiliser la combinaison de notre objet de construire un libpublic.donc, en reliant privé.o et public.c (alias/exportations uniquement ce que vous voulez publique) dans une bibliothèque partagée.

Cette méthode se prête bien à trouver le "code" qui est inutile dans votre API publique. Si vous ajoutez -fdata-sections -ffunction-sections à votre objet construit, quand vous faites le lien avec -Wl,--gc-sections,--print-gc-sections , il permettra d'éliminer les sections inutilisées et imprimer une sortie de ce qui a été retiré.

Edit 2 - ou vous pouvez cacher l'ensemble de l'API et de l'alias uniquement les fonctions que vous souhaitez exporter

alias ("cible")

L'attribut alias les causes de la déclaration qui doit être émise que par un alias pour un autre symbole, qui doit être spécifiée. Par exemple,

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

définit f' to be a weak alias for__f'. En C++, la déformation du nom de la cible doit être utilisé. C'est une erreur si `__f' n'est pas définie dans la même unité de traduction.

Pas tous les ordinateurs cibles à l'appui de cet attribut.

OriginalL'auteur technosaurus

De cacher le sens de l'fonctions exportées sur UNIX, vous pouvez simplement dissimuler leurs noms avec un simple renommage, en utilisant #définit. Comme ceci:

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

et ainsi de suite.

Dans une affaire de quelques fonctions, il peut être fait par les mains. Si vous avez besoin de milliers, vous devez utiliser la génération de code.

1. obtenir la liste de vos noms de fonction, utiliser grep, awk, cut, etc.
2. préparer un dictionnaire le sens des noms de
3. écrire un script (ou binaire) générateur de sortie d'un fichier en-tête C avec #définit comme indiqué ci-dessus.

La seule question est de savoir comment vous pouvez obtenir le dictionnaire. Eh bien, je vois quelques options ici:

• vous pourriez demander à vos collègues au hasard de taper sur leur clavier 😉
• la génération aléatoire des chaînes de caractères comme: la lecture(/dev/urandom, de 10 à 20 octets) | base64
• utiliser certains réel dictionnaire (anglais général, domaine spécifique)
• percevoir un API de système de noms et de les changer un peu: __lxstat -> lxstat__

c'est seulement limité par votre imagination.

OriginalL'auteur Alexander

Je cherchais une solution pour le même problème. Donc, à présent, je ne pouvais pas trouver une solution robuste. Cependant, comme une preuve de concept, j'ai utilisé objcopy pour atteindre les résultats souhaités. En principe, après la compilation d'un fichier de l'objet-je redéfinir certaines de ses symboles. Ensuite, la traduction du fichier d'objet est utilisé pour construire la finale de l'objet partagé ou un exécutable. Comme un résultat de la classe des noms de méthode qui pourrait être utilisée comme un indice de désosser mon algorithme sont complètement rebaptisé par certains sens des noms de m1,m2,m3.

Voici le test que j'ai utilisé pour s'assurer que l'idée fonctionne:

Makefile:

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;
}

OriginalL'auteur Vahagn