Strumenti / strategia di offuscamento .NET [chiuso]

Il mio prodotto ha diversi componenti: ASP.NET, App di Windows Form e Servizio Windows. Il 95% circa del codice è scritto in VB.NET.

Per motivi di proprietà intellettuale, devo offuscare il codice e fino ad ora ho usato una versione di dotfuscator che ora ha più di 5 anni. Sto pensando che è tempo di passare a uno strumento di nuova generazione. Quello che sto cercando è un elenco di requisiti che dovrei considerare quando cerco un nuovo offuscatore.

Quello che so dovrei cercare finora:

• Serializzazione / De-serializzazione . Nella mia soluzione attuale, dico semplicemente allo strumento di non offuscare i membri dei dati di una classe perché il dolore di non poter caricare dati precedentemente serializzati è semplicemente troppo grande.
• Integrazione con il processo di compilazione
• Lavorare con ASP.NET . In passato, ho riscontrato questo problema a causa della modifica dei nomi DLL (spesso ne hai uno per pagina) - che non tutti gli strumenti gestiscono bene.

Di nuovo con .Net 1.1 l'offuscamento era essenziale: decompilare il codice era facile, e si poteva passare dall'assemblaggio, a IL, al codice C # e farlo compilare di nuovo con pochissimo sforzo.

Ora con .Net 3.5 non ne sono affatto sicuro. Prova a decompilare un assembly 3.5; quello che ottieni è molto lontano dalla compilazione.

Aggiungi le ottimizzazioni da 3.5 (molto meglio di 1.1) e il modo in cui i tipi anonimi, i delegati e così via vengono gestiti dalla riflessione (sono un incubo da ricompilare). Aggiungi espressioni lambda, compilatore "magico" come Linq-sintassi e varfunzioni C # 2 yield(che si traducono in nuove classi con nomi illeggibili). Il tuo codice decompilato finisce molto per essere compilabile.

Un team di professionisti con molto tempo potrebbe ancora riprogrammarlo, ma lo stesso vale per qualsiasi codice offuscato. Il codice che hanno ottenuto sarebbe irraggiungibile e altamente probabile che fosse molto difettoso.

Consiglierei di firmare le chiavi dei tuoi assembly (il che significa che se gli hacker possono ricompilarne uno devono ricompilare tutto) ma non credo che l'offuscamento ne valga la pena.

Abbiamo provato un certo numero di offuscatori. Nessuno di essi funziona su un'app client / server di grandi dimensioni che utilizza servizi remoti. Il problema è che client e server condividono alcune dll e non abbiamo trovato alcun offuscatore in grado di gestirlo.

Abbiamo provato DotFuscator Pro, SmartAssembly, XenoCode, Salamander e diverse piccole app temporali i cui nomi mi sfuggono.

Francamente, sono convinto che l'offuscamento sia un grande trucco.

Anche i problemi che affronta non è del tutto un vero problema. L'unica cosa che devi davvero proteggere è stringhe di connessione, codici di attivazione, cose sensibili alla sicurezza del genere. Questa assurdità che un'altra società sta per decodificare tutta la tua base di codice e creare un prodotto concorrente da esso è qualcosa dall'incubo di un manager paranoico, non dalla realtà.

Sono "Knee Deep" in questo momento, cercando di trovare una buona soluzione. Ecco le mie impressioni finora.

Xenocode - Ho una vecchia licenza per Xenocode2005 che usavo per offuscare i miei assiemi .net 2.0. Ha funzionato bene su XP ed è stata una soluzione decente. Il mio progetto attuale è .net 3.5 e sono su Vista, il supporto mi ha detto di provarlo, ma la versione del 2005 non funziona nemmeno su Vista (crash), quindi io e ora devo comprare 'PostBuild2008' a un prezzo incredibile di $ 1900. Questo potrebbe essere un buon strumento ma non lo scoprirò. Troppo caro.

Reactor.Net - Questo è un prezzo molto più interessante e ha funzionato bene sul mio eseguibile standalone. Anche il modulo Licensing è stato bello e mi avrebbe risparmiato un sacco di sforzi. Sfortunatamente, manca una caratteristica chiave e questa è la capacità di escludere cose dall'offuscamento. Ciò rende impossibile ottenere il risultato di cui avevo bisogno (unire più assiemi, offuscarne alcuni, non offuscare altri).

