Proteger o código .NET da engenharia reversa?

A ofuscação é uma maneira, mas não pode proteger contra a quebra da segurança de proteção contra pirataria do aplicativo. Como garantir que o aplicativo não seja violado e como garantir que o mecanismo de registro não possa sofrer engenharia reversa?

Também é possível converter um aplicativo C # em código nativo e Xenocode é muito caro.

O C # fornece muitos recursos e é a linguagem ideal para o meu código, portanto, escrever toda a base de código novamente em C ++ está fora de questão.

Os certificados seguros podem ser facilmente removidos dos assemblies assinados no .NET.

Você não pode.

Existem etapas que você pode seguir para torná-lo um pouco mais difícil, mas no final qualquer executável na máquina local é decifrável. Eventualmente, esse código deve ser convertido em código de máquina nativo e todos os aplicativos executáveis ​​ficam vulneráveis.

O que você quer fazer é dificultar o suficiente o crack para não valer o problema das pessoas.

Algumas sugestões que tenho para você ajudar a proteger seu aplicativo:

• Ofusque seu código. Dotfuscator tem uma edição gratuita e vem com o Visual Studio.
• Use chave pública / privada ou criptografia assimétrica para gerar suas licenças de produto. Isso garante que apenas você possa gerar seus códigos de licença. Mesmo se o seu aplicativo estiver com falhas, você pode ter certeza de que eles não estarão liberando um gerador de chaves para o seu aplicativo, porque é impossível reverter o algoritmo de geração de chaves.
• Use um empacotador de terceiros para compactar seu executável .NET em um aplicativo de invólucro Win32 criptografado. Themida é um dos melhores. Isso impede que as pessoas reflitam seu aplicativo no .NET Reflector e torna difícil descompactar para reverter.
• Escreva seu próprio empacotador personalizado . Se os empacotadores de terceiros forem muito caros, considere escrever seus próprios. Às vezes, os empacotadores personalizados podem ser muito eficazes, porque não existem métodos bem publicados sobre como descompactá-los. O tutorial Como escrever seu próprio empacotador fornece muitas informações sobre como escrever seu próprio empacotador Win32.

Em última análise, se as pessoas querem que seu aplicativo seja quebrado, elas o farão. Observe todos os softwares comerciais existentes que possuem uma grande quantidade de recursos para proteger seus aplicativos e, no entanto, eles são quebrados antes mesmo que os aplicativos sejam lançados ao público.

Um engenheiro reverso qualificado pode iniciar o IDA-Pro e cortar sua aplicação como manteiga, não importa o que você faça. Um aplicativo compactado pode ser descompactado e a ofuscação apenas o impede de fazer uma caminhada no parque. Todo o seu trabalho duro com seu código de licença complexo pode ser desfeito com um patch de byte único.

Você só precisa aceitar que há uma chance muito real de as pessoas piratearem seu software. Existem pessoas que nunca estão pagarão pelo seu aplicativo, não importa com o que e essas são as pessoas com as quais você não precisa se preocupar.

No entanto, existem muitas empresas por aí que nunca arriscariam uma ação judicial e comprariam alegremente licenças de software e muitos usuários de computador que não querem arriscar, acham errado ou não têm experiência em tecnologia o suficiente para piratear. Esses são seus verdadeiros clientes, e você deve concentrar seus esforços em proporcionar a eles uma boa experiência do usuário e ignorar as pessoas que estão invadindo seu software.

Eu já tive meu aplicativo pirateado antes e o tomei como uma afronta pessoal. Aqui estava eu, um pequeno desenvolvedor, despejando meu coração e alma em um aplicativo e essas pessoas tiveram a ousadia de me piratar ?! Eles estavam tirando dinheiro diretamente do meu bolso!

Eu imediatamente adicionei um monte de código DRM draconiano e tentei sabotar qualquer pessoa usando uma cópia ilegítima ou quebrada. É claro que eu deveria estar trabalhando para melhorar meu aplicativo em vez de tentar parar o inevitável. Não apenas isso, mas eu estava machucando meus verdadeiros clientes com todas essas proteções extras que eu estava colocando.

Depois de uma longa batalha, percebi que estava lutando contra as marés e todo esse tempo perdido foi em vão. Peguei todo o código da casa telefônica, exceto as funções de licença de barebones, e nunca olhei para trás.

