Estou desenvolvendo um software em Python que será distribuído aos clientes de meus empregadores. Meu empregador deseja limitar o uso do software com um arquivo de licença com restrição de tempo.

Se distribuirmos os arquivos .py ou mesmo os arquivos .pyc, será fácil (descompilar e) remover o código que verifica o arquivo de licença.

Outro aspecto é que meu empregador não deseja que o código seja lido por nossos clientes, temendo que o código seja roubado ou, pelo menos, as "novas idéias".

Existe uma boa maneira de lidar com esse problema? De preferência com uma solução pronta para uso.

O software será executado nos sistemas Linux (então não acho que o py2exe funcione).

Python, sendo uma linguagem interpretada compilada por código de bytes, é muito difícil de bloquear. Mesmo se você usar um exe-packager como o py2exe , o layout do executável é bem conhecido e os códigos de bytes do Python são bem conhecidos.

Normalmente, em casos como esse, é necessário fazer uma troca. Quão importante é realmente proteger o código? Existem segredos reais (como uma chave para criptografia simétrica de transferências bancárias) ou você está apenas sendo paranóico? Escolha o idioma que permite desenvolver o melhor produto o mais rápido possível e seja realista sobre o valor de suas novas idéias.

Se você realmente precisar aplicar a verificação de licença com segurança, escreva-a como uma pequena extensão C para que o código de verificação da licença possa ser extremamente difícil (mas não impossível!) Para fazer engenharia reversa e deixar a maior parte do seu código em Python .

"Existe uma boa maneira de lidar com esse problema?" Não. Nada pode ser protegido contra engenharia reversa. Até o firmware das máquinas de DVD foi submetido a engenharia reversa e a chave de criptografia AACS foi exposta. E isso apesar do DMCA tornar isso um crime.

Como nenhum método técnico pode impedir que seus clientes leiam seu código, você deve aplicar métodos comerciais comuns.

1. Licenças. Contratos. Termos e Condições. Isso ainda funciona mesmo quando as pessoas podem ler o código. Observe que alguns de seus componentes baseados em Python podem exigir o pagamento de taxas antes de vender software usando esses componentes. Além disso, algumas licenças de código aberto proíbem você de ocultar a fonte ou as origens desse componente.

2. Ofereça um valor significativo. Se o seu material é tão bom - a um preço difícil de recusar - não há incentivo para perder tempo e dinheiro com engenharia reversa. A engenharia reversa é cara. Torne seu produto um pouco menos caro.

3. Ofereça atualizações e aprimoramentos que tornam qualquer engenharia reversa uma má idéia. Quando o próximo lançamento interrompe a engenharia reversa, não faz sentido. Isso pode ser levado a extremos absurdos, mas você deve oferecer novos recursos que tornem a próxima versão mais valiosa que a engenharia reversa.

4. Ofereça personalização a preços tão atraentes que eles preferem pagar para você construir e dar suporte aos aprimoramentos.

5. Use uma chave de licença que expira. Isso é cruel e lhe dará uma má reputação, mas certamente faz com que seu software pare de funcionar.

6. Ofereça-o como um serviço da web. O SaaS não envolve downloads para os clientes.

Python não é a ferramenta que você precisa

Você deve usar a ferramenta certa para fazer a coisa certa, e o Python não foi projetado para ser ofuscado. É o contrário; tudo é aberto ou fácil de revelar ou modificar no Python, porque essa é a filosofia da linguagem.

Se você quer algo que não consegue ver, procure outra ferramenta. Isso não é uma coisa ruim, é importante que existam várias ferramentas diferentes para diferentes usos.

Ofuscação é realmente difícil

Até programas compilados podem sofrer engenharia reversa, portanto, não pense que você pode proteger totalmente qualquer código. Você pode analisar o PHP ofuscado, quebrar a chave de criptografia do flash etc. Versões mais recentes do Windows são quebradas todas as vezes.

Ter um requisito legal é um bom caminho a percorrer

Você não pode impedir que alguém abuse do seu código, mas pode descobrir facilmente se alguém o faz. Portanto, é apenas uma questão legal casual.

A proteção de código é superestimada

Atualmente, os modelos de negócios tendem a vender serviços em vez de produtos. Você não pode copiar um serviço, piratear ou roubá-lo. Talvez seja hora de considerar ir com o fluxo ...

Compile python e distribua binários!

Ideia sensata:

Use Cython , Nuitka , Shed Skin ou algo semelhante para compilar python no código C, depois distribua seu aplicativo como bibliotecas binárias python (pyd).

Dessa forma, nenhum código Python (byte) é deixado e você fez uma quantidade razoável de obscurificação que qualquer pessoa (ou seja, seu empregador) poderia esperar do código normal, eu acho. (.NET ou Java menos seguro que esse caso, pois esse bytecode não é ofuscado e pode ser decompilado relativamente facilmente em uma fonte razoável.)

O Cython está ficando cada vez mais compatível com o CPython, então acho que deve funcionar. (Na verdade, estou considerando isso no nosso produto. Já estamos construindo algumas bibliotecas de terceiros como pyd / dlls, portanto, enviar nosso próprio código python como binários não é um grande passo para nós.)

Consulte Esta postagem do blog (não por mim) para obter um tutorial sobre como fazê-lo. (thx @hithwen)

Ideia louca:

Você provavelmente poderia pedir ao Cython para armazenar os arquivos C separadamente para cada módulo, concatená-los todos e construí-los com inlining pesado. Dessa forma, seu módulo Python é bastante monolítico e difícil de usar com ferramentas comuns.

Além do louco:

Você poderá criar um único executável se conseguir vincular (e otimizar) o tempo de execução do python e todas as bibliotecas (dlls) estaticamente. Dessa forma, seria difícil interceptar chamadas de / para python e quaisquer bibliotecas de estrutura que você usa. Isso não pode ser feito se você estiver usando o código LGPL.

Entendo que você deseja que seus clientes usem o poder do python, mas não deseja expor o código-fonte.

Aqui estão minhas sugestões:

(a) Escreva as partes críticas do código como bibliotecas C ou C ++ e use SIP ou swig para expor as APIs C / C ++ ao namespace Python.

(b) Use cython em vez de Python

(c) Nos itens (a) e (b), deve ser possível distribuir as bibliotecas como binárias licenciadas com uma interface Python.

Seu empregador está ciente de que pode "roubar" de volta alguma idéia que outras pessoas recebam do seu código? Quero dizer, se eles podem ler o seu trabalho, você também pode. Talvez analisar como você pode se beneficiar da situação traria um retorno melhor do seu investimento do que temer quanto poderia perder.

[EDIT] Resposta ao comentário de Nick:

Nada ganhou e nada perdeu. O cliente tem o que deseja (e pagou por isso desde que ele próprio fez a alteração). Como ele não libera a mudança, é como se isso não acontecesse para todos os outros.

Agora, se o cliente vender o software, ele terá que alterar o aviso de direitos autorais (o que é ilegal, para que você possa processar e vencer -> caso simples).

Se eles não mudarem o aviso de direitos autorais, os clientes do segundo nível perceberão que o software é original e se perguntam o que está acontecendo. As chances são de que eles entrarão em contato com você e assim você aprenderá sobre a revenda do seu trabalho.

Novamente, temos dois casos: O cliente original vendeu apenas algumas cópias. Isso significa que eles não ganharam muito dinheiro de qualquer maneira, então por que se preocupar? Ou eles venderam em volume. Isso significa melhores chances para você aprender sobre o que eles fazem e fazer algo a respeito.

Mas, no final, a maioria das empresas tenta cumprir a lei (uma vez que sua reputação é arruinada, é muito mais difícil fazer negócios). Portanto, eles não roubam seu trabalho, mas trabalham com você para melhorá-lo. Portanto, se você incluir a fonte (com uma licença que o proteja da simples revenda), é provável que eles simplesmente refutem as alterações feitas, pois isso garantirá que a alteração esteja na próxima versão e não precisará mantê-la . Isso é vantajoso para as duas partes: você obtém alterações e elas podem fazer elas próprias se realmente precisam desesperadamente, mesmo que não estejam dispostas a incluí-las no lançamento oficial.

Você já deu uma olhada no pyminifier ? Minifica, ofusca e compacta o código Python. O código de exemplo parece bastante desagradável para a engenharia reversa casual.

$ pyminifier --nonlatin --replacement-length=50 /tmp/tumult.py
#!/usr/bin/env python3
ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲמּ=ImportError
ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ燱=print
ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ巡=False
ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ澨=object
try:
 import demiurgic
except ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲמּ:
 ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ燱("Warning: You're not demiurgic. Actually, I think that's normal.")
try:
 import mystificate
except ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲמּ:
 ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ燱("Warning: Dark voodoo may be unreliable.")
ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲﺬ=ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ巡
class ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ𐦚(ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ澨):
 def __init__(self,*args,**kwargs):
  pass
 def ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ클(self,dactyl):
  ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ퐐=demiurgic.palpitation(dactyl)
  ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ𠛲=mystificate.dark_voodoo(ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ퐐)
  return ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ𠛲
 def ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ𐠯(self,whatever):
  ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ燱(whatever)
if __name__=="__main__":
 ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ燱("Forming...")
 ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲﺃ=ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ𐦚("epicaricacy","perseverate")
 ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲﺃ.ﺭ异𞸐𐤔ﭞﰣﺁں𝕌𨿩𞸇뻛𐬑𥰫嬭ﱌ𢽁𐡆𧪮Ꝫﴹ뙫𢤴퉊ﳦﲣפּܟﺶ𐐤ﶨࠔ𐰷𢡶𧐎𐭈𞸏𢢘𦘼ﶻ𩏃𦽨𞺎𠛘𐠲䉊ﰸﭳᣲ𐠯("Codswallop")
# Created by pyminifier (https://github.com/liftoff/pyminifier)

Não confie na ofuscação. Como você concluiu corretamente, oferece proteção muito limitada. ATUALIZAÇÃO: Aqui está um link para o artigo que codifica o código python ofuscado de engenharia reversa no Dropbox. A abordagem - remapeamento do opcode é uma boa barreira, mas claramente pode ser derrotada.

Em vez disso, como muitos pôsteres mencionaram, faça isso:

• Não vale o tempo de engenharia reversa (seu software é tão bom que faz sentido pagar)
• Faça-os assinar um contrato e fazer uma auditoria de licença, se possível.

Como alternativa, como o IDE IDEAL do Python Wing-kick faz: Distribua o código . É isso mesmo, distribua o código e faça com que as pessoas voltem para atualizações e suporte.

Use Cython . Ele compilará seus módulos em arquivos C de alto desempenho, que poderão ser compilados em bibliotecas binárias nativas. Isso é basicamente irreversível, comparado ao .pyc bytecode!

Eu escrevi um artigo detalhado sobre como configurar o Cython para um projeto Python, confira:

Protegendo fontes Python com Cython

O envio de arquivos .pyc tem seus problemas - eles não são compatíveis com nenhuma outra versão python que não a versão python com a qual foram criados, o que significa que você deve saber em qual versão python está sendo executada nos sistemas nos quais o produto será executado. Esse é um fator muito limitador.

Em algumas circunstâncias, pode ser possível mover (todo ou pelo menos uma parte importante) do software para um serviço da web que sua organização hospeda.

Dessa forma, as verificações de licença podem ser realizadas na segurança da sua própria sala de servidores.

Embora não exista uma solução perfeita, o seguinte pode ser feito:

1. Mova uma parte crítica do código de inicialização para uma biblioteca nativa.
2. Impor a verificação de licença na biblioteca nativa.

Se a chamada para o código nativo fosse removida, o programa não seria iniciado de qualquer maneira. Se não for removido, a licença será aplicada.

Embora essa não seja uma solução multiplataforma ou Python pura, ela funcionará.

Eu acho que há mais um método para proteger seu código Python; parte do método Ofuscação. Eu acredito que houve um jogo como Mount and Blade ou algo que mudou e recompilou seu próprio intérprete python (o intérprete original que acredito ser de código aberto) e apenas alterei os códigos OP na tabela de códigos OP para serem diferentes do OP python padrão códigos.

Portanto, a fonte python não é modificada, mas as extensões dos arquivos * .pyc são diferentes e os códigos op não correspondem ao interpretador público python.exe. Se você verificou os arquivos de dados dos jogos, todos os dados estavam no formato de origem Python.

Todos os tipos de truques desagradáveis ​​podem ser feitos para mexer com hackers imaturos dessa maneira. É fácil parar um monte de hackers inexperientes. São os hackers profissionais que você provavelmente não vencerá. Mas a maioria das empresas não mantém hackers profissionais por muito tempo, imagino (provavelmente porque as coisas são invadidas). Mas hackers imaturos estão por toda parte (leia-se uma equipe de TI curiosa).

Você pode, por exemplo, em um intérprete modificado, permitir que ele verifique certos comentários ou sequências de documentos em sua fonte. Você pode ter códigos OP especiais para essas linhas de código. Por exemplo:

OP 234 é para a linha de origem "# Copyright escrevi isso" ou compile essa linha em códigos op equivalentes a "se False:" se "# Copyright" estiver ausente. Desabilitando basicamente todo um bloco de código pelo que parece ser algum motivo obscuro.

Um caso de uso em que a recompilação de um intérprete modificado pode ser possível é onde você não escreveu o aplicativo, ele é grande, mas é pago para protegê-lo, como quando você é um administrador de servidor dedicado para um aplicativo financeiro.

Acho um pouco contraditório deixar a fonte ou os códigos abertos para os olhos, mas usar SSL para o tráfego de rede. O SSL também não é 100% seguro. Mas é usado para impedir a maioria dos olhos de lê-lo. Uma pequena precaução é sensata.

Além disso, se um número suficiente de pessoas considerar que a fonte e os códigos de código Python são muito visíveis, é provável que alguém acabe desenvolvendo pelo menos uma ferramenta de proteção simples para isso. Portanto, mais pessoas perguntando "como proteger o aplicativo Python" apenas promovem esse desenvolvimento.

A única maneira confiável de proteger o código é executá-lo em um servidor que você controla e fornecer a seus clientes um cliente que faça interface com esse servidor.

Fiquei surpreso ao não ver pyconcrete em qualquer resposta. Talvez porque seja mais recente que a pergunta?

Pode ser exatamente o que você precisa (ed).

Em vez de ofuscar o código, ele o criptografa e descriptografa no momento do carregamento.

Da página pypi :

Proteger o fluxo de trabalho do script python

• your_script.py import pyconcrete
• pyconcrete vai ligar módulo de importação
• quando seu script fazer importação MODULE, pyconcrete gancho de importação tentará encontrar MODULE.pyeem primeiro lugar e, em seguida, descriptografar MODULE.pyevia _pyconcrete.pyde executar dados descriptografados (como conteúdo .pyc)
• criptografar e descriptografar o registro de chave secreta _pyconcrete.pyd (como DLL ou SO), a chave secreta estaria oculta no código binário, não pode ser vista diretamente no modo de exibição HEX

Dependendo de quem é o cliente, um mecanismo de proteção simples, combinado com um contrato de licença sensato, será muito mais eficaz do que qualquer sistema complexo de licenciamento / criptografia / ofuscação.

A melhor solução seria vender o código como um serviço, por exemplo, hospedando o serviço ou oferecendo suporte - embora isso nem sempre seja prático.

O envio do código como .pycarquivos impedirá que sua proteção seja frustrada por alguns #segundos, mas dificilmente é uma proteção antipirataria eficaz (como se houvesse essa tecnologia) e, no final do dia, ela não deve conseguir nada que contrato de licença decente com a empresa.

Concentre-se em tornar seu código o mais agradável possível de usar - ter clientes satisfeitos fará com que sua empresa ganhe muito mais dinheiro do que evitar alguma pirataria teórica.

Outra tentativa de tornar seu código mais difícil de roubar é usar jython e depois usar o java obfuscator .

Isso deve funcionar muito bem, pois o jythonc traduz o código python para java e, em seguida, o java é compilado no bytecode. Por isso, ofuscar as classes, será realmente difícil entender o que está acontecendo após a descompilação, sem mencionar a recuperação do código real.

O único problema com o jython é que você não pode usar módulos python escritos em c.

Que tal assinar seu código com esquemas de criptografia padrão usando hash e assinando arquivos importantes e verificando-o com métodos de chave pública?

Dessa forma, você pode emitir o arquivo de licença com uma chave pública para cada cliente.

Além disso, você pode usar um ofuscador python como este (apenas pesquisei no Google).

Você deve dar uma olhada em como os caras do getdropbox.com fazem isso pelo software cliente, incluindo o Linux. É bastante complicado de quebrar e requer uma desmontagem bastante criativa para superar os mecanismos de proteção.

O melhor que você pode fazer com o Python é obscurecer as coisas.

• Retire todas as instruções
• Distribua apenas os arquivos compilados .pyc.
• congele
• Obscure suas constantes dentro de uma classe / módulo para que a ajuda (config) não mostre tudo

Você pode adicionar alguma obscuridade adicional criptografando parte dela e descriptografando-a rapidamente e passando-a para eval (). Mas não importa o que você faça, alguém pode quebrá-lo.

Nada disso impedirá que um invasor determinado desmonte o bytecode ou vasculhe sua API com ajuda, dir etc.

A idéia de ter uma licença com restrição de tempo e verificá-la no programa instalado localmente não funcionará. Mesmo com a ofuscação perfeita, a verificação da licença pode ser removida. No entanto, se você verificar a licença no sistema remoto e executar parte significativa do programa em seu sistema remoto fechado, poderá proteger seu IP.

Impedindo que os concorrentes usem o código-fonte como eles próprios ou escrevam sua versão inspirada do mesmo código, uma maneira de proteger é adicionar assinaturas à lógica do seu programa (alguns segredos para provar que o código foi roubado) e ofuscar o código-fonte python, é difícil de ler e utilizar.

Uma boa ofuscação adiciona basicamente a mesma proteção ao seu código, que é compilada em executável (e removendo binário). Descobrir como o código complexo ofuscado funciona pode ser ainda mais difícil do que realmente escrever sua própria implementação.

Isso não ajudará a impedir a invasão do seu programa. Mesmo com o código de ofuscação, o material da licença será quebrado e o programa poderá ser modificado para ter um comportamento ligeiramente diferente (da mesma maneira que compilar código no binário não ajuda na proteção de programas nativos).

Além da ofuscação do símbolo, pode ser uma boa idéia desclassificar o código, o que torna tudo ainda mais confuso se, por exemplo, os gráficos de chamada apontarem para muitos lugares diferentes, mesmo que, na verdade, esses locais diferentes acabem fazendo a mesma coisa.

Assinatura lógica dentro do código ofuscado (por exemplo, você pode criar uma tabela de valores que é usada pela lógica do programa, mas também usada como assinatura), que pode ser usada para determinar que o código é originário de você. Se alguém decidir usar seu módulo de código ofuscado como parte de seu próprio produto (mesmo depois de ofuscá-lo para torná-lo diferente), você pode mostrar que esse código é roubado com sua assinatura secreta.

Eu observei a proteção de software em geral para meus próprios projetos e a filosofia geral é que a proteção completa é impossível. A única coisa que você espera alcançar é adicionar proteção a um nível que custaria mais ao seu cliente ignorar do que comprar outra licença.

Com isso dito, eu estava apenas checando o Google por obsfucação em python e não aparecendo muita coisa. Em uma solução .Net, a obsfucação seria a primeira abordagem para o seu problema em uma plataforma Windows, mas não tenho certeza se alguém tem soluções no Linux que funcionam com o Mono.

A próxima coisa seria escrever seu código em uma linguagem compilada ou, se você realmente quiser ir até o fim, em assembler. Um executável despojado seria muito mais difícil de descompilar do que uma linguagem interpretada.

Tudo se resume a compensações. Por um lado, você tem facilidade de desenvolvimento de software em python, no qual também é muito difícil ocultar segredos. Por outro lado, você tem um software escrito em assembler, que é muito mais difícil de escrever, mas é muito mais fácil ocultar segredos.

Seu chefe precisa escolher um ponto em algum ponto desse continuum que suporte seus requisitos. E então ele tem que lhe dar as ferramentas e o tempo para que você possa construir o que ele quer. No entanto, minha aposta é que ele se oporá aos custos reais de desenvolvimento versus possíveis perdas monetárias.

Longa história curta:

1. Criptografar seu código fonte
2. Escreva seu próprio carregador de módulo python para descriptografar seu código ao importar
3. Implemente o carregador de módulo em C / C ++
4. Você pode adicionar mais recursos ao carregador de módulos, por exemplo, anti-depurador, controle de licença, ligação de impressão digital de hardware, etc.

Para mais detalhes, veja esta resposta .

Se você está interessado no tópico, este projeto irá ajudá-lo - a proteger .

É possível ter o código de bytes py2exe em um recurso criptografado para um iniciador C que o carrega e executa na memória. Algumas idéias aqui e aqui .

Alguns também pensaram em um programa auto-modificável para tornar a engenharia reversa cara.

Você também pode encontrar tutoriais para evitar depuradores , fazer com que o desmontador falhe, definir pontos de interrupção de depurador falso e proteger seu código com somas de verificação. Procure por ["código criptografado" execute "na memória"] para obter mais links.

Mas, como outros já disseram, se o seu código vale a pena, os engenheiros reversos terão sucesso no final.

