Como faço para proteger o código Python?

Question

Estou desenvolvendo um pedaço de software em Python que será distribuído aos clientes do meu empregador. Meu empregador quer limitar o uso do software com um arquivo de licença de tempo restrito.

Se nós distribuir os arquivos .py ou mesmo arquivos .pyc será fácil (decompile e) remover o código que verifica o arquivo de licença.

Outro aspecto é que o meu patrão não quer que o código a ser lido pelos nossos clientes, temendo que o código pode ser roubado ou pelo menos as "novas idéias".

Existe uma boa maneira de lidar com este problema? De um modo preferido com uma solução de fora da prateleira.

O software será executado em sistemas Linux (então eu não acho que py2exe irá fazer o truque).

Answer 1

Python, sendo uma linguagem interpretada byte-code-compilados, é muito difícil de bloquear. Mesmo se você usar um exe-acondicionador como py2exe , o layout do executável é bem conhecida, e o byte de códigos Python são bem compreendidos.

Normalmente, em casos como este, você tem que fazer uma troca. Quão importante é realmente para proteger o código? Existem segredos reais lá (como uma chave para criptografia simétrica das transferências bancárias), ou você está apenas sendo paranóico? Escolha o idioma que lhe permite desenvolver o melhor produto mais rápido, e ser realista sobre o quão valioso suas novas idéias são.

Se você decidir que realmente precisa para impor a verificação de licença segura, escrevê-lo como uma pequena extensão C para que o código de verificação de licença pode ser extra-duro (mas não impossível!) Fazer engenharia reversa, e deixar a maior parte do seu código em Python.

Answer 2

"Existe uma boa maneira de lidar com este problema?" Não. Nada pode ser protegido contra a engenharia reversa. Mesmo o firmware em máquinas de DVD foi a engenharia reversa e AACS criptografia de chave exposta. E isso é, apesar da tomada de DMCA que uma ofensa criminal.

Uma vez que nenhum método técnico pode parar seus clientes de ler o seu código, você tem que 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. Note-se que alguns de seus componentes baseados em Python podem exigir que você paga taxas antes de você vender o software usando esses componentes. Além disso, algumas licenças de código aberto proibi-lo de ocultar a origem ou origens desse componente.

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

3. atualizações de Oferta e melhorias que fazem qualquer engenharia reversa uma má idéia. Quando a próxima versão quebra sua engenharia reversa, não há nenhum ponto. Isso pode ser levada a extremos absurdos, mas você deve oferecer novas funcionalidades que tornam a próxima versão mais valioso do que a engenharia reversa.

4. personalização Oferta a taxas tão atraente que eles preferem pagar você construir e apoiar as melhorias.

5. Use uma chave de licença que expira. Isso é cruel, e vai lhe dar uma má reputação, mas certamente faz sua parada software de trabalho.

6. oferecê-lo como um serviço web. SaaS envolve nenhum download para os clientes.

Answer 3

Python não é a ferramenta que você precisa

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

Se você quer algo que você não pode ver através, olhar para outra ferramenta. Esta não é uma coisa ruim, é importante que existem várias ferramentas diferentes para diferentes usos.

Obfuscation é realmente difícil

programas Mesmo compilados podem ser engenharia reversa por isso não acho que você pode proteger totalmente qualquer código. Você pode analisar ofuscado PHP, quebrar a chave de criptografia flash, etc. As versões mais recentes do Windows estão rachados de cada vez.

Ter uma exigência legal é um bom caminho a percorrer

Você não pode impedir alguém de mau uso de seu código, mas você pode facilmente descobrir se alguém faz. Portanto, é apenas uma questão jurídica casual.

Protecção Código é superestimada

Hoje em dia, os modelos de negócios tendem a ir para a venda de serviços em vez de produtos. Você não pode copiar um serviço, pirata, nem roubá-lo. Talvez seja hora de considerar a ir com o fluxo ...

Answer 4

Compilar python e distribuir binários!

idéia sensata:

Use Cython , Nuitka , muda de pele ou algo semelhante para compilar python para o código C, em seguida, distribuir o seu aplicativo como binário python bibliotecas (PYD) em vez.

