Come posso proteggere il codice Python?

https://stackoverflow.com/questions/261638

06-07-2019
|

Domanda

Sto sviluppando un software in Python che verrà distribuito ai clienti del mio datore di lavoro. Il mio datore di lavoro desidera limitare l'utilizzo del software con un file di licenza con orario limitato.

Se distribuiamo i file .py o anche i file .pyc sarà facile (decompilare e) rimuovere il codice che controlla il file di licenza.

Un altro aspetto è che il mio datore di lavoro non vuole che il codice venga letto dai nostri clienti, temendo che il codice possa essere rubato o almeno le "nuove idee".

C'è un buon modo per gestire questo problema? Preferibilmente con una soluzione standard.

Il software funzionerà su sistemi Linux (quindi non credo che py2exe farà il trucco).

Soluzione

Python, essendo un linguaggio interpretato compilato con codice byte, è molto difficile da bloccare. Anche se usi un exe-packager come py2exe , il layout dell'eseguibile è noto e i codici byte Python sono ben compresi.

Di solito in casi come questo, devi fare un compromesso. Quanto è veramente importante proteggere il codice? Ci sono veri segreti lì dentro (come una chiave per la crittografia simmetrica dei bonifici bancari) o sei solo paranoico? Scegli la lingua che ti consente di sviluppare il miglior prodotto più rapidamente e sii realistico su quanto siano preziose le tue nuove idee.

Se decidi che devi davvero imporre il controllo della licenza in modo sicuro, scrivilo come una piccola estensione C in modo che il codice di controllo della licenza possa essere molto difficile (ma non impossibile!) per decodificare e lasciare la maggior parte del tuo codice in Python.

Altri suggerimenti

" C'è un buon modo per gestire questo problema? " No. Nulla può essere protetto contro il reverse engineering. Anche il firmware su macchine DVD è stato retroingegnerizzato e chiave di crittografia AACS . E questo nonostante il DMCA abbia commesso un reato.

Poiché nessun metodo tecnico può impedire ai tuoi clienti di leggere il tuo codice, devi applicare i normali metodi commerciali.

Licenze. Contratti. Termini e condizioni. Funziona ancora anche quando le persone possono leggere il codice. Si noti che alcuni dei componenti basati su Python potrebbero richiedere il pagamento di commissioni prima di vendere software utilizzando tali componenti. Inoltre, alcune licenze open source ti vietano di nascondere la fonte o le origini di quel componente.
Offri un valore significativo. Se le tue cose sono così buone - a un prezzo che è difficile da rifiutare - non c'è alcun incentivo a perdere tempo e denaro per decodificare qualcosa. Il reverse engineering è costoso. Rendi il tuo prodotto leggermente meno costoso.
Offri aggiornamenti e miglioramenti che rendono qualsiasi ingegneria inversa una cattiva idea. Quando la prossima versione interrompe il loro reverse engineering, non ha senso. Questo può essere portato a livelli assurdi, ma dovresti offrire nuove funzionalità che rendono la prossima versione più preziosa del reverse engineering.
Offri la personalizzazione a tariffe così interessanti che preferiscono pagare per creare e supportare i miglioramenti.
Utilizza una chiave di licenza che scade. Questo è crudele e ti darà una cattiva reputazione, ma sicuramente farà smettere di funzionare il tuo software.
Offrilo come servizio web. SaaS non prevede download per i clienti.

Python non è lo strumento necessario

Devi usare lo strumento giusto per fare la cosa giusta e Python non è stato progettato per essere offuscato. È il contrario; tutto è aperto o facile da rivelare o modificare in Python perché questa è la filosofia del linguaggio.

Se vuoi qualcosa che non riesci a vedere, cerca un altro strumento. Questa non è una cosa negativa, è importante che esistano diversi strumenti diversi per usi diversi.

L'offuscamento è davvero difficile