Se focarmos no licenciamento de software, eu recomendaria dar uma olhada em outra resposta do Stack Overflow que escrevi aqui para ter alguma inspiração de como um sistema de verificação de chave de licença pode ser construído.

Existe uma biblioteca de código aberto no GitHub que pode ajudá-lo com o bit de verificação da licença.

Você pode instalá-lo pip install licensinge adicionar o seguinte código:

pubKey = "<RSAKeyValue><Modulus>sGbvxwdlDbqFXOMlVUnAF5ew0t0WpPW7rFpI5jHQOFkht/326dvh7t74RYeMpjy357NljouhpTLA3a6idnn4j6c3jmPWBkjZndGsPL4Bqm+fwE48nKpGPjkj4q/yzT4tHXBTyvaBjA8bVoCTnu+LiC4XEaLZRThGzIn5KQXKCigg6tQRy0GXE13XYFVz/x1mjFbT9/7dS8p85n8BuwlY5JvuBIQkKhuCNFfrUxBWyu87CFnXWjIupCD2VO/GbxaCvzrRjLZjAngLCMtZbYBALksqGPgTUN7ZM24XbPWyLtKPaXF2i4XRR9u6eTj5BfnLbKAU5PIVfjIS+vNYYogteQ==</Modulus><Exponent>AQAB</Exponent></RSAKeyValue>"

res = Key.activate(token="WyIyNTU1IiwiRjdZZTB4RmtuTVcrQlNqcSszbmFMMHB3aWFJTlBsWW1Mbm9raVFyRyJd",\
                   rsa_pub_key=pubKey,\
                   product_id=3349, key="ICVLD-VVSZR-ZTICT-YKGXL", machine_code=Helpers.GetMachineCode())

if res[0] == None not Helpers.IsOnRightMachine(res[0]):
    print("An error occured: {0}".format(res[1]))
else:
    print("Success")

Você pode ler mais sobre o modo como a chave pública RSA, etc, está configurada aqui .

Use o mesmo modo para proteger o arquivo binário do c / c ++, ou seja, ofuscar cada corpo da função no arquivo binário executável ou da biblioteca, insira uma instrução "jump" no início de cada entrada de função, vá para a função especial para restaurar o código ofuscado. Byte-code é um código binário do script Python, então

• Primeiro compile o script python para codificar o objeto
• Em seguida, itere cada objeto de código, ofusque o co_code de cada objeto de código da seguinte maneira

    0 JUMP_ABSOLUTE n = 3 + len (bytecode)

    3
    ...
    ... Aqui está ofuscado bytecode
    ...

    n LOAD_GLOBAL? (__pyarmor__)
    n + 3 CALL_FUNCTION 0
    n + 6 POP_TOP
    n + 7 JUMP_ABSOLUTE 0

• Salve o objeto de código ofuscado como arquivo .pyc ou .pyo

O arquivo ofuscado (.pyc ou .pyo) pode ser usado pelo interpretador python normal, quando esse objeto de código é chamado pela primeira vez

• A primeira operação é JUMP_ABSOLUTE. Irá pular para compensar n

• No deslocamento n, a instrução é chamar uma função PyCF. Essa função restaurará aqueles bytecodes ofuscados entre o deslocamento 3 en, e colocará o código de bytes original no offset 0. O código ofuscado pode ser obtido pelo seguinte código

      char * obfucated_bytecode;
      Py_ssize_t len;
      PyFrameObject * frame = PyEval_GetFrame ();
      PyCodeObject * f_code = frame-> f_code;
      PyObject * co_code = f_code-> co_code;      
      PyBytes_AsStringAndSize (co_code, & obfucated_bytecode, & len)
  

• Após o retorno dessa função, a última instrução é pular para o deslocamento 0. O código de bytes realmente agora é executado.

Existe uma ferramenta Pyarmor para ofuscar scripts python dessa maneira.

o uso do cxfreeze (py2exe para linux) fará o trabalho.

http://cx-freeze.sourceforge.net/

está disponível nos repositórios do ubuntu

Existe uma resposta abrangente para ocultar o código-fonte python, que pode ser encontrado aqui .

As possíveis técnicas discutidas são:
- use bytecode compilado ( python -m compileall)
- criadores executáveis ​​(ou instaladores como PyInstaller )
- software como serviço (a melhor solução para ocultar seu código na minha opinião)
- ofuscadores de código fonte do python