Dessa forma, nenhum código (byte) Python é deixado e você tenha feito qualquer quantidade razoável de obscurification ninguém (ou seja, seu empregador) poderia esperar de código regular, eu acho. (.NET ou Java menos seguro do que neste caso, como que bytecode não é ofuscado e pode relativamente ser facilmente compilado em fonte razoável.)

Cython está ficando mais e mais compatível com CPython, então eu acho que ele deve funcionar. (Na verdade, estou considerando este para o nosso produto .. Nós já estamos construindo algumas thirdparty libs como PYD / DLLs, então o transporte nosso próprio código python como binários não é um excessivamente grande passo para nós.)

Veja Este Blog Publicar (não por mim) para um tutorial sobre como fazê-lo. (Thx @hithwen)

idéia louca:

Você poderia provavelmente começar Cython para armazenar os C-arquivos separadamente para cada módulo, em seguida, basta concatenar todos eles e construí-los com inlining pesado. Dessa forma, o seu módulo Python é bastante monolítica e difícil de chip em com ferramentas comuns.

Além louco:

Você pode ser capaz de construir um único executável, se você pode ligar para (e optimize com) o tempo de execução python e todas as bibliotecas (DLLs) estaticamente. Dessa forma, ele tinha certeza de ser difícil de chamadas de interceptação de / para python e quaisquer bibliotecas quadro que você usa. Isso não pode ser feito se você estiver usando o código LGPL embora.

Answer 5

Eu entendo que você deseja que seus clientes para usar o poder de python, mas não querem expor o código-fonte.

Aqui estão as minhas sugestões:

(a) Adicione as partes críticas do código como bibliotecas C ou C ++ e, em seguida, usar SIP ou gole para expor os C APIs / C ++ para Python namespace.

(b) Use Cython em vez de Python

(c) Em ambos (a) e (b), deve ser possível distribuir as bibliotecas como binário licenciado com uma interface Python.

Answer 6

é seu empregador ciente de que ele pode "roubar" apoiar todas as idéias que outras pessoas se do seu código? Quer dizer, se eles podem ler o seu trabalho, você também pode deles. Talvez olhando como você pode se beneficiar da situação renderia um melhor retorno do seu investimento do que temer quanto você poderia perder.

[EDIT] Resposta ao comentário de Nick:

Nada adquirida e nada perdido. O cliente tem o que ele quer (e pago por ele desde que ele fez a si mesmo a mudança). Desde que ele não libera a mudança, é como se isso não aconteceu para todos os outros.

Agora, se o cliente vende o software, eles têm que mudar o aviso de direitos autorais (o que é ilegal, para que possa processar e vai ganhar -> caso simples)

.

Se eles não alterar o aviso de copyright, os clientes 2º nível vai notar que o software vem de você original e saber o que está acontecendo. As chances são de que eles vão entrar em contato com você e assim que você vai aprender sobre a revenda do seu trabalho.

Mais uma vez temos dois casos: o cliente original vendeu apenas algumas cópias. Isso significa que eles não fazem muito dinheiro de qualquer maneira, então porque se preocupar. Ou eles vendidos em volume. O que significa melhores chances para você aprender sobre o que eles fazem e fazer algo sobre isso.

Mas no final, a maioria das empresas tentam cumprir a lei (uma vez que sua reputação está arruinada, é muito mais difícil de fazer negócios). Então, eles não vão roubar o seu trabalho, mas trabalhar com você para melhorá-lo. Então, se você incluir a fonte (com uma licença que protege você de simples revenda), as chances são de que eles vão simplesmente empurrar para trás as mudanças que fez desde que irá certificar-se de que a mudança é na próxima versão e eles não tem que mantê-lo . Isso é ganha-ganha:. Você começa mudanças e eles podem fazer a mudança se se eles realmente, precisa desesperadamente mesmo se você estiver disposto a incluí-lo no lançamento oficial

Answer 7

Você teve uma olhada pyminifier ? Ele faz Minify, Ofuscação e compressa código Python. Os olhares de código de exemplo bastante desagradável para engenharia reversa ocasional.

