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 limiti di tempo.

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

Python, essendo un linguaggio interpretato compilato con codice byte, è molto difficile da bloccare. Anche se si utilizza 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 trasferimenti 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 .

"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 ed è stata esposta la 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.

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

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

3. Offri aggiornamenti e miglioramenti che rendono qualsiasi ingegneria inversa una cattiva idea. Quando la prossima versione rompe 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.

4. Offri la personalizzazione a tariffe così interessanti che preferiscono pagare per creare e supportare i miglioramenti.

5. Utilizzare una chiave di licenza che scade. Questo è crudele e ti darà una cattiva reputazione, ma sicuramente farà smettere di funzionare il tuo software.

6. Offrilo come servizio web. SaaS non prevede download per i clienti.

Python non è lo strumento di cui hai bisogno

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

Compilare Python e distribuire i binari!

Idea sensata:

Usa Cython , Nuitka , Shed Skin o qualcosa di simile per compilare python in codice C, quindi distribuisci la tua app come librerie binarie python (pyd).

In questo modo, non è rimasto alcun codice Python (byte) e hai fatto una ragionevole quantità di oscuramento che chiunque (cioè 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à sto considerando questo 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 troppo 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 pesanti allineamenti. In questo modo, il tuo modulo Python è piuttosto monolitico e difficile da utilizzare con strumenti comuni.

Oltre pazzo:

Potresti essere in grado di creare un singolo eseguibile se riesci a collegarti (e ottimizzare con) il runtime 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 usa SIP o swig per esporre le API C / C ++ allo spazio dei nomi Python.

(b) Usa cython invece di Python

(c) In entrambe le lettere (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" eventuali idee che altre persone ottengono dal tuo codice? Voglio dire, se riescono a leggere il tuo lavoro, puoi farlo anche tu. Forse osservare come trarre vantaggio dalla situazione produrrebbe un ritorno dell'investimento migliore rispetto alla paura di quanto si potrebbe perdere.

[EDIT] Rispondi 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 successo a tutti gli altri.

Ora, se il cliente vende il software, deve modificare 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 . Questo è vantaggioso per tutti: ottieni cambiamenti e loro possono apportare i cambiamenti 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 invertito il 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 rendono:

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

In alternativa, come fa il kick-ass Python IDE WingIDE: regala il codice . Esatto, dai il codice e chiedi alle persone di tornare per aggiornamenti e supporto.

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

La spedizione dei file .pyc ha i suoi problemi: non sono compatibili con nessuna versione di Python diversa dalla versione con cui sono stati creati, 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 dall'organizzazione.

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

Sebbene non esista una soluzione perfetta, è possibile eseguire le seguenti operazioni:

1. Sposta alcune parti critiche del codice di avvio in una libreria nativa.
2. Applicare 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à.

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 si possono fare tutti i tipi 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 hackerate). 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. È possibile disporre di codici OP speciali per tali righe di codice. Per esempio:

OP 234 è per la riga di origine "# Copyright Ho scritto questo" o compila quella riga in codici operativi equivalenti a "if False:" se manca "# Copyright". 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 finanziaria.

Trovo un po 'contraddittorio lasciare la fonte o gli opcode 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 quello sviluppo.

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.

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

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

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 viene importato MODULE, il gancio di importazione pyconcrete proverà MODULE.pyeprima a trovare e quindi a decifrare MODULE.pyetramite _pyconcrete.pyded eseguire dati decrittografati (come contenuto .pyc)
• crittografare e decrittografare il record della chiave segreta in _pyconcrete.pyd (come DLL o SO) la chiave segreta sarebbe nascosta nel codice binario, non può vederla direttamente nella vista esadecimale

A seconda di chi sia il cliente, un semplice meccanismo di protezione, combinato con un ragionevole accordo di licenza, sarà lontano 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 .pycfile eviterà che la tua protezione venga sventata da alcuni #secondi, ma è appena efficace la protezione antipirateria (come se ci fosse una tale tecnologia), e alla fine, non dovrebbe ottenere nulla che un accordo di licenza decente con la società sarà

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.

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 che offuschi le classi, sarà davvero difficile capire cosa sta succedendo dopo la decompilazione, per non parlare del recupero del codice reale.

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

Che ne dici di firmare il tuo codice con schemi di crittografia standard eseguendo l'hashing e firmando file importanti e controllandolo con metodi a chiave pubblica?

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

Inoltre puoi usare un Python Obfuscator come questo (basta cercarlo 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.

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

• Elimina tutte le dotstring
• Distribuire 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 essere in grado di dimostrare che il codice ti è stato rubato) e offuscare il codice sorgente python quindi, è difficile da leggere e utilizzare.

Una 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 ancora più difficile che scrivere davvero 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 (nello 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 esempio, i grafici delle chiamate puntano verso 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 utilizzati 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 è quella di aggiungere una protezione a un livello che costerebbe di più ai tuoi clienti bypassare che acquistare un'altra licenza.

Detto questo, stavo solo controllando google per l'oscuramento del pitone e non trovavo 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à ai costi di sviluppo reali contro potenziali perdite monetarie.

Per farla breve:

1. Crittografa il tuo codice sorgente
2. Scrivi il tuo caricatore di moduli Python per decrittografare il codice durante l'importazione
3. Implementare il caricatore di moduli in C / C ++
4. È possibile 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 .

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

Alcuni hanno anche pensato a un programma di auto-modifica di per rendere costoso il reverse engineering.

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

Ma come altri hanno già detto, se il tuo codice ne vale la pena, alla fine riusciranno i reverse engineer.

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

C'è una libreria open source su GitHub che può aiutarti con il bit di verifica della licenza.

È possibile installarlo pip install licensinge 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 sul modo in cui la chiave pubblica RSA, ecc. È configurata qui .

Utilizzare 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 ogni 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 di codice, offuscare co_code di ciascun oggetto di codice come segue

    0 JUMP_ABSOLUTE n = 3 + len (bytecode)

    3
    ...
    ... Qui è offuscato dal codice
    ...

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

• Salvare l'oggetto codice offuscato come file .pyc o .pyo

Quei file offuscati (.pyc o .pyo) possono essere usati dal normale interprete python, quando l'oggetto code 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 è passare all'offset 0. Il codice byte reale ora viene eseguito.

C'è uno strumento Pyarmor per offuscare gli script Python in questo modo.

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

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

è disponibile nei repository Ubuntu

C'è una risposta completa su come nascondere il codice sorgente di Python, che puoi trovare qui .

Le possibili tecniche discusse sono:
- utilizzare bytecode compilato ( python -m compileall)
- creatori eseguibili (o installatori come PyInstaller )
- software come servizio (la migliore soluzione per nascondere il codice secondo me)
- offuscatori del codice sorgente di Python