SmartAssembly - Ho scaricato l'Eval per questo e ha funzionato perfettamente. Sono stato in grado di ottenere tutto ciò che desideravo e l'interfaccia era di prima classe. Il prezzo è ancora un po 'pesante.

Dotfuscator Pro - Impossibile trovare il prezzo sul sito Web. Attualmente in discussione per ottenere un preventivo. Sembra inquietante.

Confuser - un progetto open source che funziona abbastanza bene (confondere ppl, proprio come suggerisce il nome).

Nota: Secondo quanto riferito, ConfuserEx è "rotto" in base al numero 498 sul repository GitHub.

Se stai cercando uno gratuito, potresti provare DotObfuscator Community Edition fornito con Visual Studio o Eazfuscator.NET .

Dal 29 giugno 2012 , Eazfuscator.NET è ora commerciale. L'ultima versione disponibile gratuita è 3.3.

Ho usato l'assemblaggio intelligente. Fondamentalmente, scegli una dll e la restituisce offuscata. Sembra funzionare bene e finora non ho avuto problemi. Molto, molto facile da usare.

Ho provato quasi tutti gli offuscatori sul mercato e SmartAssembly è il migliore secondo me.

Ho anche usato SmartAssembly. Ho scoperto che Ezrinz .Net Reactor è molto meglio per me su applicazioni .net. Offusca, supporta Mono, unisce assiemi e ha anche un modulo di licenza molto carino per creare una versione di prova o collegare la licenza a una macchina particolare (molto facile da implementare). Il prezzo è anche molto competitivo e quando avevo bisogno di supporto erano veloci. Eziriz

Giusto per essere chiaro, sono solo un cliente a cui piace il prodotto e che non è in alcun modo collegato con l'azienda.

La risposta breve è che non puoi.

Esistono vari strumenti che renderanno più difficile la lettura del codice da parte di qualcuno - alcuni dei quali sono stati indicati da altre risposte.

Tuttavia, tutto ciò che fanno è rendere più difficile la lettura: aumentano la quantità di sforzo richiesto, tutto qui. Spesso questo è abbastanza per scoraggiare i lettori occasionali, ma qualcuno che è determinato a scavare nel tuo codice sarà sempre in grado di farlo.

Abbiamo un'app multilivello con un'interfaccia asp.net e winform che supporta anche i telecomandi. Non ho avuto problemi con l'utilizzo di qualsiasi offuscatore ad eccezione del tipo di crittografia che genera un caricatore che può essere problematico in tutti i modi inaspettati e non ne vale la pena secondo me. In realtà il mio consiglio sarebbe più sulla falsariga di "Evitare la crittografia di offuscatori di tipo caricatore come la peste". :)

Nella mia esperienza, ogni offuscatore funzionerà bene con qualsiasi aspetto di .net incluso asp.net e remoting, devi solo entrare in intimità con le impostazioni e imparare fino a che punto puoi spingerlo in quali aree del tuo codice. E prenditi il ​​tempo per tentare il reverse engineering su ciò che ottieni e vedere come funziona con le varie impostazioni.

Abbiamo usato diversi nel corso degli anni nelle nostre app commerciali e ci siamo affidati a Spices obfuscator da 9rays.net perché il prezzo è giusto, fa il lavoro e hanno un buon supporto anche se non abbiamo davvero bisogno del supporto negli anni ma per essere onesti Non penso sia importante quale offuscatore usi, i problemi e la curva di apprendimento sono tutti uguali se vuoi che funzioni correttamente con il telecomando e asp.net.

Come altri hanno già detto, tutto ciò che stai realmente facendo è l'equivalente di un lucchetto, tenendo fuori gente altrimenti onesta e rendendo più difficile semplicemente ricompilare un'app.

Le licenze sono di solito l'area chiave per la maggior parte delle persone e dovresti sicuramente utilizzare un qualche tipo di sistema di certificazione con firma digitale per le licenze. La tua più grande perdita verrà dalla condivisione casuale delle licenze se non hai un sistema intelligente in atto, le persone che rompono il sistema di licenze non avrebbero mai acquistato in primo luogo.

È davvero facile andare troppo lontano e avere un impatto negativo sui tuoi clienti e sulla tua attività, fare ciò che è semplice e ragionevole e quindi non preoccuparti.

Negli ultimi due giorni ho sperimentato Dotfuscator Community Edition advanced (un download gratuito dopo aver registrato il CE di base fornito in bundle con Visual Studio).