Você não pode proteger totalmente nenhum aplicativo (gerenciado ou não). Se sistemas como o Playstation e o iPad podem quebrar - onde o fornecedor até controla o hardware - que esperança seu aplicativo tem? Felizmente, você realmente não quer. Na minha opinião, você precisa proteger seu aplicativo apenas o suficiente para que alguém não possa piratear acidentalmente seu produto, e não mais.

Por exemplo, se você usar uma licença por máquina, ela não funcionará apenas quando você a instalar em uma nova segunda máquina. Você deseja uma boa mensagem de erro para impedir chamadas de suporte extras, mas não gaste mais tempo dificultando o trabalho de contornar e não atinja os usuários.

Outro exemplo é um estudo com tempo limitado. Nem se preocupe com coisas simples, como se os usuários pudessem reverter o relógio do sistema. Alguém que faz isso sabe que está violando sua licença e desde que um usuário saiba quando está violando, você já fez o suficiente.

Você precisa fazer isso muito porque os usuários não se importam com sua licença. Licenças são coisas inventadas que ninguém importa até que precisem. Ninguém os lê, e eles realmente não deveriam. Portanto, a melhor maneira de informar ao usuário onde estão os limites é se o comportamento pronto para uso do seu aplicativo estiver em conformidade com a licença. Nesse primeiro caso, isso significa deixar de instalar ou instalar no modo de versão de teste pela segunda vez. Para o último, pode significar apenas verificar uma data em texto sem formatação em um arquivo de configuração. De qualquer maneira, certifique-se de lidar com isso de uma maneira elegante, útil e respeitosa.

Então, isso explica o que significa fazer exatamente isso. Mas por que não ir mais longe? Por que não conectar todos os pequenos orifícios que encontrar? A resposta está em duas partes. Primeiro, se alguém cruzar o limiar ético de quebrar conscientemente os termos da sua licença - mesmo que de maneira simples -, também estará disposto a fazer algo mais difícil ou perigoso, como retirar seu aplicativo de um torrentsite - e há uma certa quantidade de perigo envolvido na execução de aplicativos baixados de fontes não confiáveis. Tornar as coisas mais difíceis é apenas um pequeno aborrecimento para esses usuários e corre o risco de causar problemas aos seus clientes pagantes. Mantê-lo simples pode impedir que alguém penetre no seu aplicativo e libere um crack mais abrangente. Segundo, você tem poucos olhos disponíveis para procurar falhas; os hackers têm muitos e têm mais prática em encontrá-los. Você só precisa perder uma pequena falha, e seu aplicativo terá a mesma distribuição em sites piratas como se você não tivesse feito nada. Você tem que estar certo toda vez; eles só têm que ter sorte uma vez. Portanto, o esforço necessário é muito alto e a probabilidade de qualquer medida de sucesso é muito baixa.

Por fim, se alguém quiser piratear seu aplicativo (em vez de apenas usá-lo), e esse é o objetivo principal, eles o farão. Não há nada que você possa fazer para detê-los. Essa é a natureza do software; uma vez que os arquivos que compõem o seu produto está no computador de um usuário que vai ser capaz de fazer com eles como quiserem. Isso é especialmente relevante em ambientes gerenciados como Java ou .NET , mas definitivamente se aplica também ao código nativo. O tempo está do lado deles e, com tempo suficiente, qualquer segurança digital pode ser violada.

Como você não pode impedir os usuários de piratear seu produto, o melhor caminho a seguir é envolver essa classe de usuários de uma maneira que os use em seu benefício. Muitas vezes, é possível fazê-los trabalhar para você e não contra você. Com isso em mente, não importa qual seja seu aplicativo, provavelmente vale a pena manter uma versão gratuita que é quase completamente funcional e não expira. A diferença entre até um preço de US $ 1 e gratuito é enorme, se por outro motivo, o cliente não precisar confiar em você com seu cartão de crédito. Uma edição gratuita do seu produto não apenas matará efetivamente a distribuição pirateada (por que arriscar uma versão pirateada quando você pode ser legítima pelo mesmo preço?), Mas também tem o potencial de expandir drasticamente seu público.

O resultado é que você pode precisar aumentar o preço da edição paga, para que, no final, em vez de 2.000 usuários por US $ 20 cada, você tenha 100.000 usuários gratuitos, dos quais 500 estão dispostos a pagar US $ 99 pela edição "profissional" . Isso gera mais dinheiro do que se você gastasse muito tempo bloqueando seu produto. Mais do que isso, você pode envolver esses usuários gratuitos e alavancar o relacionamento de várias maneiras importantes.