Anche i programmi compilati possono essere retroingegnerizzati, quindi non pensare di poter proteggere completamente qualsiasi codice. Puoi analizzare PHP offuscato, rompere la chiave di crittografia flash, ecc. Le versioni più recenti di Windows vengono violate ogni volta.

Avere un requisito legale è una buona strada da percorrere

Non puoi impedire a qualcuno di abusare del tuo codice, ma puoi facilmente scoprire se qualcuno lo fa. Pertanto, è solo un problema legale occasionale.

La protezione del codice è sopravvalutata

Al giorno d'oggi, i modelli di business tendono a vendere servizi anziché prodotti. Non è possibile copiare un servizio, pirata né rubarlo. Forse è il momento di considerare di seguire il flusso ...

Compila python e distribuisci i binari!

Idea sensata:

Usa Cython , Nuitka , Shed Skin o qualcosa di simile alla compilazione di Python in codice C, quindi distribuisci la tua app come binario Python librerie (pyd) invece.

In questo modo, non è rimasto alcun codice Python (byte) e hai fatto una ragionevole quantità di oscuramento che chiunque (ad esempio il tuo datore di lavoro) potrebbe aspettarsi dal normale Codice, credo. (.NET o Java sono meno sicuri di questo caso, poiché quel bytecode non è offuscato e può essere facilmente decompilato in una fonte ragionevole.)

Cython sta diventando sempre più compatibile con CPython, quindi penso che dovrebbe funzionare. (In realtà lo sto prendendo in considerazione per il nostro prodotto .. Stiamo già costruendo alcune librerie di terze parti come pyd / dlls, quindi spedire il nostro codice python come binari non è un passo eccessivamente grande per noi.)

Vedi Questo post sul blog (non da me) per un tutorial su come farlo. (grazie @hithwen)

Pazza idea:

Probabilmente potresti fare in modo che Cython memorizzi i file C separatamente per ciascun modulo, quindi concatenali tutti e costruiscili con un pesante allineamento. In questo modo, il tuo modulo Python è piuttosto monolitico e difficile da utilizzare con strumenti comuni.

Oltre la follia:

Potresti essere in grado di creare un singolo eseguibile se riesci a collegarti (e ottimizzare con) il runtime di Python e tutte le librerie (dll) staticamente. In questo modo, sarebbe sicuramente difficile intercettare le chiamate da / verso Python e qualunque libreria di framework in uso. Questo non può essere fatto se si utilizza il codice LGPL.

Comprendo che vuoi che i tuoi clienti utilizzino la potenza di Python ma non vuoi esporre il codice sorgente.

Ecco i miei suggerimenti:

(a) Scrivi le parti critiche del codice come librerie C o C ++ e quindi utilizza SIP o swig per esporre le API C / C ++ allo spazio dei nomi Python.

(b) Usa cython invece di Python

(c) In entrambi (a) e (b), dovrebbe essere possibile distribuire le librerie come binarie con licenza con un'interfaccia Python.

Il tuo datore di lavoro è consapevole di poter " rubare " Qualche idea che altre persone ottengono dal tuo codice? Voglio dire, se riescono a leggere il tuo lavoro, puoi farlo anche tu. Forse guardare come trarre vantaggio dalla situazione produrrebbe un ritorno migliore del tuo investimento rispetto alla paura di quanto potresti perdere.

[MODIFICA] Risposta al commento di Nick:

Niente di guadagnato e niente di perso. Il cliente ha quello che vuole (e lo ha pagato da quando ha fatto il cambiamento da solo). Dal momento che non rilascia il cambiamento, è come se non fosse accaduto per tutti gli altri.

Ora, se il cliente vende il software, deve cambiare la nota sul copyright (che è illegale, quindi puoi fare causa e vincere - > caso semplice).

Se non modificano la nota sul copyright, i clienti di 2 ° livello noteranno che il software proviene da te originale e si chiederanno cosa stia succedendo. È probabile che ti contatteranno e quindi imparerai a rivendere il tuo lavoro.