$ 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)

Answer 8

Não confie em ofuscação. Como Você concluiu corretamente, ele oferece proteção muito limitada. UPDATE: Aqui está um link para o papel que a engenharia reversa python código ofuscado no Dropbox. A abordagem -. Remapeamento opcode é uma boa barreira, mas claramente ele pode ser derrotado

Em vez disso, como muitos comentários mencionaram make-lo:

• Não vale a pena o tempo de engenharia reversa (Seu software é tão bom, não faz sentido pagar)
• Faça-los assinar um contrato e fazer uma auditoria licença se viável.

Como alternativa, como o kick-ass Python IDE WingIDE faz: Dar afastado o código . É isso mesmo, dar o código de distância e ter pessoas voltar para atualizações e suporte.

Answer 9

Envio arquivos .pyc tem seus problemas - eles não são compatíveis com qualquer outra versão python que a versão python eles foram criados com, o que significa que você deve saber qual a versão Python é executado nos sistemas o produto será executado. Isso é um fator muito limitante.

Answer 10

Em algumas circunstâncias, pode ser possível mover (todos, ou pelo menos uma parte fundamental) do software em um serviço web que sua organização anfitriões.

Assim, as verificações de licença pode ser realizada na segurança de seu próprio quarto servidor.

Answer 11

Embora não há nenhuma solução perfeita, o seguinte pode ser feito:

1. Mover algum trecho crítico de código de inicialização em uma biblioteca nativa.
2. Aplicar a verificação de licença na biblioteca nativa.

Se a chamada para o código nativo fosse removido, o programa não iniciar qualquer maneira. Se não for removido, em seguida, a licença será aplicada.

Embora este não é um multi-plataforma ou uma solução de Python puro, ele vai trabalhar.

Answer 12

A única maneira confiável de código de proteção é executá-lo em um servidor que você controlar e fornecer os seus clientes com um cliente que interage com esse servidor.

Answer 13

Eu acho que há mais um método para proteger seu código Python; parte do método ofuscação. Acredito que havia um jogo como Mount e Blade ou algo que alterar e recompilar seu próprio interpretador Python (o intérprete original que eu acredito é open source) e apenas mudou os códigos OP na tabela de código OP para ser diferente, em seguida, o OP python padrão códigos.

Assim, a fonte python não foi modificado, mas as extensões dos arquivos * .pyc arquivos são diferentes e os códigos op não correspondem ao intérprete python.exe público. Se você verificou os dados de jogos arquiva todos os dados estava em formato fonte Python.

Todos os tipos de truques sujos pode ser feito para mexer com hackers imaturos desta forma. Parando um bando de hackers inexperientes é fácil. É os hackers profissionais que você provavelmente não vai bater. Mas a maioria das empresas não manter pro hackers na equipe longo imagino (provavelmente porque as coisas hackeado). Mas os hackers imaturos estão em todo o lugar (leia-se equipe de TI curioso).

Você poderia, por exemplo, em um intérprete modificado, permitir que ele para verificar se há certos comentários ou doc ??strings em sua fonte. Você poderia ter códigos OP especiais para essas linhas de código. Por exemplo:

OP 234 é para a linha fonte "# Direitos de autor Eu escrevi este" ou compilar essa linha em códigos op que são equivalentes a "se falso:" se "# Direitos de autor" está faltando. Basicamente desativação de um bloco inteiro de código para o que parece ser alguma razão obscura.

Um caso de uso onde recompilar um intérprete modificado pode ser viável é onde você não escrever o aplicativo, o aplicativo é grande, mas você é pago para protegê-lo, como quando você é um administrador de servidor dedicado para uma financeira aplicação.

Acho que é um pouco contraditório para deixar a fonte ou opcodes abrir para os globos oculares, mas o uso de SSL para o tráfego de rede. SSL não é 100% seguro também. Mas ele é usado para parar olhos mais de lê-lo. Uma precaução pouquinho é sensato.

Além disso, se as pessoas o suficiente considerem essa fonte e opcodes Python são muito visíveis, é provável que alguém acabará por desenvolver pelo menos uma ferramenta de proteção simples para ele. Então, quanto mais as pessoas perguntando "como proteger Python app" só promove esse desenvolvimento.

