Comment modifier la sortie d'un programme dont vous n'avez pas le code source
Dans notre entreprise, nous avons un petit programme (taille .exe 500Kb) qui fait des calculs mathématiques et à la fin, il diffuse le résultat sur une feuille de calcul Excel que nous utilisons pour continuer notre flux de travail.
Je souhaite modifier les colonnes, le format d'espacement et ajouter la logique VBA, etc. sur la feuille de calcul Excel, mais comme ces paramètres ne sont pas configurables dans ce programme, il me semble que le seul moyen de le modifier consiste à décomposer/désosser le .exe
Personne ne sait dans quelle langue il a été programmé, la seule chose que nous connaissons est:
- Développé il y a plus de 20 ans
- Développeur retiré il y a 10 ans
- Application GUI
- Fonctionne de façon autonome
- Taille 500Kb
Avez-vous des suggestions sur les options dont je dispose pour faire face à ce genre de problèmes? La rétro-ingénierie est-elle la seule option ou existe-t-il une meilleure approche?
La rétro-ingénierie peut devenir très difficile, encore plus si vous ne voulez pas seulement comprendre la logique du programme, mais la modifier et la recompiler. Donc la première chose que j'essaierais est de chercher une solution différente.
Je souhaite modifier les colonnes, le format d'espacement et ajouter la logique VBA, etc. sur la feuille de calcul Excel
Si c'est la seule chose que vous voulez et que le calcul effectué par le programme est correct, pourquoi ne pas écrire un programme dans la langue de votre choix (peut-être une macro Excel) qui appelle votre ancien "exe", prend la sortie et la traite plus loin.
En plus des réponses déjà données par Doc Brown et Telastyn, je voudrais suggérer une approche alternative (sous l'hypothèse que c'est critique pour la mission).
Si vous ne connaissez pas les calculs qu'il effectue et que les calculs sont (quelque peu) critiques pour la mission: déduisez la logique d'origine dans le .exe fichier par tous les moyens nécessaires. Décodez-le en utilisant un décompilateur/désassembleur comme IDA si nécessaire. Embaucher un consultant (ou un lot de consultants) si nécessaire.
Bien sûr, contournez-le pour l'instant en utilisant leur solution, mais ne le laissez pas.
La raison que je suggère est la suivante: vous avez admis que les calculs sont très complexes (selon un ingénieur à qui vous avez parlé). C'est également essentiel à la mission. Donc, si en quelque sorte l'original .exe cesse de fonctionner en raison de changements dans les plates-formes que vous avez (peut-être que le support 16 bits est abandonné?), vous venez de perdre un élément essentiel de la connaissance .
Maintenant, je ne crains pas de perdre le .exe, mais de perdre les connaissances qu'il encode. Cette connaissance doit être récupérée.
Comme précédemment: si ces connaissances sont déjà disponibles, assurez-vous de les noter dans un format qui ne sera pas perdu de si tôt. Sinon, récupérez-le et notez-le.
Demandez au programmeur d'origine, si possible.
Il y a quelques semaines, j'ai été contacté par une entreprise avec laquelle je travaillais il y a 10 ans avec la même question concernant un fichier mdb développé au milieu des années 90.
Avez-vous des suggestions sur les options dont je dispose pour faire face à ce genre de problèmes?
Si tout ce que vous cherchez à faire est de modifier la sortie, pourquoi ne pas simplement utiliser la composition?
Au lieu de modifier la boîte noire à laquelle vous ne pouvez pas accéder facilement, vous créez un nouveau programme qui prend la sortie Excel et modifie la mise en forme/colonne trop. Ensuite, vous pouvez créer un nouvel exe/script qui appelle les deux programmes dans l'ordre, il apparaît donc à l'utilisateur final qu'il n'y a qu'un seul programme qui fait tout le travail - même si ce sont deux étapes distinctes sous le capot.
Écrivez un simple wrapper autour du programme, capturant sa sortie. Il n'est pas complexe de faire autant de langages ( Java , C++ , Python , . NET , par exemple) ont des moyens pour cela. Analysez la sortie et générez-en une autre, sous la forme souhaitée. L'utilisateur appellera votre nouveau programme. L'ancien exécutable restera à côté de lui, ou même peut être extrait automatiquement de la ressource, avant de l'invoquer.
Cette solution ne fonctionne bien sûr que lorsque la sortie est bien structurée et donc facile à analyser.
Que ce soit une application graphique, ce n'est pas un problème de blocage. Vous pouvez le lancer, générer une sortie, puis le post-traiter automatiquement à la fin de cette interface graphique.
Il y a des entreprises qui se spécialisent exactement dans ce genre de problème. Ils utilisent du code propriétaire pour décompiler le code natif dans un langage de haut niveau, puis appliquent l'expertise humaine pour le rendre utile (par exemple en donnant aux variables des noms appropriés).
Il y a quelques années, mon employeur l'a utilisé pour migrer du code de mainframe S/390 natif sur des serveurs Linux. Nous leur avons donné un binaire, ils nous ont donné le code source en C.
Que cela soit nécessaire dans votre cas, cela dépend de vous. Si vous ne vous souciez que du format de la sortie, vous pouvez simplement masser la sortie après sa production. Cependant, comme d'autres l'ont souligné, la logique métier cachée dans un blob binaire pourrait être un risque permanent.
Écrivez des tests qui exercent autant de cas que possible sur l'ancien code. Trouvez des cas d'angle, testez une entrée incorrecte et testez une entrée correcte.
Épinglez la sortie correcte dans divers cas, puis essayez d'écrire une implémentation qui satisfait les mêmes tests.
Je ne voudrais pas emprunter la voie du reverse engineering. Il est incroyablement compliqué d'inverser le code machine, et vous devriez déjà savoir quel est le but de l'exe. L'ingénierie inverse est un peu trop de travail pour ce que vous recherchez.
Si le logiciel a été développé par un gars il y a 20 ans, ce n'est probablement pas quelque chose qui prend beaucoup de puissance moderne. Un programme GUI qui a étendu la machine il y a 20 ans s'enregistrera à peine sur une machine moderne, donc vous cherchez probablement quelque chose qui est relativement simple à reproduire.
Essayez de désosser l'exe. Dans le seul but de trouver la logique de calcul ou au moins pour avoir une bonne idée de ce qu'elle fait réellement et si votre rétro-ingénierie peut vous y amener, vous pouvez écrire une nouvelle application basée sur cette logique de calcul. A part ça, je ne vois pas d'autre issue.
Plus facile à dire qu'à faire, l'ingénierie inverse d'un exe créé il y a 20 ans est un véritable défi.