Saya mengembangkan sebuah software Python yang akan dibagikan kepada majikan saya's pelanggan. Majikan saya ingin membatasi penggunaan perangkat lunak dengan waktu terbatas file lisensi.
Jika kita mendistribusikan .py file atau bahkan .pyc file ini akan mudah untuk (menguraikan dan) menghapus kode yang memeriksa file lisensi.
Aspek lain adalah bahwa majikan saya tidak ingin kode yang dapat dibaca oleh pelanggan kami, takut bahwa kode dapat dicuri atau setidaknya "ide-ide baru".
Apakah ada cara yang baik untuk menangani masalah ini? Sebaiknya dengan off-the-shelf solusi.
Perangkat lunak ini akan berjalan pada sistem Linux (jadi saya don't pikir py2exe akan melakukan trik).
"Apakah ada cara yang baik untuk menangani masalah ini?" Tidak. Tidak ada yang dapat dilindungi terhadap reverse engineering. Bahkan firmware pada DVD mesin telah membalikkan direkayasa dan AACS kunci Enkripsi terkena. Dan yang's terlepas dari DMCA membuat bahwa tindak pidana.
Karena tidak ada metode teknis yang dapat menghentikan anda pelanggan dari membaca kode anda, anda harus menerapkan komersial biasa metode.
Lisensi. Kontrak. Syarat dan Kondisi. Ini masih bekerja bahkan ketika orang-orang dapat membaca kode. Perhatikan bahwa beberapa dari anda Python berbasis komponen mungkin mengharuskan anda untuk membayar biaya sebelum anda menjual software dengan menggunakan komponen-komponen tersebut. Juga, beberapa open source lisensi yang melarang anda untuk menyembunyikan sumber atau asal-usul dari komponen tersebut.
Menawarkan nilai yang signifikan. Jika barang-barang anda begitu baik -- dengan harga yang lebih keras untuk menolak -- ada's tidak ada insentif untuk membuang-buang waktu dan uang reverse engineering apa-apa. Reverse engineering adalah mahal. Membuat produk anda sedikit lebih mahal.
Menawarkan upgrade dan perangkat tambahan yang membuat setiap reverse engineering ide yang buruk. Ketika rilis berikutnya istirahat mereka reverse engineering, ada's tidak ada gunanya. Hal ini dapat dilakukan untuk absurd ekstrem, tapi anda harus menawarkan fitur-fitur baru yang membuat rilis berikutnya lebih berharga dari reverse engineering.
Menawarkan kustomisasi pada tingkat yang begitu menarik sehingga mereka'd suka membayar anda membangun dan mendukung perangkat tambahan.
Menggunakan license key yang berakhir. Ini adalah kejam, dan akan memberikan anda reputasi yang buruk, tapi hal itu tentu saja membuat perangkat lunak anda berhenti bekerja.
Memberikan itu sebagai layanan web. SaaS tidak melibatkan popularitas untuk pelanggan.
Python, menjadi byte-code-dikumpulkan diinterpretasikan bahasa, adalah sangat sulit untuk mengunci. Bahkan jika anda menggunakan exe-packager seperti py2exe, tata letak eksekusi terkenal, dan Python byte-kode yang dipahami dengan baik.
Biasanya dalam kasus seperti ini, anda harus membuat tradeoff. Bagaimana penting apakah itu benar-benar untuk melindungi kode? Ada rahasia nyata di sana (seperti kunci untuk enkripsi simetris bank transfer), atau anda hanya paranoid? Memilih bahasa yang memungkinkan anda mengembangkan produk terbaik tercepat, dan realistis tentang bagaimana berharga anda ide-ide baru yang.
Jika anda memutuskan anda benar-benar perlu untuk menegakkan memeriksa lisensi aman, menulis itu sebagai kecil C ekstensi sehingga lisensi cek kode dapat ekstra-keras (tetapi bukan tidak mungkin!) untuk reverse engineer, dan meninggalkan sebagian besar kode dalam Python.
Anda harus menggunakan alat yang tepat untuk melakukan hal yang benar, dan Python tidak dirancang untuk menjadi dikaburkan. It's sebaliknya; semuanya terbuka atau mudah untuk mengungkapkan atau memodifikasi di Python karena itu's bahasa's filsafat.
Jika anda ingin sesuatu yang anda bisa't see through, mencari alat lain. Ini bukan hal yang buruk, itu adalah penting bahwa beberapa alat yang berbeda yang ada untuk penggunaan yang berbeda.
Bahkan menyusun program-program yang dapat di-reverse-engineered jadi don't berpikir bahwa anda dapat sepenuhnya melindungi setiap kode. Anda dapat menganalisis dikaburkan PHP, istirahat flash kunci enkripsi, dll. Versi yang lebih baru dari Windows yang pecah-pecah setiap saat.
Anda tidak dapat mencegah seseorang dari menyalahgunakan kode anda, tetapi anda dapat dengan mudah menemukan jika seseorang tidak. Oleh karena itu, it's just a casual masalah hukum.
Saat ini, model bisnis yang cenderung untuk pergi untuk menjual jasa, bukan produk. Anda tidak dapat menyalin layanan, bajak laut atau mencurinya. Mungkin itu's waktu untuk mempertimbangkan untuk pergi dengan aliran...
Gagasan yang masuk akal:
Gunakan Acpi, Nuitka, Menumpahkan Kulit atau sesuatu yang mirip untuk mengkompilasi python untuk kode C, kemudian mendistribusikan aplikasi anda sebagai python binary perpustakaan (pyd) sebagai gantinya.
Dengan cara itu, tidak ada Python (byte) kode kiri dan anda've dilakukan setiap jumlah yang masuk akal obscurification siapa saja (yaitu majikan anda) bisa mengharapkan dari Kode biasa, saya pikir. (.NET atau Java kurang aman dari kasus ini, seperti yang bytecode tidak dikaburkan dan relatif dapat dengan mudah menjadi decompiled menjadi wajar sumber.)
Acpi adalah mendapatkan lebih banyak dan lebih kompatibel dengan CPython, jadi saya pikir itu harus bekerja. (Saya'm benar-benar mempertimbangkan ini untuk produk kami.. Kami're sudah membangun beberapa thirdparty libs sebagai pyd/dll, jadi pengiriman kami sendiri kode python sebagai binari tidak terlalu besar bagi kita.)
Lihat Posting Blog Ini (tidak oleh saya) untuk tutorial tentang cara untuk melakukannya. (thx @hithwen)
Ide gila:
Anda mungkin bisa mendapatkan Acpi untuk menyimpan C-file terpisah untuk setiap modul, maka hanya menggabungkan mereka semua dan membangun mereka dengan berat inlining. Dengan cara itu, anda Python modul ini cukup monolitik dan sulit untuk chip dengan alat biasa.
Di luar gila:
Anda mungkin bisa membangun executable tunggal jika anda dapat link ke (dan mengoptimalkan dengan) python runtime dan semua libraries (dll) statis. Dengan cara itu, it'd pasti akan sulit untuk mencegat panggilan ke/dari python dan apapun kerangka pustaka yang anda gunakan. Hal ini tidak dapat dilakukan jika anda're menggunakan LGPL kode sekalipun.
Saya memahami bahwa anda ingin pelanggan anda untuk menggunakan kekuatan python tapi tidak ingin mengekspos kode sumber.
Berikut ini adalah saran saya:
(a) Menulis kritis potongan kode seperti C atau C++ perpustakaan dan kemudian gunakan SIP atau meneguk untuk mengekspos C/C++ Api Python namespace.
(b) Menggunakan acpi bukan Python
(c) baik (a) dan (b), itu harus mungkin untuk mendistribusikan perpustakaan sebagai lisensi biner dengan Python antarmuka.
Majikan anda menyadari bahwa dia dapat "mencuri" kembali ide-ide yang orang lain dapatkan dari kode anda? Maksud saya, jika mereka dapat membaca pekerjaan anda, sehingga dapat anda milik mereka. Mungkin melihat bagaimana anda bisa mendapatkan keuntungan dari situasi yang akan menghasilkan hasil yang lebih baik dari investasi anda dari takut berapa banyak anda bisa menurunkan.
[SUNTING] Jawaban untuk Nick's komentar:
Ada yang naik dan ada yang turun. Pelanggan memiliki apa yang dia inginkan (dan dibayar untuk itu sejak dia mengubah dirinya sendiri). Sejak dia doesn't melepaskan berubah,'s seolah-olah itu tidak't terjadi untuk orang lain.
Sekarang jika nasabah menjual perangkat lunak, mereka harus mengubah pemberitahuan hak cipta (yang ilegal, sehingga anda bisa menuntut dan akan menang -> kasus sederhana).
Jika mereka don't mengubah pemberitahuan hak cipta, tingkat 2 pelanggan akan melihat bahwa perangkat lunak yang berasal dari anda asli dan bertanya-tanya apa yang sedang terjadi. Kemungkinannya adalah bahwa mereka akan menghubungi anda dan anda akan belajar tentang menjual kembali pekerjaan anda.
Sekali lagi kami memiliki dua kasus: pelanggan asli hanya dijual beberapa salinan. Itu berarti mereka didn't membuat banyak uang, jadi mengapa repot-repot. Atau mereka dijual dalam volume. Yang berarti kesempatan yang lebih baik bagi anda untuk belajar tentang apa yang mereka lakukan dan melakukan sesuatu tentang hal itu.
Tapi pada akhirnya, kebanyakan perusahaan mencoba untuk mematuhi undang-undang (sekali reputasi mereka hancur, it's jauh lebih sulit untuk melakukan bisnis). Sehingga mereka tidak akan menipu anda untuk bekerja, tetapi bekerja dengan anda untuk meningkatkan itu. Jadi, jika anda menyertakan sumber (dengan lisensi yang melindungi anda dari yang sederhana reselling), kemungkinan adalah bahwa mereka hanya akan mendorong kembali perubahan yang mereka buat karena itu akan memastikan perubahan di versi berikutnya dan mereka don't harus mempertahankan itu. Yang's win-win: Anda mendapatkan perubahan dan mereka dapat membuat perubahan diri mereka sendiri jika mereka benar-benar, sangat perlu bahkan jika anda're tidak mau memasukkannya dalam rilis resmi.
Apakah anda telah melihat pyminifier? Itu tidak Mengecilkan, mengaburkan, dan kompres kode Python. Contoh kode yang terlihat cukup buruk untuk santai reverse engineering.
$ 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)
Tidak bergantung pada kebingungan. Seperti yang Anda telah benar menyimpulkan, ia menawarkan perlindungan yang terbatas. UPDATE: Berikut adalah link untuk kertas yang membalikkan direkayasa dikaburkan kode python di Dropbox. Pendekatan - opcode remapping adalah penghalang yang baik, tapi jelas itu bisa dikalahkan.
Sebaliknya, banyak poster yang telah disebutkan membuatnya:
Atau, sebagai kick-ass Python IDE WingIDE tidak: Memberikan kode. Yang's benar, memberi kode dan memiliki orang-orang datang kembali untuk upgrade dan dukungan.
Pengiriman .pyc file yang memiliki masalah - mereka tidak kompatibel dengan yang lain python versi dari python versi mereka diciptakan dengan, yang berarti anda harus tahu mana python versi ini berjalan pada sistem produk yang akan berjalan pada. Yang's sangat membatasi faktor.
Dalam beberapa keadaan, mungkin mungkin untuk bergerak (semua, atau setidaknya bagian penting) dari perangkat lunak ke layanan web yang anda organisasi tuan rumah.
Dengan cara itu, izin pemeriksaan dapat dilakukan dalam keselamatan anda sendiri ruang server.
Meskipun ada's tidak ada solusi yang sempurna, berikut yang bisa dilakukan:
Jika panggilan ke kode asli yang akan dihapus, program ini tidak't mulai pula. Jika itu's tidak dihapus maka lisensi akan diberlakukan.
Meskipun ini bukan sebuah cross-platform atau murni-Python solusi, itu akan bekerja.
Gunakan Acpi. Ini akan mengkompilasi modul anda untuk tinggi-performant C file, yang kemudian dapat disusun ke biner asli perpustakaan. Ini pada dasarnya adalah un-bisa dibalik, dibandingkan dengan .pyc bytecode!
I've menulis sebuah artikel rinci tentang cara untuk mengatur Acpi untuk Python project, check it out:
Saya pikir ada satu lagi metode untuk melindungi kode Python; bagian dari Kebingungan metode. Saya percaya ada permainan seperti Mount dan Blade atau sesuatu yang berubah dan recompiled mereka sendiri interpreter python (asli penerjemah yang saya percaya adalah open source) dan hanya berubah OP kode di OP tabel kode untuk menjadi berbeda maka standar python OP kode.
Jadi python sumber dimodifikasi tapi file ekstensi dari *.pyc file yang berbeda dan op kode don't pertandingan untuk umum python.exe interpreter. Jika anda memeriksa permainan file data semua data di Python sumber format.
Segala macam trik jahat yang dapat dilakukan untuk main-main dengan matang hacker dengan cara ini. Berhenti sekelompok hacker berpengalaman lebih mudah. It's hacker profesional bahwa anda tidak akan mungkin mengalahkan. Tapi kebanyakan perusahaan don't tetap pro hacker pada staf lama aku membayangkan (mungkin karena hal-hal yang di-hack). Tapi belum matang hacker di semua tempat (baca karena penasaran staff IT).
Anda bisa misalnya, di modifikasi interpreter, yang memungkinkan untuk memeriksa komentar tertentu atau doc string di sumber anda. Anda bisa OP khusus kode untuk baris kode. Misalnya:
OP 234 adalah untuk sumber garis "# hak Cipta saya menulis ini" atau menyusun garis itu ke op-kode yang setara dengan "jika False:" jika "# hak Cipta" hilang. Pada dasarnya menonaktifkan seluruh blok kode untuk apa yang tampaknya menjadi beberapa alasan yang jelas.
Salah satu penggunaan kasus di mana recompiling dimodifikasi penerjemah mungkin layak adalah di mana anda didn't menulis aplikasi, aplikasi ini adalah besar, tapi anda dibayar untuk melindunginya, seperti ketika anda're dedicated server admin untuk aplikasi keuangan.
Saya menemukan ini sedikit bertentangan dengan meninggalkan sumber atau opcode terbuka untuk bola mata, tapi gunakan SSL untuk lalu lintas jaringan. SSL tidak 100% aman. Tapi itu's digunakan untuk menghentikan SEBAGIAN besar mata dari membaca itu. Wee bit tindakan pencegahan yang masuk akal.
Juga, jika cukup banyak orang menganggap bahwa Python sumber dan opcode terlalu terlihat,'s mungkin seseorang akhirnya akan mengembangkan setidaknya sederhana alat perlindungan untuk itu. Sehingga banyak orang bertanya "bagaimana untuk melindungi Python app" hanya mempromosikan pembangunan yang.
Tergantung pada siapa klien, sederhana mekanisme perlindungan, dikombinasikan dengan masuk akal perjanjian lisensi akan jauh lebih efektif daripada kompleks perizinan/enkripsi/kebingungan sistem.
Solusi terbaik akan menjual kode sebagai layanan, mengatakan dengan hosting service, atau menawarkan dukungan - meskipun itu isn't selalu praktis.
Pengiriman kode seperti .pyc
file yang akan mencegah anda perlindungan yang digagalkan oleh beberapa #
s, tapi itu's hampir tidak efektif anti-pembajakan perlindungan (seperti jika ada seperti teknologi), dan pada akhir hari, itu seharusnya't mencapai apa-apa yang layak perjanjian lisensi dengan perusahaan akan.
Berkonsentrasi pada membuat kode anda bagus untuk digunakan sebagai mungkin memiliki pelanggan yang bahagia akan membuat perusahaan anda jauh lebih banyak uang daripada yang mencegah beberapa teori pembajakan..
Upaya lain untuk membuat kode anda lebih sulit untuk mencuri adalah dengan menggunakan kelompok dari setiap dua elemen dan kemudian gunakan jawa obfuscator.
Ini harus bekerja dengan cukup baik sebagai jythonc menerjemahkan kode python ke jawa dan kemudian java dikompilasi ke bytecode. Jadi ons anda obfuscate kelas itu akan menjadi benar-benar sulit untuk memahami apa yang terjadi setelah dekompilasi, belum lagi pulih kode aktual.
Satu-satunya masalah dengan kelompok dari setiap dua elemen adalah bahwa anda dapat't menggunakan python modul yang ditulis dalam c.
Saya terkejut tidak melihat pyconcrete dalam setiap jawaban. Mungkin karena itu's baru dari pertanyaannya?
Ini bisa menjadi apa yang anda butuhkan(ed).
Bukan obfuscating kode, mengenkripsi dan mendekripsi di waktu buka.
Dari pypi halaman:
Melindungi python script alur kerja
- your_script.py
impor pyconcrete
- pyconcrete akan menghubungkan modul impor
- ketika naskah anda lakukan impor
MODUL
, pyconcrete impor hook akan mencoba untuk menemukanMODUL.pye
pertama dan kemudian mendekripsiMODUL.pye
melalui_pyconcrete.pyd
dan melakukan dekripsi data (sebagai .pyc isi)- mengenkripsi & mendekripsi kunci rahasia catatan di
_pyconcrete.pyd
(seperti DLL atau JADI) kunci rahasia yang akan disembunyikan dalam kode biner, tidak bisa lihat langsung di HEX melihat
Yang terbaik yang dapat anda lakukan dengan Python adalah untuk hal yang tidak jelas.
Anda mungkin bisa menambahkan beberapa tambahan ketidakjelasan oleh enkripsi dan dekripsi pada terbang dan melewati itu untuk eval(). Tapi tidak peduli apa yang anda lakukan seseorang dapat mematahkan itu.
Tak satu pun dari ini akan berhenti ditentukan penyerang dari pembongkaran bytecode atau menggali melalui api dengan bantuan, dir, dll.
Anda harus mengambil melihat bagaimana orang-orang di getdropbox.com melakukannya untuk perangkat lunak klien mereka, termasuk Linux. It's cukup sulit untuk retak dan memerlukan beberapa cukup kreatif pembongkaran untuk melewati mekanisme perlindungan.
Bagaimana dengan penandatanganan kode anda dengan enkripsi standar skema dengan hashing dan menandatangani berkas-berkas penting dan memeriksa dengan kunci publik metode?
Dengan cara ini anda dapat mengeluarkan lisensi file dengan kunci publik untuk masing-masing pelanggan.
Tambahan anda dapat menggunakan python obfuscator seperti ini (hanya googled).