Answer 14

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

A melhor solução seria vender o código como um serviço, dizer por que hospeda o serviço ou suporte oferta - embora isso nem sempre é prático

.

Envio o código como arquivos .pyc vai impedir que sua proteção está sendo frustrado por algumas #s, mas dificilmente é eficaz protecção anti-pirataria (como se houvesse tal tecnologia a), e no final do dia, não deve conseguir qualquer coisa que um contrato de licença decente com a empresa vai.

se concentrar em fazer o seu código tão agradável de usar quanto possível - Tendo clientes felizes vai fazer sua empresa muito mais dinheiro do que prevenir a pirataria teórica ..

Answer 15

Use Cython . Ele irá compilar seus módulos para arquivos C de alta elevada performance, que podem então ser compilados para bibliotecas binários nativos. Este é basicamente un-reversível, em comparação com bytecode .pyc!

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

Proteger Python Fontes Com Cython

Answer 16

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

Isso deve funcionar muito bem como jythonc traduzir código python para java e java é compilado para bytecode. Então onça você ofuscar as classes que será muito difícil entender o que está acontecendo depois de descompilação, para não mencionar a recuperação do código real.

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

Answer 17

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

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

adicionais que você pode usar um obfuscator python como esta (apenas pesquisei).

Answer 18

Você deve dar uma olhada em como os rapazes no getdropbox.com fazê-lo para o seu software cliente, incluindo Linux. É bastante complicado para rachar e requer algum bastante criativos desmontagem para passar os mecanismos de proteção.

Answer 19

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

Ele poderia ser exatamente o que você precisa (ed).

Em vez de ofuscar o código, ele criptografa e decifra no tempo de carregamento.

A partir pypi página :

python proteger o fluxo de trabalho de script

• your_script.py import pyconcrete
• pyconcrete vai ligar módulo de importação
• quando o script fazer MODULE importação, gancho de importação pyconcrete vai tentar encontrar MODULE.pye primeiro e depois MODULE.pye descriptografar através _pyconcrete.pyd e executar dados descodificados (como conteúdo .pyc)
• criptografar e descriptografar registro de chave secreta em _pyconcrete.pyd (Como DLL ou SO) a chave secreta seria esconder no código binário, não pode vê-lo diretamente na vista HEX

Answer 20

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

• Faixa de todas docstrings
• Distribuir somente os arquivos .pyc compilado.
• congelá-lo
• Obscure suas constantes dentro de uma classe / módulo para que ajuda (config) não mostra tudo

Você pode ser capaz de adicionar um pouco de obscuridade adicional, criptografando parte dela e descriptografar lo na mosca e passá-la para eval (). Mas não importa o que você faz alguém pode quebrá-lo.

Nada disso vai parar um atacante determinado a partir da desmontagem do bytecode ou cavar através de sua API com ajuda, dir, etc.

Answer 21

idéia de ter licença restrita tempo e cheque para ele no programa instalado localmente não vai funcionar. Mesmo com perfeita ofuscação, verificação de licença pode ser removido. No entanto, se você verificar licença no sistema remoto e executar parte significativa do programa no seu sistema remoto fechado, você será capaz de proteger o seu IP.

impedir que os concorrentes usando o código-fonte como a sua própria ou escrever sua versão inspirada do mesmo código, uma maneira de proteger é adicionar assinaturas para a sua lógica do programa (alguns segredos para ser capaz de provar que o código foi roubado de você) e ofuscar o código-fonte python assim, é difícil de ler e utilizar.

Boa ofuscação acrescenta basicamente a mesma proteção para o seu código, que compilá-lo para o executável (e descascar binário) faz. Descobrir obras código complexo como ofuscado pode ser ainda mais difícil do que realmente escrevendo sua própria implementação.

Isso não vai ajudar prevenir hackers de seu programa. Mesmo com o material licença de código ofuscação será rachada e programa pode ser modificado para ter um comportamento ligeiramente diferente (da mesma forma que compilar o código para binário não proteção ajuda de programas nativos).

