Discussion :

[winzzz]

Bonjour,

Comment faut il s'y prendre pour qu'un exécutable puisse s'auto-éditer?

Je voudrais tagger un exe lors de sa première exécution pour qu'il ne puisse plus être exécuté sur une autre machine par la suite.

Je pensais déclarer une constante bien identifiable qqpart dans le code:
const long int id = 0xf81f81f81f81.
Lors de l'execution :
soit le code est égale à 0xf81f81f81f81 -> on le remplace par un id généré par rapport au hardware de la machine.

Le code correspond à l'id hardware, on continue l'exécution du programme sinon exit.

Évidement tout est piratable, etc...

Connaissez vous des sites qui expliquent des techniques s'y rapportant?

[yan]

le plus simple est d'utiliser un tableau de char d'une certaine taille et d'y aller à la bourrin.
dans un .cpp que tu link

static const char myTab[256] ="hello";

Ainsi en cherchant hello directement dans le binaire, tu trouvera la mémoire de myTab (ici c'est 256 octets) et tu peut la modifier.

C'est comme cela que fait Qt pour pouvoir patcher les binaires lors de l'installation.

[3DArchi]

le plus simple est d'utiliser un tableau de char d'une certaine taille et d'y aller à la bourrin.

J'avais pensé à quelque chose comme ça aussi (modification d'une zone identifiée dans le ficher .exe), mais je me demande dans quelle mesure tu ne risques pas d'avoir des problèmes sur des OS récents ou avec des anti-virus pointilleux.

[reptils]

Là tu vas modifier une zone mémoire... si une autre machine load le programme c'est à partir de ce qui est sur disque, donc tu reload le binaire d'origine.

[Davidbrcz]

"HS": La solution la plus simple consiste à utiliser l'outil le plus adapté pour faire cela, donc oublier le C++ et embrasser le lisp

PS: y'avait eu y'a quelques semaines une série de post dans un topic où le sujet était abordé (Mac LAK participait de mémoire). A fouiller

[nikko34]

static const char myTab[256] ="hello";

et aussi faire ce qu'il faut pour éviter que le compilateur te l'optimise allègrement

bon si c'est un truc sécurisé qu'il te faut, bon ben voilà quoi.

[yan]

et aussi faire ce qu'il faut pour éviter que le compilateur te l'optimise allègrement

bon si c'est un truc sécurisé qu'il te faut, bon ben voilà quoi.

ben faut juste qu'il soit utilisé quelque part. Je ne pense pas que le compilateur à le droit de modifier la taille.
En tous cas je ne connais pas d'autre solution, je trouve cela moche mais ca marche... .
Du moment que tu ne touche qu'à cette mémoire ton prog ne risque rien.
Bien penser au \0 quand c'est une string

Là tu vas modifier une zone mémoire... si une autre machine load le programme c'est à partir de ce qui est sur disque, donc tu reload le binaire d'origine.

quand je parle mémoire ici, je parle de modifier la zone de ce tableau dans le binaire. Ouvre n'importe quel exe, tu verra que toute les chaînes du code écrit avec des "" sont visible dans le binaire.

J'avais pensé à quelque chose comme ça aussi (modification d'une zone identifiée dans le ficher .exe), mais je me demande dans quelle mesure tu ne risques pas d'avoir des problèmes sur des OS récents ou avec des anti-virus pointilleux.

De ce que je connait aucun. Tant que ton exe ne fait rien de dangereux, y as pas de problème.
J'ai déjà fait bien pire, mettre des NOP au lieu du teste de la version de windows pour faire marcher une dll sous vista.. pas eu un seule problème.

Comme je l'ai dit, c'est la méthode qu'utilise Qt pour redistribuer des binaire car il y as des path absolue en dure dans certaine dll et dans qmake.

[winzzz]

Je développe justement avec Qt

Je n'ai pas testé la solution que vous proposez car je me suis dit qu'un exécutable n'est pas modifiable en cours d'utilisation (ni le supprimer/déplacer). En tout cas, pas de manière si directe.

Et effectivement ça à l'air de coincer. Je peux retrouver une chaine de caractère dans le bin mais je ne peux pas y accéder en écriture.

Est ce que vous avez une idée pour y parvenir?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
#include <QApplication>
#include <QPushButton>
#include <QDebug>
#include <QFile>
 
static const char myTab[256] ="premiere execution";
const size_t msgSize = 18;
 
int main(int argc, char* argv[])
{
    QApplication app(argc, argv);
 
    qDebug() << myTab;
 
    QFile file(argv[0]);
    qDebug() << "ouverture du binaire :" << file.open(QIODevice::ReadWrite);
 
    char data;
    quint64 fileIndex; 
    size_t stringIndex = 0; 
 
    do {
        file.getChar(&data);
 
        //On repère la chaine de caractères à remplacer
        //ainsi que sa position dans le binaire
        if (data == myTab[stringIndex]) ++stringIndex;
        else {
            fileIndex = file.pos();
            stringIndex = 0;
        }
 
        //Si elle est identifiée, on la remplace
        if (stringIndex == msgSize) {
            file.seek(fileIndex);
            const char *newData = QString("nouvelle execution").toLatin1().constData();
            file.write(newData,msgSize);
        }
 
    } while(!file.atEnd());
 
    file.close();
 
    QPushButton quit("Exit");
    QObject::connect(&quit, SIGNAL(clicked()), &app, SLOT(quit()));
    quit.show();
 
    return app.exec();
}

[yan]

En cour déxécution je ne pense pas que ce soit possible.
Mais rien n'empêche de le faire à l'installation.

Je ne sais pas s'il est possible d'écrire dans le binaire pendant son exécution(il me semble que oui car l'exe ou dll est chargé dans la ram pour son execution). Si c'est cas, il te faudra surement relancer ton exe après la modif.

[Invité]

Est ce que vous avez une idée pour y parvenir?

Le plus simple serait d'avoir un 'lanceur' externe, qui modifie l'exe puis le lance. En gros, tu exécutes le lanceur, qui vérifie que la version est bien 'd'origine', fait le calcul d'authentification de la machine, recopie l'exe, et le lance avant de se terminer...

Ca permet aussi de faire des mises à jour de l'exe, sans avoir besoin d'une routine d'installation.

Mais je ne comprends pas très bien comment cela va te protéger contre la copie (il suffit de faire des copies du lanceur et de la version d'origine, non?)

Francois

[winzzz]

Un lanceur/updater , c'est ce que je vais faire (d'ailleurs j'attends toujours avec impatience la suite de : http://tcuvelier.developpez.com/qt/u...-introduction/)

Le binaire vierge ne serait téléchargeable que via le lanceur/updater (avec un accès restreint id/password).
Le lanceur/updater modifierait immédiatement l'exe vierge sur la base de 2/3 id harware. Ainsi nulle copie de l'exe vierge.

Je pense à une autre technique avec des dll mais je ne suis pas sur que ce soit possible.

- Depuis l'exe, chargement d'une dll qui contient la chaine de caractère à comparer.

- Analyse de son contenu : exécution de l'exe autorisée / interdite ou si dll vierge, édition de la dll.

- Déchargement de la dll pour une éventuelle édition

[jblecanard]

- Déchargement de la dll pour une éventuelle édition

Je dis peut être une connerie, mais il me semble que ça ce n'est pas possible côté processus.