Como protejo o código Python?

632

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

Jordfräs
fonte
25
O py2exe apenas armazena os arquivos de código de bytes .pyc em um arquivo .zip, portanto essa definitivamente não é uma solução. Ainda assim, isso pode ser útil quando combinado com um script starup adequado para fazê-lo funcionar unter Linux
Ber
Esta é a resposta mais abrangente para sua pergunta: wiki.python.org/moin/Asking%20for%20Help/…
Mike

Respostas:

378

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 .

Ned Batchelder
fonte
157
Mesmo se o código de verificação de licença fosse difícil de fazer engenharia reversa porque está escrito em C, ainda não seria relativamente fácil remover as chamadas para o código de verificação de licença?
Blair Conrad
59
Sim, dependendo de onde a verificação da licença é realizada. Se houver muitas chamadas para o ramal, pode ser difícil erradicar. Ou você pode mover outra parte crucial do aplicativo para a verificação de licença, para que a remoção da chamada para o ramal prejudique o aplicativo.
Ned Batchelder
103
Realmente, todo esse trabalho não se trata de impedir modificações, mas de aumentar sua dificuldade para que não valha mais a pena. Qualquer coisa pode sofrer engenharia reversa e modificar se houver benefícios suficientes.
Ned Batchelder
11
@Blair Conrad: Não se o código de verificação da licença também ocultar a funcionalidade. Exemplomylicensedfunction(licenseblob liblob, int foo, int bar, std::string bash)
Brian
8
Na verdade, eu vi código python comercial enviado como python incorporado dentro de uma biblioteca C. Em vez de converter algumas partes do código em C, elas ocultam todo o código python dentro de uma camada C protetora. Então, se eles querem um módulo importável por python, eles escrevem uma extensão fina de python sobre o C. Código aberto é um modo de vida muito mais fácil.
Mike McKerns
454

"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.

S.Lott
fonte
7
O ponto 2 é ainda mais importante. Se é mais barato comprar do que a engenharia reversa, além de atualizações anuais, ninguém tentará e, mesmo que o faça, ninguém pagará a um hacker o fornecedor do software.
M3nda 01/09/2015
Isso é verdade. A engenharia reversa é factível, mas cara na maioria das situações. @ S.Lott, acredito que o ponto 6 tem mais importância com base na pergunta. Se o código-fonte realmente precisar ser protegido, deverá ser remoto do usuário final.
Delali 10/10
7
Pergunta: "Existe uma boa maneira de proteger minha família e eu de ser assassinado por intrusos durante o sono?" Internet: "Não. Qualquer pessoa pode ser alcançada e nenhuma habitação é 100% impenetrável. Uma família humana mortal é a ferramenta errada para o trabalho".
Um algoritmo simples
O ponto 5 não pôde ser aplicado com o mesmo pressuposto de que ele pode sofrer engenharia reversa e rachar.
Jjmontes #
313

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 ...

e-satis
fonte
16
Python não é a ferramenta que você precisa. Malbolge é. :)
johndodo 4/11
8
Boa resposta, mas "questão legal casual"? Mesmo? Onde você mora que você tem quaisquer questões legais que são casual?
Mark E. Haase
1
Penso que, se tivermos uma frequência - com que frequência o código ofuscado é hackeado -, poderíamos dizer sobre a praticabilidade do uso de código ofuscado e Python.
Sergzach
Se o seu código tiver recursos interessantes, quem fosse capaz de usá-lo seria redistribuído @Macke
Delali 10/10
1
Como no mundo você "descobriria facilmente se alguém o faz"?
Make42
145

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.

Macke
fonte
Compilar com o cython funcionaria com um aplicativo Django 3.4 do python, ou poderia ser feito para funcionar sem uma enorme quantidade de esforço?
Daniel
@ Daniel: Não tenho certeza. Não tentei no Django. Sinta-se livre para postar uma nova pergunta sobre isso.
Macke
4
@mlvljr FWIW, IMHO compilar com binários é uma boa opção entre vender todos os seus segredos e tentar se proteger contra a engenharia reversa da classe NSA. Esp, se você tem uma grande base de código python e razões para ser paranóico. ;)
Macke
2
O POST de hithwen é inválido agora.
Qg_java_17137
58

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.

bhadra
fonte
1
Outras possibilidades na mesma linha: Shed pele code.google.com/p/shedskin e Nuitka kayhayen24x7.homelinux.org/blog/nuitka-a-python-compiler
TryPyPy
Acabei de dar uma olhada no Shed Skin, como sugerido por TyPyPy, e parece ser uma coisa muito boa!
Filipe
34

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.

Aaron Digulla
fonte
E se eles lançarem software para os clientes, e o cliente o modifica internamente, sem o relançar?
Nick T
@ Nick: Não muda a situação de forma alguma. Veja minhas edições.
Aaron Digulla
6
+1 por roubar idéias de volta. Por que limitar seu poder de atendimento ao cliente às suas soluções internas, quando você pode ver como os outros melhoram sua solução e, consequentemente, melhoram seu próprio produto? "Se você tem uma maçã e eu tenho uma maçã e nós trocamos essas maçãs, você e eu ainda vamos ter uma maçã. Mas se você tem uma idéia e eu tenho uma idéia e trocamos essas idéias, cada um de nós terá duas idéias ".
31413 Jordânia
E se um de seus clientes relançar seu código ou as idéias de forma gratuita e anônima? Você não pode dizer quem fez isso e processá-los e, como eles não foram beneficiados, você também não. Isso arruinará seu trabalho, enquanto um de vocês clientes pagou apenas o preço básico por isso. (obviamente, só funciona se você tiver mais de um cliente para a sua solução)
Skandix
1
@ Skandix Como exatamente isso funcionaria? Carregar seu trabalho na Internet não o prejudica. Começaria a prejudicá-lo se muitas pessoas o encontrassem e, em vez disso, pagariam aos clientes. O roubo de código é um mito. "Meu conhecimento é de graça, meu tempo é caro" (não sei quem disse isso).
Aaron Digulla
34

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)
Lmwangi
fonte
6
O ponto positivo disso é desmoralizar quem tenta decodificar a funcionalidade. Combine isso com o Cython e alguma criptografia extra em módulos ou chamadas pela Internet, e você provavelmente receberá um prêmio.
M3nda 01/09/2015
A única coisa que este pacote conseguiu realizar é enganar o 'ofuscador' que o código está ofuscado.
MarkRoxor 03/03/19
isso estava cometendo erros quando tentei. Eu acho que manipulou mal os dados e não os converteu completamente.
Vicrobot 01/10/19
não funciona para todo o projeto ou modelo de motor, uma vez que precisa de nome de variável para exibição no template
TomSawyer
Esta biblioteca não parece ser mantida e fornece erros de indentação. Estou usando o Python 3.7
PV
25

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.

Konrads
fonte
1
Como essa ideia extrema. Divulga de maneira gigantesca e com grande participação de mercado, então você tem uma grande base de clientes para suporte e complementos. Eu também tenho lidado com essa pergunta e todas as respostas de "licenciamento" são basicamente absurdas porque não protegem contra cópias generalizadas, mas não oferecem nenhuma vantagem de participação de mercado.
22413 Thomas Thomase
Mas, as atualizações também são apenas brindes ... então, como eles cobrariam por isso? Não seria apenas o apoio?
Make42
Em relação ao modelo de negócios WingIDE: Suporte é um serviço, software, um produto. Escala de produtos, serviço não. O suporte é apenas um bom modelo de negócios se não houver outro modelo de negócios - ou seja, se ninguém comprar seu produto (por qualquer motivo), você o distribuirá, para que você tenha uma base de clientes que pelo menos adquira seu serviço.
Make42
20

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

Vitaly Gordon
fonte
19

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.

Erik Forsberg
fonte
Sim, mas não se você distribuir a versão exata do Python com seu código ofuscado.
Alex
17

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.

Pensamento estranho
fonte
+1 (voltar a 0): parece a única solução verdadeira para o problema, assumindo que essa abordagem seja prática para a configuração.
intuited
10
Lembre-se de que, se o servidor da web de licenciamento ficar inoperante ou o acesso à Internet do cliente estiver inativo, o cliente não ficará satisfeito por não poder administrar seus negócios devido à perda de acesso às verificações de licenciamento.
DevPlayer
1
@DevPlayer Existem soluções para isso. Você pode implementar um mecanismo de chave local que permita acesso temporário quando o software não puder acessar o servidor de licenciamento remoto.
Jeffrey
1
@ Jeffrey: Isso leva você de volta ao ponto em que começou - como proteger esse código. Para ser mais seguro, você precisa colocar algumas das principais funcionalidades em seu próprio servidor; portanto, substituí-las exigiria muito esforço (nesse ponto, por que não iniciar um concorrente de código aberto?)
Oddthinking
14

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á.

Smi
fonte
3
A abordagem da biblioteca nativa torna muito mais fácil para alguém programaticamente forçar seu sistema de chave de licença, pois eles podem usar seu próprio código e API para validar suas licenças.
Tom Leys
8
Assim? Use o RSA para assinar sua licença e deixá-los forçar sua chave privada, digamos, consistindo em 1024 bits. É possível, mas leva muito tempo ... e, portanto, dinheiro.
Abgan
12

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.

DevPlayer
fonte
11

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.

Alex Coventry
fonte
10

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
mvallebr
fonte
9

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.

dbr
fonte
8

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.

Piotr Czapla
fonte
6

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

Peter Parker
fonte
1
+1 para a assinatura; -1 para o ofuscador Você pode pelo menos impedir que o código seja alterado.
44630 Ali Afshar #
2
A assinatura não funciona nesse contexto. É sempre possível ignorar o carregador de verificação de assinatura. A primeira coisa que você precisa para a proteção útil do software é um mecanismo opaco de inicialização. Não é algo que o Python facilita.
DDAA
Sim, inicialize em não-python.
44630 Ali Afshar #
Ou valide a licença não apenas na inicialização, mas em vários outros lugares. Pode ser facilmente implementado e pode aumentar severamente o tempo para ignorar.
Abgan 29/12/08
6

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.

fwzgekg
fonte
8
mas o fato de ter passado despercebido significava que eles fracassaram - o resultado final é simplesmente não tentar, mas buscar proteção legal.
Chii
Existe alguma informação publicada sobre como obter aprovação nesses mecanismos de proteção?
Mitar
6

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.

Brian C. Lane
fonte
5

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.

Mikael Lepistö
fonte
4

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.

Peter M
fonte
4

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 .

lambda11
fonte
3

É 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.

lalebarde
fonte
3

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 .

Artem
fonte
2

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.

Jondy Zhao
fonte
1

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

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

está disponível nos repositórios do ubuntu

Ali AlNoaimi
fonte
5
Eu acho que isso simplesmente agrupa os arquivos .pyc. Cython, Shed Skin e PyPy vão além do bytecode.
Cees Timmerman
1

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

Mike
fonte
O link vai para example.com.
Darian
@ Darian, obrigado por apontar isso. Eu atualizei o link.
Mike