Além de símbolo ofuscação pode ser boa idéia para unrefactor o código, o que torna tudo ainda mais confuso se por exemplo chamar pontos gráficos para muitos lugares diferentes, mesmo que na verdade esses lugares diferentes faz, eventualmente, a mesma coisa.

assinatura lógico dentro código ofuscado (por exemplo, você pode criar a tabela de valores que são usados ??pela lógica do programa, mas também usado como assinatura), que podem ser usados ??para determinar que o código é originado de você. Se alguém decide usar o seu módulo de código ofuscado, como parte de seu próprio produto (mesmo depois reobfuscating-lo para fazê-lo parecer diferente) você pode mostrar, que o código é roubado com a sua assinatura secreta.

Answer 22

Eu olhei para proteção de software, em geral, para os meus próprios projetos e a filosofia geral é que a proteção completa é impossível. A única coisa que você pode esperar conseguir é adicionar proteção a um nível que custaria o seu cliente mais para desvio do que seria para comprar outra licença.

Com que disse que eu estava apenas verificando google para obsfucation python e não transformar-se um monte de nada. Em uma solução .Net, obsfucation seria uma primeira abordagem para o seu problema em uma plataforma Windows, mas eu não tenho certeza se alguém tem soluções em Linux que trabalham com Mono.

O próximo passo seria escrever seu código em uma linguagem compilada, ou se você realmente quer ir todo o caminho, então em assembler. Um executável retirados seria muito mais difícil de decompor do que uma linguagem interpretada.

Tudo se resume a compensações. Em uma final, você tem a facilidade de desenvolvimento de software em python, em que também é muito difícil de esconder segredos. Na outra extremidade você tem o software escrito em assembler que é muito mais difícil de escrever, mas é muito mais fácil de esconder segredos.

Seu chefe tem que escolher um lugar ponto ao longo desse continuum que suporta suas necessidades. E então ele tem que dar-lhe as ferramentas e tempo para que você pode construir o que ele quer. No entanto a minha aposta é que ele vai opor-se os custos de desenvolvimento reais contra potenciais perdas monetárias.

Answer 23

É possível ter o byte-code py2exe em um recurso crypted para um lançador de C que carrega e executa-lo na memória. Algumas idéias aqui e aqui .

Alguns também ter pensado um programa de modificação de auto fazer reversa engenharia caro.

Você também pode encontrar tutoriais para evitar depuradores , fazer o desmontador falhar, conjunto de pontos de interrupção do depurador falsos e proteger o seu código com somas de verificação. Pesquisa por [ "código crypted" executar "na memória"] para mais ligações.

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

Answer 24

Para encurtar a história:

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

Para obter mais detalhes, olhar esta resposta .

Se você está interessado no assunto, este projecto irá ajudá-lo -. pyprotect

Answer 25

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

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

Você pode instalá-lo pip install licensing e, em seguida, adicione 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 a forma como a chave pública RSA, etc estão configurados aqui .

Answer 26

usando cxfreeze (py2exe para linux) irá fazer o trabalho.

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

está disponível em ubuntu repositórios

Answer 27

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

• Primeiro roteiro de compilação python para objeto de código
• Em seguida, iterate cada objeto código, co_code Ofuscação de cada objeto de código como o seguinte

    0   JUMP_ABSOLUTE            n = 3 + len(bytecode)

    3
    ...
    ... Here it's obfuscated bytecode
    ...

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

• Save ofuscado objeto código como .pyc ou .pyo arquivo

Aqueles arquivo ofuscado (.pyc ou .pyo) pode ser usado por interpretador Python normal, quando aqueles objeto de código é chamado pela primeira vez

• Primeiro op é JUMP_ABSOLUTE, ele vai saltar para compensar n

• No deslocamento n, a instrução é chamar um PyCFunction. Esta função irá restaurar os bytecode ofuscado entre compensada 3 e n, e colocar o bytecode original em deslocamento 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)
  

• Depois que esta função retorna, a última instrução é para saltar para deslocamento 0. O byte-code realmente agora é executado.

Há uma ferramenta Pyarmor para ofuscar python roteiros por este caminho.