Um é o apoio. Um pessimista aproveitaria a oportunidade para reclamar do aumento do custo de suporte a 100.000 usuários gratuitos, mas algo surpreendente acontece: seu produto se torna amplamente autossustentável. Você vê isso o tempo todo com grandes projetos de código aberto que não têm dinheiro para custos de suporte. Os usuários irão acelerar e fazer isso acontecer.

Os usuários gratuitos geralmente reduzem as expectativas de suporte, e por boas razões. Tudo o que você precisa fazer é marcar a edição gratuita como qualificada apenas para suporte da comunidade e criar um fórum on-line moderado pelo usuário para esse fim. Sua base de conhecimento de suporte é autogerada, e usuários avançados orientarão aqueles que precisam de assistência extra em seu nome. Ainda mais importante, isso permitirá identificar e corrigir erros mais rapidamente, melhorando a qualidade do seu produto e reduzindo os custos totais de suporte. Isso não era possível antes porque sua base de usuários não era grande o suficiente, mas quando você trata os usuários gratuitos como clientes, pode funcionar muito bem.

Outro é o feedback. Ao assistir ao seu fórum, você aprende idéias importantes de aprimoramento que talvez nunca tenha considerado de outra forma. Isso pode permitir que você transforme mais usuários gratuitos em usuários pagos e crie um produto mais atraente que atraia um público ainda maior.

Finalmente, você precisa considerar o marketing. Todos esses usuários gratuitos agora são fãs e não adversários, e eles agirão de acordo. Não apenas isso, mas quando chegar a hora de lançar sua próxima versão, todos esses usuários passarão pelo seu canal de distribuição aprovado, em vez de algum outro mecanismo desconhecido. Isso significa que, para a sua próxima versão, você começará conectado a um público maior, altamente interessado e solidário.

Os melhores recursos a serem reservados para a edição profissional são ferramentas destinadas a facilitar a implantação e o gerenciamento corporativos. Um cracker não vê isso como uma razão convincente o suficiente para invadir o site para uso próprio, mas para uma empresa que deseja comprar 300 licenças e distribuí-lo para toda a empresa, este é um item obrigatório. É claro que a edição profissional será pirateada de qualquer maneira, mas novamente: não se preocupe, porque você provavelmente não seria capaz de vender o produto para esses piratas, não importa o que você fez, por isso não está lhe custando nenhuma receita.

Embora psicologicamente possa ser difícil doar tanto seu produto, espero que você possa entender como ele realmente é o melhor caminho a percorrer. Não é só isso, é o único caminho a longo prazo. Eu sei que alguém está lá fora, pensando que não quer fazer dessa maneira. Afinal, eles conseguiram vender seu produto bloqueado de US $ 20 por anos. Mas isso é muito ruim, porque se você não fizer dessa maneira, eventualmente alguém o fará . E o produto deles será tão bom quanto o seu, ou perto o suficiente para que eles se safem da alegação disso. De repente, seus preços parecem ultrajantes, as vendas caem drasticamente e não há mais nada que você possa fazer. Você pode optar por uma camada intermediária adicional, se for necessário, mas é improvável que o ajude.

Na minha experiência, dificultar a quebra de seu aplicativo ou biblioteca prejudica seus clientes honestos, atrasando apenas ligeiramente os desonestos. Concentre-se em criar um excelente produto de baixa fricção, em vez de se esforçar muito para atrasar o inevitável.

Um segredo que você compartilha com muitas pessoas não é um segredo. Se você tem coisas secretas no seu código, ofuscar isso não é proteção; só precisa ser desobstruído uma vez . Se você tem um segredo que não deseja compartilhar com seus clientes, não o compartilhe com seus clientes . Escreva seu código como um serviço da Web e mantenha seu código super secreto em seu próprio servidor, onde somente você poderá vê-lo.

De um modo geral, existem três grupos de pessoas por aí.

• Aqueles que não compram seu software e recorrem a rachaduras ou, se não encontrarem, não usam o software. Não espere ganhar dinheiro com este grupo. Eles dependem de suas próprias habilidades ou de crackers (que tendem a priorizar seu tempo, dependendo da sua utilidade e do tamanho da sua audiência. Quanto mais útil, mais cedo uma crack estará disponível).

