En gros, à protéger tes assemblies/exécutables contre le reverse engineering et bien d'autres choses.
http://msdn.microsoft.com/fr-fr/libr...(v=vs.90).aspx
En gros, à protéger tes assemblies/exécutables contre le reverse engineering et bien d'autres choses.
http://msdn.microsoft.com/fr-fr/libr...(v=vs.90).aspx
...ce qui concerne très très très peu de monde. Et rarement dans du code .Net :D
Sleeping all day, sitting up all night
Poncing fags that's all right
We're on the dole and we're proud of it
We're ready for 5 More Years
Apparemment, c'est pour répondre aux inquiétudes du management : "mais si le code MSIL est intégré dans l'exécutable, tout le monde va pouvoir le lire et désassembler mon code !"
Disons qu'il y a un fond de vérité : de l'IL avec toute la structure des classes, les noms de fonctions et de variables c'est quand-même vachement plus facile à reverse-engineerer que du x86 compilé sans infos de debug.
C'est le même genre de préoccupation qui refroidit certains utilisateurs potentiels d'OpenCL, qui ne veulent pas que leur code passe en clair pour être compilé à la volée.
D'ailleurs il parait que c'est le cas de développeurs de jeux/moteurs graphiques. C'est vrai ou c'est des conneries ?
Si c'est le cas je ne comprends pas pourquoi, vu que ça a toujours marché comme ça avec Cg/HLSL/GLSL...
Oui, le code est facilement "lisible" au niveau dotnet, c'est même MS qui te fournit les outils pour le lire
Pour Dotfuscator, faut avoir une version autre qu'express il me semble, et apparement, il faut build directement avec l'outil :
http://msdn.microsoft.com/en-us/libr...=vs.80%29.aspx
Avec DirectX tu peux pré-compiler ton code HLSL, et tu inclus le produit dans ton exécutable. Le principal intérêt c'est que les temps de chargement sont réduits, mais la conséquence c'est que ça offusque aussi le code.
Avec OpenGL c'est possible depuis la version 4 si je ne dis pas de connerie. Sauf que comme le résultat est hardware-specific ça ne sert à rien (à part mettre le résultat en cache la première fois que le jeu est lancé pour accélérer les chargements les fois suivantes).
Et Cg, ben Cg c'est mort.
Rust fanboy
Bon, pour mon cas, dotfuscator je peux l'oublier. je ne peux pas déployer mon assembly dans une des applis de MS, car ce dernier fait de la reflection de code pour savoir comment déployer mon assembly.
Dans tous les cas, ça reste du langage intermédiaire type "assembleur" un peu comme à l'époque de DirectX 7 ou l'extension ARB_fragment_program d'OpenGL. (Cg, tu précompiles en langage intermédiaire aussi).
La syntaxe c'est pas du C, mais ça se lit très bien, surtout pour du code de calcul.
J'ai un peu du mal a saisir l'utilite et le fonctionnement. Je touche pas beaucoup de .net, mais de ma comprehension de la techno, tu compiles pas en langage machine mais en langue intermediaire et t'as le clr qui interprete ton code. C'est bien ca? De plus, si je ne me fourvoie pas, la techno est faite pour etre "decompilee" facilement (via l'object browser de visual studio ou des logiciels tiers genre ILSpy). Partant de la, quel est l'interret pour un dev de choisir .NET plutot qu'un compiler qui compile en langage machine pour compiler du code "sensible"?
Facilité de langage/IDE, contrainte imposée par le client, ne pas faire une moitié de programme dans un langage puis dans une autre, etc.
De nombreuses raisons vont t'amener à choisir une plateforme/langage plutôt qu'une autre, et à mon avis la "facilité de décompilation" en est rarement un.
Du coup pour ceux qui veulent rendre difficile de reverse engineering, l'obfuscation est une bonne solution. Mais ça n'empêche pas le désassemblage, et un exe Win32 natif n'en est pas protégé non plus.
Pour les rares cas où il y a besoin d'aller plus loin, il y a d'autres solutions, et elles s'appliquent aussi bien aux assemblies .Net qu'aux fichiers natifs.
Disons qu'effectivement, avec l'introspection, ça leake beaucoup d'info sur les objets.
Sinon, gluglu, je crois que à peu près tous les studios de jeu se sont convaincus qu'il n'y avait pas de grands secrets dans leurs shaders et leur code en général.
Si obfuscation il y a, c'est contre le piratage, via Starforce par exemple. Ou dans les bootloaders/OS des consoles.
Sleeping all day, sitting up all night
Poncing fags that's all right
We're on the dole and we're proud of it
We're ready for 5 More Years
Ca existe encore cette saloperie de Starforce ? Ca me rappelle l'époque (vers 2009 non?) ou quand tu achetai un jeu protégé par starforce tu avais moins de chances de réussir à jouer qu'en le piratant. Ou Assassin's Creed II qui se vantait d'avoir l'anti piratage le plus performant, en deux semaines il était cassé.
Il fallait émuler le serveur ubisoft en local et rediriger le jeu dessus via le fichier hosts.
Le bon vieux temps ou, je le confesse, il m'arrivait de ne pas acheter mes jeux
anecdoteInutile end;
La boîte existe encore mais la techno n'a plus rien à voir avec les hacks kernel et autres filtres de device CD de l'époque, maintenant tu uploades ton exe sur leur serveur et il te revient (méchamment) obfusqué.
Bon exemple : ils ne filent pas leur obfuscateur, ça rendrait le reversing des jeux Starforcés plus simple.
Sleeping all day, sitting up all night
Poncing fags that's all right
We're on the dole and we're proud of it
We're ready for 5 More Years
Tiens, vous connaissez des frameworks de test unitaire qui prennent en charge les tests de compilation?
Jenkins par exemple.
Sleeping all day, sitting up all night
Poncing fags that's all right
We're on the dole and we're proud of it
We're ready for 5 More Years
"Tests de compilation" comme dans "est-ce que mes tests compilent ?" ou bien comme "est ce le test, qui fait de la compilation, passe correctement ?".
Dans le premier cas : Maven, Ant, Gradle, etc...
"Tout est vrai, tout existe, il suffit d'y croire."
Dieu. (enfin… je crois)
OpenGL 4.5 est sorti et intègre enfin EXT_direct_state_access
Je crois que cette extension existait déjà alors qu'OpenGL 3 n'était même pas sorti.
Rust fanboy
J'ai des static_assert, je souhaite vérifier qu'ils se déclenchent correctement. Donc plutôt ton second cas si j'ai bien compris.
J'ai eu un problème chelou sur visual studio l'autre jour.
En C++ quand on veut faire un lambda dans une fonction membre et accéder aux autres membres de l'objet, il faut spécifier 'this' dans la liste de capture. Cette fois j'avais un lambda (A) dans un lambda (B ) dans une fonction membre. Le lambda A capture this, et utilise certains membres de l'objet. Le lambda B utilise aussi certains membres de l'objet + des variables du lambda A, donc j'avais simplement mis [&] comme capture. Ça compile parfaitement, et ça plante à l’exécution lorsque le code utilise les membres de l'objet, erreur d'adresse.
Je remarque ensuite que j'ai oublié 'this', je change en [&, this] et là tout roule. Bref c'est quand même étrange que ça compile sans capturer explicitement this non ?
Tiens ce mec a créé de jolies animations si quelqu'un veut comprendre deux/trois trucs sur le pipeline graphique : http://simonschreibt.de/gat/renderhell/
Rust fanboy
Bonjour,
Je dois développer le site d'un pote, vous pourriez me conseiller un framework PHP (pas d'usines à gaz svp) pour séparer le code de la présentation svp ?
J'en avait utilisé un il y a quelques années...Dans les fichier html (templates) il fallait mettre des variables genre {UnTruc}
Et dans le code PHP il fallait appeller une fonction pour remplacer ces variables par de vraies données.
C'était bien pratique...
Salut,
Ici c'est pour les gros barbus, le web c'est par ici http://forum.canardpc.com/threads/72...nt-des-cookies
Sinon on est plusieurs canards à aimer Symfony ou Silex comme framework ou microframework.
Oui Symfony j'en ai entendu parler, c'est pas trop lourd à mettre en place et à prendre en main ? Parceque c'est juste pour un petit site (3 ou 4 pages max)
Si Symfony c'est assez complexe, je te conseil plutôt Silex http://silex.sensiolabs.org/ pour un petit projet.
ok thanx je vais y jeter un oeil...
Coin les canards,
quelqu'un a-t-il de l'expérience sur les MMF utilisés comme mémoire partagée ? En particulier, je m'interroge sur les performances d'accès aux données comparées à un accès direct dans la mémoire propre du processus.
Précisémment, j'ai besoin de partager la race de données en mémoire entre plusieurs processus, et j'ai besoin de perfos. Du coup, est-ce que je synchronise ce qui est en mémoire entre les processus ou est-ce que je tente d'utiliser directement la mémoire partagée.
P.S.1 Je serais sans doute parti sur du .NET
P.S.2 Je ferais un test le cas échéant...
Je ne suis pas sur de comprendre la question, mais si tu évites le faux partage (des données écrites par des process différents dans la même ligne de cache), c'est la solution la plus efficace.
Une fois que tu as fait le mapping, les accès sont aussi rapides que si tu avais deux threads du même process.
Dans tous les cas c'est à toi de gérer la synchronisation, mais ça c'est une question de correction, pas de perfs.
Merci gluglu
oui, oeuf corse: un seul process écrit. D'ailleurs un seul process créera le MMF et écrira dedans, les autres feront de la lecture voire du copy-on-write.
Finalement, la question sera : performance d'un accès à un tableau versus accès via un stream (.NET, pas de pointeurs toussa).
A moins que je puisse demander à un objet .NET managé de s'allouer dans le MMF mais faut pas rêver, je ne suis plus en C++... d'ailleurs c'est peut-être moins casse-gueule aussi...