Ancora una volta abbiamo due casi: il cliente originale ha venduto solo poche copie. Ciò significa che comunque non hanno fatto molti soldi, quindi perché preoccuparsi. O hanno venduto in volume. Ciò significa maggiori possibilità per te di imparare cosa fanno e fare qualcosa al riguardo.

Ma alla fine, la maggior parte delle aziende cerca di conformarsi alla legge (una volta che la loro reputazione è rovinata, è molto più difficile fare affari). Quindi non ruberanno il tuo lavoro ma collaboreranno con te per migliorarlo. Quindi, se includi la fonte (con una licenza che ti protegge dalla semplice rivendita), è probabile che rispediranno semplicemente le modifiche apportate poiché ciò assicurerà che la modifica sia nella prossima versione e che non debbano mantenerla . È vantaggioso per tutti: ottieni modifiche e loro possono apportare le modifiche da soli se ne hanno davvero, disperatamente bisogno, anche se non sei disposto a includerlo nella versione ufficiale.

Hai dato un'occhiata a pyminifier ? Minimizza, offusca e comprime il codice Python. Il codice di esempio sembra piuttosto brutto per il reverse engineering casuale.

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

Non fare affidamento sull'offuscamento. Come hai giustamente concluso, offre una protezione molto limitata. AGGIORNAMENTO: ecco un link alla carta che ha la tecnica inversa codice pitone offuscato in Dropbox. L'approccio: la rimappatura del codice operativo è una buona barriera, ma chiaramente può essere sconfitta.

Invece, come molti poster hanno menzionato, fallo:

Non vale il tempo di reverse engineering (il tuo software è così buono, ha senso pagare)
Falli firmare un contratto e, se possibile, fai un controllo della licenza.

In alternativa, come fa l'IDE Python IDE WingIDE: Dai via il codice . Esatto, dai via il codice e chiedi alle persone di tornare per aggiornamenti e supporto.

La spedizione dei file .pyc ha i suoi problemi: non sono compatibili con altre versioni di Python diverse dalla versione con cui sono state create, il che significa che è necessario sapere quale versione di Python è in esecuzione sui sistemi su cui verrà eseguito il prodotto. Questo è un fattore molto limitante.

In alcune circostanze, potrebbe essere possibile spostare (tutto, o almeno una parte chiave) del software in un servizio web ospitato dalla tua organizzazione.

In questo modo, i controlli di licenza possono essere eseguiti nella sicurezza della propria sala server.

Anche se non esiste una soluzione perfetta, si può fare quanto segue:

Sposta alcune parti critiche del codice di avvio in una libreria nativa.
Applica il controllo della licenza nella libreria nativa.

Se la chiamata al codice nativo dovesse essere rimossa, il programma non si avvierebbe comunque. Se non viene rimosso, verrà applicata la licenza.

Sebbene questa non sia una soluzione multipiattaforma o pura Python, funzionerà.

L'unico modo affidabile per proteggere il codice è eseguirlo su un server che controlli e fornire ai tuoi clienti un client che si interfaccia con quel server.