Penso che il motivo per cui più persone non usano l'offuscamento come opzione predefinita è che è una seccatura seria rispetto al rischio. Sui progetti di test più piccoli ho potuto ottenere il codice offuscato in esecuzione con molto sforzo. L'implementazione di un semplice progetto tramite ClickOnce è stata problematica, ma realizzabile dopo aver firmato manualmente i manifest con mage. L'unico problema era che in caso di errore la traccia dello stack tornava offuscata e il CE non ha un deobfuscatore o un chiarificatore confezionato.

Ho cercato di offuscare un vero progetto basato su VSTO in Excel, con l'integrazione di Virtual Earth, molte chiamate al servizio web e un contenitore IOC e molta riflessione. Era impossibile.

Se l'offuscamento è davvero un requisito fondamentale, è necessario progettare l'applicazione tenendo presente questo aspetto fin dall'inizio, testando le build offuscate man mano che si procede. Altrimenti, se si tratta di un progetto abbastanza complesso, finirai con un grave dolore.

Crypto Obfuscator risolve tutti i tuoi dubbi e scenari. Esso:

1. Esclude automaticamente tipi / membri dall'offuscamento in base alle regole. I tipi / campi serializzati sono uno di questi.
2. Può essere integrato nel processo di compilazione utilizzando MSBUild.
3. Supporta progetti ASP.Net.

Di recente ho provato a convogliare l'output di un offuscatore libero in un altro offuscatore libero - vale a dire Dotfuscator CE e il nuovo offuscatore Babel su CodePlex. Maggiori dettagli sul mio blog .

Per quanto riguarda la serializzazione, ho spostato quel codice in un'altra DLL e l'ho incluso nel progetto. Ho pensato che non c'erano segreti lì dentro che non fossero nell'XML, quindi non aveva bisogno di offuscamento. Se esiste un codice serio in quelle classi, l'uso di classi parziali nell'assemblaggio principale dovrebbe coprirlo.

Dovresti usare ciò che è più economico e meglio conosciuto per la tua piattaforma e chiamarlo un giorno. L'offuscamento di linguaggi di alto livello è un problema difficile, perché i flussi di codice operativo VM non soffrono dei due maggiori problemi che i flussi di codice operativo nativo fanno: identificazione della funzione / metodo e aliasing del registro.

Quello che dovresti sapere sull'inversione di bytecode è che è già pratica standard per i tester di sicurezza rivedere il codice X86 e trovare vulnerabilità in esso. In X86 grezzo, non puoi nemmeno trovare funzioni valide, e tanto meno tenere traccia di una variabile locale durante una chiamata di funzione. In quasi nessuna circostanza gli invertitori di codice nativi hanno accesso alla funzione e ai nomi delle variabili --- a meno che non stiano rivedendo il codice Microsoft, per il quale MSFT fornisce utili informazioni al pubblico.

"Dotfuscation" funziona principalmente per funzione di codifica e nomi di variabili. Probabilmente è meglio farlo che pubblicare codice con informazioni a livello di debug, in cui Reflector sta letteralmente rinunciando al codice sorgente. Ma qualsiasi cosa tu faccia al di là di questo rischia di ottenere rendimenti decrescenti.

Non ho avuto problemi con Smartassembly.

È possibile utilizzare "Dotfuscator Community Edition", disponibile per impostazione predefinita in Visual Studio 2008 Professional. Puoi leggerlo a:

http://msdn.microsoft.com/en-us/library/ms227240%28VS.80%29.aspx
http://www.preemptive.com/dotfuscator.html

La versione "Professional" del prodotto costa ma è migliore.

Hai davvero bisogno del tuo codice offuscato? Di solito, l'applicazione viene decompilata molto poco, a meno che non venga utilizzata per motivi di sicurezza. Se sei preoccupato che le persone "rubino" il tuo codice, non esserlo; la stragrande maggioranza delle persone che guardano il tuo codice sarà a scopo di apprendimento. Ad ogni modo, non esiste una strategia di offuscamento totalmente efficace per .NET: qualcuno con abbastanza abilità sarà sempre in grado di decompilare / modificare la tua applicazione.

Evitare il reattore. È completamente inutile (e sì, ho pagato per una licenza). Xenocode è stato il migliore che abbia mai incontrato e ha acquistato anche una licenza. Il supporto è stato molto buono ma non ne ho avuto bisogno in quanto ha funzionato. Ho testato tutti gli offuscatori che ho trovato e la mia conclusione è che lo xenocodice era di gran lunga il più robusto e ha fatto il miglior lavoro (anche la possibilità di postare il tuo exe .NET in un ex nativo che non ho visto da nessun'altra parte).

Esistono due differenze principali tra reattore e xenocodice. Il primo è che Xenocode funziona davvero. Il secondo è che la velocità di esecuzione dei tuoi assiemi non è diversa. Con il reattore era circa 6 milioni di volte più lento. Ho anche avuto l'impressione che il reattore fosse un'operazione individuale.

Ho scoperto che Agile.Net offre una protezione abbastanza buona per il tuo .Net Assembly perché offre non solo offuscamento ma anche crittografia. Scarica un percorso gratuito.
http://secureteam.net/NET-Code-Protection.aspx http://secureteam.net/downloads.aspx

Ho offuscato il codice nella stessa applicazione da .Net 1, ed è stato un grosso mal di testa dal punto di vista della manutenzione. Come hai detto, il problema della serializzazione può essere evitato, ma è davvero facile fare un errore e offuscare qualcosa che non volevi offuscare. È facile interrompere la build o modificare il modello di offuscamento e non poter aprire vecchi file. Inoltre, può essere difficile scoprire cosa è andato storto e dove.

La nostra scelta è stata Xenocode, e se dovessi fare di nuovo la scelta oggi preferirei non offuscare il codice o utilizzare Dotfuscator.

Ecco un documento degli stessi Microsoft. Spero che aiuti ..., è del 2003, ma potrebbe essere ancora rilevante.

Stiamo usando SmartAssembly sul nostro client Windows. Funziona bene.

Aggiunge anche alcuni problemi extra. La stampa dei nomi delle classi in file di registro / eccezioni deve essere offuscata. E ovviamente non è possibile creare una classe dal suo nome. Quindi è una buona idea dare un'occhiata al tuo cliente e vedere quali problemi puoi ottenere offuscando.

Tutto dipende dal linguaggio di programmazione che usi. Leggi l'articolo: codice offuscato

il modo gratuito sarebbe usare dotfuscator da Visual Studio, altrimenti dovresti uscire e comprare un offuscatore come Postbuild ( http://www.xenocode.com/Landing/Obfuscation.aspx )

Ho dovuto usare un offuscamento / protezione delle risorse nel mio ultimo rpoject e ho trovato Crypto Obfuscator come uno strumento piacevole e semplice da usare. Il problema di serializzazione è solo una questione di impostazioni in questo strumento.

Esiste una buona versione open source chiamata Obfuscar. Sembra funzionare bene. Tipi, proprietà, campi, metodi possono essere esclusi. L'originale è qui: https://code.google.com/p/obfuscar/ , ma dal momento che sembra non essere più aggiornato

Potresti anche voler esaminare nuove tecnologie di protezione del codice come Metaforic e ViLabs e nuove tecnologie di protezione della copia del software come ByteShield . Divulgazione: lavoro per ByteShield.

Uso anche lo Smartassembly. Tuttavia, non so come funzioni per un'applicazione web. Tuttavia, vorrei sottolineare che se la tua app utilizza la protezione del tipo shareware, assicurati di non controllare una licenza con un ritorno booleano. è troppo facile byte crack. http://blogs.compdj.com/post/Binary-hack-a-NET-executable.aspx

SmartAssembly è fantastico, sono stato utilizzato nella maggior parte dei miei progetti

Ho provato la versione demo di Eziriz .... Mi è piaciuto. Ma non ho mai portato il software.

Offuscare non è una vera protezione.

Se si dispone di un file Exe .NET, esiste una soluzione FAR migliore .

Uso Themida e posso dire che funziona molto bene.

L'unico inconveniente di Themida è che non può proteggere .NET Dlls. (Protegge anche il codice C ++ in Exe e DLL)

Themida è di gran lunga più economico degli offuscatori qui menzionati ed è il migliore lotta alla pirateria di protezione sul mercato. Crea una macchina virtuale dove vengono eseguite parti critiche del codice ed esegue diversi thread che rilevano manipolazioni o punti di interruzione impostati da un cracker. Converte .NET Exe in qualcosa che Reflector non riconosce nemmeno più come assembly .NET.

Si prega di leggere la descrizione dettagliata sul loro sito Web: http://www.oreans.com/themida_features.php

Ho provato un prodotto chiamato Rummage e fa un buon lavoro nel darti un po 'di controllo ... Anche se manca molte cose che offre Eziriz ma il prezzo per Rummage è troppo buono ...