• O grupo de usuários legítimos que comprarão (pagarão) pelo seu software, independentemente do mecanismo de proteção usado. Não dificulte a vida de seus usuários legítimos, usando um mecanismo de proteção elaborado, pois eles pagarão por isso de qualquer forma. Um mecanismo de proteção complexo pode facilmente estragar a experiência do usuário e você não quer que isso aconteça com esse grupo. Pessoalmente, eu votaria contra qualquer solução de hardware, o que aumenta o custo do seu software.

• Uma minoria que recorrerá a rachaduras "antiéticas" e pagará apenas pelo seu software porque seus recursos são protegidos por um mecanismo de licenciamento. Você provavelmente não quer facilitar demais esse grupo para contornar sua proteção. No entanto, todo esse esforço que você gasta em proteger seu software será recompensado, dependendo do tamanho desse grupo de pessoas. Isso depende inteiramente do tipo de software que você está construindo.

Dado o que você disse, se você acha que existe uma minoria grande o suficiente para comprar seu software, vá em frente e implemente alguma forma de proteção. Pense em quanto dinheiro você pode ganhar com essa minoria em comparação com o tempo gasto trabalhando na proteção ou o valor gasto em uma API / ferramenta de proteção de terceiros.

Se você gosta de implementar uma solução própria, usar a criptografia de chave pública é uma boa maneira (em oposição aos algoritmos simétricos) para impedir hacks fáceis. Você pode, por exemplo, assinar digitalmente sua licença (número de série ou arquivo de licença). A única maneira de contornar isso seria descompilar, alterar e recompilar o código (o que pode dificultar o uso de técnicas como as sugeridas na resposta de Simucal).

Você não pode impedir as pessoas de invadir seu software.

No entanto, você pode fazê-los criar rachaduras que prejudicarão menos suas vendas. Os geradores de chaves que podem emitir um código de registro válido para o seu software são muito piores que os patches simples que removem os incentivos de registro do seu software. Isso ocorre porque um crack funcionará apenas para uma versão do software e deixará de funcionar com a próxima atualização de software lançada. O gerador de chaves continuará funcionando até que você altere seu algoritmo de chave de registro, e isso é algo que você não deseja fazer com frequência, porque adiará seus clientes honestos.

Portanto, se você estiver procurando um método para combater geradores de chaves ilegais para o seu software e não quiser usar criptografia assimétrica devido aos longos códigos de registro gerados, consulte a Verificação Parcial de Chaves.

A Verificação parcial de chave garante que cada gerador de chave ilegal funcione apenas para uma versão específica do seu software. Basicamente, o que você faz é garantir que cada versão do seu software esteja vinculada apenas ao código para verificar ALGUNS dígitos do código de registro. Quais dígitos são exatamente aleatórios, portanto, os crackers teriam que fazer engenharia reversa de muitas versões diferentes do seu software e combinar tudo isso em um gerador de chaves, a fim de liberar um gerador de chaves que funcione para todas as versões do seu software.

Se você lança novas versões de software regularmente, isso leva a numerosos geradores de chaves espalhados por todos os tipos de arquivos de pirataria de software que não estão mais funcionando. Os piratas em potencial de software geralmente procuram um crack ou keygen para a versão mais recente, portanto provavelmente tentarão alguns deles e desistirão eventualmente.

Eu usei a Verificação de chave parcial nos meus jogos shareware (C ++) mais recentes e foi muito eficaz. Antes tínhamos muitos problemas com geradores de chaves que não podíamos combater. Depois disso, houve muitas falhas e alguns geradores de chaves que funcionavam apenas para essa versão específica do jogo, mas nenhum gerador de chaves que funcionasse com todas as versões. Lançamos regularmente pequenas atualizações do jogo e tornamos inúteis todas as falhas anteriormente existentes.

Parece haver uma estrutura .NET de código aberto para verificação parcial de chave , embora eu ainda não tenha tentado.

• Use a atualização online para bloquear as cópias não licenciadas.

• Verifique o número de série de diferentes módulos do seu aplicativo e não use uma única chamada de função para fazer a verificação (para que os crackers não possam ignorar a verificação facilmente).

• Não apenas verifique o número de série na inicialização, faça a verificação ao salvar os dados, faça-o toda sexta-feira à noite, faça-o quando o usuário estiver ocioso ...

• Verifique a soma de verificação do arquivo do aplicativo, armazene sua soma de verificação de segurança em locais diferentes.

• Não exagere nesse tipo de truque, verifique se o seu aplicativo nunca falha / entra em mau funcionamento ao verificar o código de registro.

• Criar um aplicativo útil para os usuários é muito mais importante do que criar um
  binário inquebrável para crackers.

Você pode..

Serviços Microsoft SLP O potencial de software da InishTech oferece a capacidade de ajudar a proteger o código sem afetar a funcionalidade dos seus aplicativos.

ATUALIZAÇÃO: (Divulgação: Trabalho no Eazfuscator.NET) O que torna o potencial do software Microsoft SLP Services diferente é a capacidade de virtualizar o código, para que você possa definitivamente . Vários anos se passaram desde que a pergunta foi feita originalmente; hoje existem mais produtos disponíveis que também funcionam de maneira semelhante, como:

• Agile.NET
• Eazfuscator.NET

O .NET Reflector pode abrir apenas "código gerenciado", que basicamente significa "código .NET". Então você não pode usá-lo para desmontar arquivos COM DLL, C ++ nativo, Visual Basic 6.0 clássico código etc. A estrutura do código .NET compilado o torna muito conveniente, portátil, detectável, verificável etc. O .NET Reflector tira proveito isso permite que você espreite os assemblies compilados, mas os descompiladores e desmontadores não são de forma alguma específicos do .NET e existem desde que os compiladores existem.

Você pode usar ofuscadores para tornar o código mais difícil de ler, mas não pode impedir exatamente que seja descompilado sem também torná-lo ilegível para o .NET. Existem alguns produtos por aí (geralmente caros) que afirmam "vincular" seu aplicativo de código gerenciado a um aplicativo de código nativo, mas, mesmo que funcionem, uma pessoa determinada sempre encontrará uma maneira.

No entanto, quando se trata de ofuscação, você obtém o que paga. Portanto, se seu código é tão proprietário que você deve se esforçar tanto para protegê-lo, você deve investir dinheiro em um bom ofuscador.

No entanto, nos meus 15 anos de experiência na escrita de código, percebi que a proteção excessiva do seu código-fonte é uma perda de tempo e tem pouco benefício. Apenas tentar ler o código fonte original sem documentação de suporte, comentários, etc., pode ser muito difícil de entender. Acrescente a isso os nomes de variáveis ​​sem sentido criados pelos decompiladores e o código de espaguete que os ofuscadores modernos criam - você provavelmente não precisa se preocupar muito com pessoas roubando sua propriedade intelectual.

Isso realmente vale a pena? Todo mecanismo de proteção pode ser quebrado com determinação suficiente. Considere seu mercado, preço do produto, quantidade de clientes etc.

Se você quer algo mais confiável, siga o caminho das chaves de hardware, mas isso é bastante problemático (para o usuário) e mais caro. As soluções de software provavelmente seriam um desperdício de tempo e recursos, e a única coisa que elas forneceriam a você é o falso senso de "segurança".

Mais algumas idéias (nenhuma é perfeita, pois não há uma perfeita).

• AntiDuplicate
• Mude o idioma, use os bons truques que os autores do Skype usaram
• Servidor de licença

E não perca muito tempo com isso, porque os crackers têm muita experiência com as técnicas típicas e estão alguns passos à sua frente. A menos que você queira usar muitos recursos, provavelmente mude a linguagem de programação (faça da maneira do Skype).

Se você deseja que as pessoas possam executar seu código (e se não, então por que você o escreveu em primeiro lugar?), Então a CPU deles precisa poder executar seu código. Para poder executar o código, a CPU precisa entender .

Como as CPUs são burras e os humanos não, isso significa que os humanos também podem entender o código.

Há apenas uma maneira de garantir que seus usuários não obtenham seu código: não forneça seu código.

Isto pode ser alcançado de duas maneiras: Software como um serviço (SaaS), ou seja, você executar o seu software em seu servidor e só permitir que seus usuários acessá-lo remotamente. Este é o modelo que o Stack Overflow usa, por exemplo. Tenho certeza de que o Stack Overflow não ofusca o código deles, mas você não pode descompilá-lo.

A outra maneira é o modelo de dispositivo: em vez de fornecer aos usuários o seu código, você fornece a eles um computador contendo o código. Este é o modelo usado pelos consoles de jogos, a maioria dos telefones celulares e o TiVo . Observe que isso só funciona se você "possui" todo o caminho de execução: você precisa construir sua própria CPU, seu próprio computador, escrever seu próprio sistema operacional e sua própria implementação da CLI . Então, e somente então, você pode proteger seu código. (Mas observe que mesmo o menor erro inutilizará todas as suas proteções. Microsoft, Apple, Sony, indústria fonográfica e indústria cinematográfica podem atestar isso.)

Ou você pode simplesmente não fazer nada, o que significa que seu código será automaticamente protegido pela lei de direitos autorais.

Infelizmente, você não vai fugir disso. Sua melhor aposta é escrever seu código em C e P / Invocá- lo.

Existe um pequeno problema, alguém pode simplesmente descompilar seu aplicativo no CIL e eliminar qualquer código de verificação / ativação (por exemplo, a chamada para sua biblioteca C). Lembre-se de que os aplicativos escritos em C também são submetidos a engenharia reversa pelos hackers mais persistentes (basta ver a rapidez com que os jogos são quebrados atualmente). Nada protegerá seu aplicativo.

No final, funciona muito como a sua casa, proteja-a o suficiente para que seja muito esforço (o código do espaguete ajudaria aqui) e para que o agressor se mova para o seu vizinho (competição :)). Olhe para o Windows Vista, deve haver 10 maneiras diferentes de quebrá-lo.

Existem pacotes por aí que criptografam o arquivo EXE e o descriptografam quando o usuário tem permissão para usá-lo, mas mais uma vez, isso está usando uma solução genérica que sem dúvida foi quebrada.

Os mecanismos de ativação e registro são direcionados para o 'Joe médio': pessoas que não possuem conhecimento técnico suficiente para contorná-lo (ou, nesse caso, sabem que podem ignorá-lo). Não se preocupe com biscoitos, eles têm muito tempo em suas mãos.

Além de adquirir proteção, você (ou seus desenvolvedores) pode aprender a proteger contra cópias.

Estas são as idéias:

Primeiro, tente escrever um programa que se escreve no console. Esse é um problema famoso. O objetivo principal desta tarefa é praticar a escrita de código de auto-referência.

Segundo, você precisa desenvolver uma tecnologia que reescreva algum código de maneira confiável no CIL de outros métodos .

Você pode escrever uma máquina virtual (ainda no .NET ). E coloque algum código lá. Por fim, a máquina virtual executa outra máquina virtual que executa o código. Isso é parte de funções raramente chamadas para não diminuir muito o desempenho.

Reescreva alguma lógica no C ++ / CLI e misture o código gerenciado com o não gerenciado. Isso vai endurecer a desmontagem. Nesse caso, não esqueça de fornecer binários x64 também.

Sim. É verdade. O código .NET é extremamente fácil de fazer engenharia reversa se o código não for ofuscado.

A ofuscação adicionará uma camada de aborrecimento às pessoas que tentam fazer engenharia reversa do seu software. Dependendo da versão obtida, você obterá diferentes níveis de proteção.

O Visual Studio inclui uma versão do Dotfuscator . Como é uma versão em pacote, você definitivamente não está obtendo a ofuscação mais forte possível. Se você olhar para as listas de recursos, verá exatamente o que está faltando (e exatamente o que o aplicativo fará para tornar seu código mais seguro).

Existem alguns outros ocultadores .NET gratuitos ou de código aberto por aí (mas não posso comentar sobre a qualidade ou os vários métodos que eles usam):

• Obfuscar
• Babel.NET

No final, nada é perfeito. Se alguém realmente quiser ver como o seu software funciona, ele o fará.

Bem, você não pode proteger TOTALMENTE seu produto contra rachaduras, mas pode maximizar / aprimorar os níveis de segurança e dificultar um pouco a quebra por novatos e crackers intermediários.

Mas lembre-se de que nada é intransponível, apenas o software no servidor está bem protegido e não pode ser quebrado. De qualquer forma, para aprimorar os níveis de segurança em seu aplicativo, você pode executar algumas etapas simples para impedir que alguns crackers "nem todos" quebrem seus aplicativos. Essas etapas farão com que esses biscoitos fiquem loucos e talvez desesperados:

• Ofusque seu código-fonte, obviamente isso fará com que seu código-fonte pareça uma bagunça e ilegível.
• Acione várias rotinas de verificação aleatória dentro do aplicativo, como a cada duas horas, 24 horas, um dia, semana etc. ou talvez após cada ação que o usuário executar.
• Salve a soma de verificação MD5 do seu aplicativo lançado no servidor e implemente uma rotina que possa verificar a soma de verificação MD5 do arquivo atual com a real do lado do servidor e torná-lo acionado aleatoriamente. Se a soma de verificação MD5 foi alterada, significa que esta cópia foi pirateada. Agora você pode simplesmente bloqueá-lo ou lançar uma atualização para bloqueá-lo etc.
• Tente criar uma rotina que possa verificar se alguns dos seus códigos (funções, classes ou rotinas específicas) foram realmente modificados, alterados ou até removidos. Eu chamo isso (verificação de integridade do código).
• Use empacotadores desconhecidos gratuitos para embalar seu aplicativo. Ou, se você tiver dinheiro, opte por soluções comerciais como o Thamida ou o .NET Reactor . Esses aplicativos são atualizados regularmente e, uma vez que um cracker descompacta seu aplicativo, você pode obter uma nova atualização dessas empresas e, depois de obter a nova atualização, apenas compacta seu programa e lança uma nova atualização.
• Libere atualizações regularmente e force o seu cliente a baixar a atualização mais recente.
• Por fim, faça sua aplicação muito barata. Não faça isso muito caro. Acredite, você terá mais clientes satisfeitos e os crackers deixarão seu aplicativo, porque não vale a pena gastar um tempo com um aplicativo muito barato.

Esses são apenas métodos simples para impedir que novatos e crackers intermediários quebrem seu aplicativo. Se você tiver mais idéias para proteger seu aplicativo, não tenha vergonha de implementá-las. Isso dificultará a vida dos crackers, e eles ficarão frustrados e, eventualmente, deixarão seu aplicativo, porque não vale o tempo deles.

Por fim, você também precisa considerar gastar seu tempo codificando aplicativos de boa qualidade. Não perca seu tempo codificando camadas de segurança complicadas. Se um bom cracker quiser quebrar seu aplicativo, ele / ela fará o que você fizer ...

Agora vá e implemente alguns brinquedos para os biscoitos ...

Há o Salamander , que é um compilador .NET nativo e vinculador do Remotesoft que pode implantar aplicativos sem a estrutura .NET. Eu não sei o quão bem ele cumpre suas reivindicações.

Se a Microsoft conseguir uma solução, não teremos versões piratas do Windows, então nada é muito seguro. Aqui estão algumas perguntas semelhantes do Stack Overflow e você pode implementar sua própria maneira de protegê-las. Se você estiver lançando versões diferentes, poderá adotar técnicas diferentes para versões diferentes. Assim, quando uma primeira falha, o segundo pode assumir o controle.

• Gerenciando recursos com base em licença para um aplicativo C ++

• Proteger um arquivo DLL com um arquivo de licença

• Software de licenciamento / proteção?

Reator .NET

Atualizar

Jared apontou que o de4dot afirma ser capaz de descompilar.

O .NET Reactor fornece proteção completa para sua propriedade intelectual confidencial convertendo seus assemblies .NET em processos não gerenciados que não podem ser entendidos como CIL e que nenhuma ferramenta existente pode descompilar. Os hackers não têm acesso a nenhuma forma inteligível da sua fonte.

Poderosos e flexíveis, os recursos de licenciamento do .NET Reactor permitem impor suas condições de licença e proteger seu fluxo de receita usando bloqueios de hardware e software. O gerenciador de licenças pode criar licenças de avaliação ou permanentes em questão de segundos. Um kit de desenvolvimento de software (SDK) totalmente documentado, completo com exemplos, permite que você chame o sistema de licenciamento diretamente do seu código, permitindo criar extensões personalizadas para o sistema de licenciamento.

Aqui está uma idéia: você pode ter um servidor hospedado por sua empresa ao qual todas as instâncias do seu software precisam se conectar. Simplesmente fazer com que eles se conectem e verifiquem uma chave de registro não é suficiente - eles apenas removerão a verificação. Além da verificação da chave, você também precisa que o servidor execute uma tarefa vital que o cliente não pode executar por si próprio, por isso é impossível removê-lo. É claro que isso provavelmente significaria muito processamento pesado por parte do servidor, mas dificultaria o roubo do software e, assumindo que você tenha um bom esquema de chaves (verifique a propriedade etc.), as chaves também serão difíceis de serem roubadas. roubar. Isso provavelmente é mais invasivo do que você deseja, pois exigirá que seus usuários estejam conectados à Internet para usar seu software.

Qualquer coisa em execução no cliente pode ser descompilada e quebrada. A ofuscação apenas torna mais difícil. Não conheço sua inscrição, mas 99% das vezes não acho que valha a pena.

É impossível proteger totalmente um aplicativo, desculpe.

Ofuscar o código! Há um exemplo em Ofuscando código C # .

Lembre-se de que mais de 99% dos usuários não terão interesse em examinar seu executável para ver como ele funciona.

Dado que poucas pessoas se incomodam em tentar e que a maioria dos ofuscadores pode ser contornada, vale a pena o seu tempo e esforço?

É melhor investir tempo na melhoria do seu produto para que mais pessoas o desejem.

Apenas para adicionar um aviso: se você vai usar ofuscação, verifique se tudo ainda funciona! A ofuscação pode mudar coisas como nomes de classes e métodos. Portanto, se você usar a reflexão para chamar certos métodos e / ou classes (como em uma arquitetura de plug-in), seu aplicativo poderá falhar após ofuscar. Também os rastreamentos de pilha podem ser inúteis para rastrear erros.

Se for escrito em .NET e compilado no CIL , poderá ser refletido. Se a segurança é uma preocupação e a ofuscação deve ser evitada, recomendo que você escreva seu aplicativo usando uma linguagem não gerenciada, que é, por natureza, mais difícil de fazer engenharia reversa.

Como garantir que o aplicativo não seja violado e como garantir que o mecanismo de registro não possa sofrer engenharia reversa.

Ambos têm a mesma resposta muito simples: não forneça código de objeto a terceiros não confiáveis, como (aparentemente) seus clientes. A viabilidade de hospedar o aplicativo em suas máquinas depende apenas do que ele faz.

Se não for um aplicativo da web , talvez você possa permitir o login SSH com o encaminhamento do X para um servidor de aplicativos (ou Conexão de Área de Trabalho Remota , eu acho, para Windows).

Se você der código de objeto a pessoas do tipo nerd e elas acharem que seu programa pode ser divertido de quebrar, ele será quebrado. De jeito nenhum.

Se você não acredita em mim, aponte um aplicativo de alto perfil que não tenha sido quebrado e pirateado.

Se você usar as chaves de hardware, a produção ficará mais cara e seus usuários o odiarão por isso. É uma verdadeira besteira rastejar no chão conectando e desconectando suas 27 coisinhas USB diferentes, porque os fabricantes de software não confiam em você (imagino).

Existem pacotes por aí que criptografam seu EXE e descriptografam quando o usuário tem permissão para usá-lo

Obviamente, a maneira de contornar isso é decifrar o teste "can-I-use-it" para que ele sempre retorne verdadeiro.

Um truque desagradável pode ser usar os valores de bytes dos opcodes que executam o teste em algum outro lugar do programa de maneira suja, que fará com que o programa trave com alta probabilidade, a menos que o valor esteja correto. Faz com que você esteja vinculado a uma arquitetura específica :-(

Basta fazer uma boa aplicação e codificar um sistema de proteção simples. Não importa qual proteção você escolher, ela será revertida ... Portanto, não perca muito tempo / dinheiro.

Quando se trata de .NET, se você estiver lançando um Windows Forms aplicativo (ou qualquer aplicativo em que o cliente tenha o arquivo Executável Portátil), ele poderá ser quebrado.

Se você deseja manter o .NET e minimizar a chance de obter seu código-fonte, considere implantá-lo como um aplicativo ASP.NET em um servidor Web, em vez de torná-lo um aplicativo Windows Forms.

Francamente, às vezes precisamos ofuscar o código (por exemplo, registrar classes de licença e assim por diante). Nesse caso, seu projeto não é gratuito. OMI, você deve pagar por um bom obfucator.

O Dotfuscator oculta seu código e o .NET Reflector mostra um erro quando você tenta descompilá-lo.

Eu posso recomendar o uso do Ofuscador .