Penso che ci sia un altro metodo per proteggere il tuo codice Python; parte del metodo di offuscamento. Credo che ci sia stato un gioco come Mount and Blade o qualcosa che ha cambiato e ricompilato il proprio interprete Python (l'interprete originale che credo sia open source) e ha semplicemente cambiato i codici OP nella tabella dei codici OP in modo che fossero diversi rispetto all'OP standard in Python codici.

Quindi l'origine python non è modificata ma le estensioni dei file * .pyc sono diverse e i codici op non corrispondono all'interprete pubblico python.exe. Se hai controllato i file di dati dei giochi, tutti i dati erano in formato sorgente Python.

In questo modo è possibile fare ogni sorta di brutti scherzi per scherzare con gli hacker immaturi. Fermare un gruppo di hacker inesperti è facile. Sono gli hacker professionisti che probabilmente non batterai. Ma la maggior parte delle aziende non tiene gli hacker professionisti sul personale a lungo immagino (probabilmente perché le cose vengono violate). Ma gli hacker immaturi sono ovunque (leggi come personale IT curioso).

Ad esempio, potresti, in un interprete modificato, consentirgli di verificare determinati commenti o stringhe di documenti nella tua fonte. Potresti avere codici OP speciali per tali righe di codice. Ad esempio:

OP 234 è per la riga di origine & #; # Copyright Ho scritto questo " oppure compila quella riga in codici operativi equivalenti a " se False: " se " # Copyright " manca. Fondamentalmente disabilita un intero blocco di codice per quella che sembra essere una ragione oscura.

Un caso d'uso in cui la ricompilazione di un interprete modificato potrebbe essere fattibile è quello in cui non hai scritto l'app, l'app è grande, ma sei pagato per proteggerla, come quando sei un amministratore del server dedicato per un app.

Trovo un po 'contraddittorio lasciare la fonte o i codici operativi aperti per i bulbi oculari, ma uso SSL per il traffico di rete. Anche SSL non è sicuro al 100%. Ma è usato per impedire alla maggior parte degli occhi di leggerlo. Una piccola precauzione è ragionevole.

Inoltre, se un numero sufficiente di persone ritiene che la fonte e i codici operativi di Python siano troppo visibili, è probabile che qualcuno alla fine svilupperà almeno un semplice strumento di protezione. Quindi più persone chiedono "come proteggere l'app Python" promuove solo tale sviluppo.

A seconda di chi sia il cliente, un semplice meccanismo di protezione, combinato con un ragionevole accordo di licenza, sarà di gran lunga più efficace di qualsiasi sistema complesso di licenze / crittografia / offuscamento.

La soluzione migliore sarebbe vendere il codice come servizio, ad esempio ospitando il servizio o offrendo supporto, anche se non è sempre pratico.

Spedire il codice come file .pyc eviterà che la tua protezione venga sventata da alcuni # , ma è difficilmente efficace la protezione antipirateria (come se ci fosse una tecnologia) e, alla fine, non dovrebbe ottenere nulla di simile a un accordo di licenza decente con la società.

Concentrati sul rendere il tuo codice il più piacevole possibile da usare - avere clienti felici farà guadagnare alla tua azienda molto più denaro che prevenire un po 'di pirateria teorica ..

Usa Cython . Compilerà i tuoi moduli in file C ad alte prestazioni, che possono quindi essere compilati in librerie binarie native. Questo è sostanzialmente non reversibile, rispetto al bytecode .pyc!

Ho scritto un articolo dettagliato su come configurare Cython per un progetto Python, dai un'occhiata:

Protezione delle fonti Python con Cython

Un altro tentativo di rendere il codice più difficile da rubare è utilizzare jython e quindi utilizzare java obfuscator .

Questo dovrebbe funzionare abbastanza bene poiché jythonc traduce il codice python in java e quindi java viene compilato in bytecode. Quindi oncia offuscare le classi, sarà davvero difficile capire cosa sta succedendo dopo la decompilazione, per non parlare del recupero del codice attuale.

L'unico problema con jython è che non puoi usare i moduli python scritti in c.

Che dire della firma del codice con schemi di crittografia standard tramite hash e firma di file importanti e verificandolo con metodi a chiave pubblica?

In questo modo è possibile emettere il file di licenza con una chiave pubblica per ciascun cliente.

In aggiunta puoi usare un python offuscatore come questo (solo cercato su Google).

Dovresti dare un'occhiata a come lo fanno i ragazzi di getdropbox.com per il loro software client, incluso Linux. È abbastanza complicato da decifrare e richiede uno smontaggio abbastanza creativo per superare i meccanismi di protezione.

Sono stato sorpreso di non aver visto pyconcrete in nessuna risposta. Forse perché è più recente della domanda?

Potrebbe essere esattamente quello di cui hai bisogno (ed).

Invece di offuscare il codice, lo crittografa e lo decodifica al momento del caricamento.

Dalla pagina pypi :

Proteggi il flusso di lavoro degli script python


your_script.py import pyconcrete

pyconcrete aggancerà il modulo di importazione

quando lo script importa MODULE ,   pyconcrete import hook proverà prima a trovare MODULE.pye   decodifica MODULE.pye tramite _pyconcrete.pyd ed esegue i dati decodificati (come   .pyc content)

crittografa & amp; decodifica il record della chiave segreta in _pyconcrete.pyd   (come DLL o SO) la chiave segreta sarebbe nascosta in codice binario, non è possibile   vederlo direttamente in visualizzazione HEX

Il meglio che puoi fare con Python è oscurare le cose.

Rimuovi tutti i documenti
Distribuisci solo i file compilati .pyc.
congelalo
Oscura le tue costanti all'interno di una classe / modulo in modo che help (config) non mostri tutto

Potresti essere in grado di aggiungere ulteriore oscurità crittografando parte di esso e decrittografandolo al volo e passandolo a eval (). Ma qualunque cosa tu faccia, qualcuno può romperlo.

Niente di tutto ciò impedirà a un determinato attaccante di smontare il bytecode o scavare attraverso l'API con aiuto, dir, ecc.

L'idea di avere una licenza a tempo limitato e verificarla nel programma installato localmente non funzionerà. Anche con perfetta offuscamento, il controllo della licenza può essere rimosso. Tuttavia, se controlli la licenza sul sistema remoto ed esegui una parte significativa del programma sul tuo sistema remoto chiuso, sarai in grado di proteggere il tuo IP.

Impedendo ai concorrenti di utilizzare il codice sorgente come loro o di scrivere la loro versione ispirata dello stesso codice, un modo per proteggere è aggiungere firme alla logica del programma (alcuni segreti per dimostrare che il codice ti è stato rubato) e offuscare il codice sorgente di Python, quindi è difficile da leggere e utilizzare.

La buona offuscamento aggiunge sostanzialmente la stessa protezione al tuo codice, che la compila in eseguibile (e stripping binario). Capire come funziona il codice complesso offuscato potrebbe essere persino più difficile che scrivere la tua implementazione.

Questo non aiuterà a prevenire l'hacking del tuo programma. Anche con il codice di offuscamento la roba della licenza verrà violata e il programma potrebbe essere modificato per avere un comportamento leggermente diverso (allo stesso modo in cui la compilazione del codice in binario non aiuta la protezione dei programmi nativi).

Oltre all'offuscamento dei simboli potrebbe essere una buona idea annullare la riformulazione del codice, il che rende tutto ancora più confuso se ad es. i grafici delle chiamate indicano molti luoghi diversi anche se in realtà quei posti diversi alla fine fanno la stessa cosa.

Firma logica all'interno del codice offuscato (ad es. è possibile creare una tabella di valori che sono usati dalla logica del programma, ma anche usati come firma), che possono essere usati per determinare che il codice è stato originato da te. Se qualcuno decide di utilizzare il tuo modulo di codice offuscato come parte del proprio prodotto (anche dopo averlo nuovamente offuscato per farlo sembrare diverso), puoi mostrare che quel codice viene rubato con la tua firma segreta.

Ho esaminato la protezione del software in generale per i miei progetti e la filosofia generale è che la protezione completa è impossibile. L'unica cosa che puoi sperare di ottenere è aggiungere una protezione a un livello che costerebbe di più ai tuoi clienti bypassare di quanto non acquisterebbe un'altra licenza.

Detto questo, stavo solo controllando google per l'oscuramento di Python e non ho scoperto molto. In una soluzione .Net, l'oscuramento sarebbe un primo approccio al tuo problema su una piattaforma Windows, ma non sono sicuro che qualcuno abbia soluzioni su Linux che funzionino con Mono.

La prossima cosa sarebbe scrivere il tuo codice in un linguaggio compilato, o se vuoi davvero andare fino in fondo, poi in assembler. Un eseguibile eliminato sarebbe molto più difficile da decompilare di un linguaggio interpretato.

Tutto si riduce ai compromessi. Da un lato hai facilità nello sviluppo di software in Python, in cui è anche molto difficile nascondere segreti. Dall'altra parte hai un software scritto in assemblatore che è molto più difficile da scrivere, ma è molto più facile nascondere i segreti.

Il tuo capo deve scegliere un punto da qualche parte lungo quel continuum che supporta le sue esigenze. E poi deve darti gli strumenti e il tempo in modo da poter costruire quello che vuole. Tuttavia la mia scommessa è che si opporrà a costi di sviluppo reali rispetto a potenziali perdite monetarie.

È possibile avere il codice byte py2exe in una risorsa crittografata per un lanciatore C che lo carica e lo esegue in memoria. Alcune idee qui e qui .

Alcuni hanno anche pensato a un programma di auto-modifica per fare il contrario ingegneria costosa.

Puoi anche trovare tutorial per prevenire i debugger , far fallire il disassemblatore, impostare falsi punti di interruzione del debugger e proteggi il tuo codice con checksum. Cerca [" codice crittografato " esegui " in memoria "] per altri collegamenti.

Ma come già detto da altri, se il tuo codice ne vale la pena, alla fine ci riusciranno gli ingegneri inversi.

Per farla breve:

Crittografa il tuo codice sorgente
Scrivi il tuo caricatore di moduli Python per decrittografare il codice durante l'importazione
Implementa il caricatore di moduli in C / C ++
Puoi aggiungere più funzionalità al caricatore del modulo, ad esempio anti-debugger, controllo delle licenze, rilegatura delle impronte digitali hardware, ecc.

Per maggiori dettagli, guarda questa risposta .

Se sei interessato all'argomento, questo progetto ti aiuterà - pyprotect .

Se ci concentriamo sulle licenze software, consiglierei di dare un'occhiata a un'altra risposta Stack Overflow che ho scritto qui a trarre ispirazione da come può essere costruito un sistema di verifica della chiave di licenza.

Esiste una libreria open source su GitHub che può aiutarti nella verifica della licenza bit.

Puoi installarlo con pip install licensing e quindi aggiungere il seguente codice:

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

Puoi leggere ulteriori informazioni sulla configurazione della chiave pubblica RSA, ecc. qui .

usando cxfreeze (py2exe per linux) farà il lavoro.

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

è disponibile nei repository ubuntu

Usa lo stesso modo per proteggere il file binario di c / c ++, ovvero offuscare ogni corpo della funzione nel file binario eseguibile o della libreria, inserire un'istruzione "jump" all'inizio di ciascuna voce della funzione, passare alla funzione speciale per ripristinare il codice offuscato. Il codice byte è il codice binario dello script Python, quindi

Prima compila lo script python per codificare l'oggetto
Quindi iterare ogni oggetto codice, offuscare co_code di ciascun oggetto codice come il seguente

    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

Salva oggetto di codice offuscato come file .pyc o .pyo

Quei file offuscati (.pyc o .pyo) possono essere usati dal normale interprete python, quando l'oggetto codice viene chiamato la prima volta

La prima operazione è JUMP_ABSOLUTE, passerà all'offset n

All'offset n, l'istruzione è di chiamare una funzione PyC. Questa funzione ripristinerà quelli bytecode offuscati tra offset 3 e n e posizionerà il codice byte originale su offset 0. Il codice offuscato può essere ottenuto con il seguente codice

    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)

Dopo il ritorno di questa funzione, l'ultima istruzione è saltare a offset 0. Il vero codice byte ora viene eseguito.

Esiste uno strumento Pyarmor per offuscare gli script Python in questo modo.

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow