Saya sedang mengembangkan perangkat lunak dengan Python yang akan didistribusikan kepada pelanggan majikan saya. Majikan saya ingin membatasi penggunaan perangkat lunak dengan file lisensi terbatas waktu.

Jika kita mendistribusikan file .py atau bahkan file .pyc akan mudah untuk (mendekompilasi dan) menghapus kode yang memeriksa file lisensi.

Aspek lain adalah bahwa majikan saya tidak ingin kode tersebut dibaca oleh pelanggan kami, takut bahwa kode tersebut dapat dicuri atau setidaknya "ide-ide baru".

Apakah ada cara yang baik untuk menangani masalah ini? Lebih disukai dengan solusi off-the-shelf.

Perangkat lunak ini akan berjalan pada sistem Linux (jadi saya tidak berpikir py2exe akan melakukan trik).

Python, sebagai bahasa yang ditafsirkan byte-kode-dikompilasi, sangat sulit untuk dikunci. Bahkan jika Anda menggunakan exe-packager seperti py2exe , tata letak executable terkenal, dan kode byte Python dipahami dengan baik.

Biasanya dalam kasus seperti ini, Anda harus melakukan tradeoff. Seberapa pentingkah melindungi kode? Apakah ada rahasia nyata di sana (seperti kunci untuk enkripsi simetris transfer bank), atau Anda hanya paranoid? Pilih bahasa yang memungkinkan Anda mengembangkan produk terbaik dengan tercepat, dan bersikap realistis tentang betapa berharganya ide-ide baru Anda.

Jika Anda memutuskan bahwa Anda benar-benar perlu menegakkan pemeriksaan lisensi dengan aman, tulislah sebagai ekstensi C kecil sehingga kode pemeriksaan lisensi dapat menjadi sangat sulit (tapi bukan tidak mungkin!) Untuk merekayasa balik, dan meninggalkan sebagian besar kode Anda dengan Python .

"Apakah ada cara yang baik untuk menangani masalah ini?" Tidak. Tidak ada yang bisa dilindungi terhadap rekayasa terbalik. Bahkan firmware pada mesin DVD telah direkayasa balik dan kunci Enkripsi AACS terbuka. Dan terlepas dari DMCA membuat itu menjadi tindak pidana.

Karena tidak ada metode teknis yang dapat menghentikan pelanggan Anda membaca kode Anda, Anda harus menerapkan metode komersial biasa.

1. Lisensi. Kontrak. Syarat dan ketentuan. Ini masih berfungsi bahkan ketika orang dapat membaca kode. Perhatikan bahwa beberapa komponen berbasis Python Anda mungkin mengharuskan Anda membayar biaya sebelum menjual perangkat lunak menggunakan komponen itu. Juga, beberapa lisensi sumber terbuka melarang Anda menyembunyikan sumber atau asal komponen itu.

2. Menawarkan nilai yang signifikan. Jika barang-barang Anda sangat bagus - dengan harga yang sulit ditolak - tidak ada insentif untuk membuang waktu dan uang membalikkan rekayasa apa pun. Rekayasa balik itu mahal. Jadikan produk Anda sedikit lebih murah.

3. Tawarkan peningkatan dan peningkatan yang membuat rekayasa terbalik merupakan ide yang buruk. Ketika rilis berikutnya merusak reverse engineering mereka, tidak ada gunanya. Hal ini dapat dilakukan secara ekstrem, tetapi Anda harus menawarkan fitur-fitur baru yang membuat rilis berikutnya lebih berharga daripada reverse engineering.

4. Tawarkan kustomisasi dengan harga yang sangat menarik sehingga mereka lebih suka membayar Anda untuk membangun dan mendukung peningkatan.

5. Gunakan kunci lisensi yang kedaluwarsa. Ini kejam, dan akan memberi Anda reputasi buruk, tetapi itu pasti membuat perangkat lunak Anda berhenti bekerja.

6. Tawarkan sebagai layanan web. SaaS tidak melibatkan unduhan untuk pelanggan.

Python bukan alat yang Anda butuhkan

Anda harus menggunakan alat yang tepat untuk melakukan hal yang benar, dan Python tidak dirancang untuk dikaburkan. Sebaliknya; semuanya terbuka atau mudah diungkapkan atau dimodifikasi dengan Python karena itulah filosofi bahasa tersebut.

Jika Anda menginginkan sesuatu yang tidak dapat Anda lihat, cari alat lain. Ini bukan hal yang buruk, penting bahwa ada beberapa alat yang berbeda untuk penggunaan yang berbeda.

Kebingungan sangat sulit

Bahkan program yang dikompilasi dapat direkayasa ulang, jadi jangan berpikir bahwa Anda dapat sepenuhnya melindungi kode apa pun. Anda dapat menganalisis PHP yang dikaburkan, memecah kunci enkripsi flash, dll. Versi Windows yang lebih baru di-crack setiap waktu.

Memiliki persyaratan hukum adalah cara yang baik untuk melakukannya

Anda tidak dapat mencegah seseorang menyalahgunakan kode Anda, tetapi Anda dapat dengan mudah menemukan jika seseorang melakukannya. Karena itu, itu hanya masalah hukum biasa.

Perlindungan kode terlalu dilebih-lebihkan

Saat ini, model bisnis cenderung pergi untuk menjual jasa daripada produk. Anda tidak dapat menyalin layanan, membajak, atau mencurinya. Mungkin sudah waktunya untuk mempertimbangkan untuk mengikuti arus ...

Kompilasi python dan distribusikan binari!

Ide yang masuk akal:

Gunakan Cython , Nuitka , Shed Skin atau yang serupa dengan kompilasi kode python ke C, kemudian bagikan aplikasi Anda sebagai pustaka biner python (pyd).

Dengan begitu, tidak ada kode Python (byte) yang tersisa dan Anda telah melakukan jumlah yang tidak jelas dari pengaburan siapa pun (yaitu majikan Anda) dapat harapkan dari Kode biasa, saya pikir. (.NET atau Java kurang aman dari kasus ini, karena bytecode tidak dikaburkan dan relatif dapat dengan mudah didekompilasi menjadi sumber yang masuk akal.)

Cython semakin kompatibel dengan CPython, jadi saya pikir ini akan berhasil. (Saya sebenarnya mempertimbangkan ini untuk produk kami .. Kami sudah membangun beberapa lib pihak ketiga sebagai pyd / dll, jadi kirim kode python kami sendiri karena binari bukan langkah yang terlalu besar bagi kami.)

Lihat Posting Blog Ini (bukan oleh saya) untuk tutorial tentang cara melakukannya. (thx @hithwen)

Ide gila:

Anda mungkin bisa meminta Cython untuk menyimpan file-C secara terpisah untuk setiap modul, kemudian menggabungkan semuanya dan membangunnya dengan inline yang berat. Dengan begitu, modul Python Anda cukup monolitik dan sulit dikompres dengan alat umum.

Di luar gila:

Anda mungkin dapat membangun satu yang dapat dieksekusi jika Anda dapat menautkan (dan mengoptimalkan dengan) runtime python dan semua pustaka (dll) secara statis. Dengan begitu, tentu akan sulit untuk mencegat panggilan ke / dari python dan kerangka kerja perpustakaan apa pun yang Anda gunakan. Ini tidak dapat dilakukan jika Anda menggunakan kode LGPL.

Saya mengerti bahwa Anda ingin pelanggan Anda menggunakan kekuatan python tetapi tidak ingin mengekspos kode sumber.

Berikut saran saya:

(a) Tuliskan bagian-bagian penting dari kode sebagai pustaka C atau C ++ dan kemudian gunakan SIP atau swig untuk mengekspos C / C ++ APIs ke Python namespace.

(B) Gunakan cython, bukan Python

(c) Dalam kedua (a) dan (b), harus dimungkinkan untuk mendistribusikan perpustakaan sebagai biner berlisensi dengan antarmuka Python.

Apakah atasan Anda tahu bahwa ia dapat "mencuri" kembali gagasan apa pun yang diperoleh orang lain dari kode Anda? Maksud saya, jika mereka bisa membaca karya Anda, Anda juga bisa. Mungkin dengan melihat bagaimana Anda dapat mengambil manfaat dari situasi tersebut akan menghasilkan pengembalian investasi Anda yang lebih baik daripada takut seberapa besar kerugian Anda.

[EDIT] Jawaban untuk komentar Nick:

Tidak ada yang didapat dan tidak ada yang hilang. Pelanggan memiliki apa yang dia inginkan (dan membayarnya sejak dia melakukan perubahan sendiri). Karena dia tidak merilis perubahan, seolah-olah itu tidak terjadi pada orang lain.

Sekarang jika pelanggan menjual perangkat lunak, mereka harus mengubah pemberitahuan hak cipta (yang ilegal, sehingga Anda dapat menuntut dan akan menang -> kasing sederhana).

Jika mereka tidak mengubah pemberitahuan hak cipta, pelanggan tingkat 2 akan melihat bahwa perangkat lunak tersebut berasal dari Anda yang asli dan bertanya-tanya apa yang sedang terjadi. Kemungkinannya adalah mereka akan menghubungi Anda dan Anda akan belajar tentang penjualan kembali pekerjaan Anda.

Sekali lagi kami memiliki dua kasing: Pelanggan asli hanya menjual beberapa salinan. Itu berarti mereka tidak menghasilkan banyak uang, jadi mengapa repot-repot. Atau mereka menjual dalam volume. Itu berarti peluang yang lebih baik bagi Anda untuk belajar tentang apa yang mereka lakukan dan melakukan sesuatu tentang itu.

Tetapi pada akhirnya, sebagian besar perusahaan berusaha untuk mematuhi hukum (begitu reputasi mereka hancur, jauh lebih sulit untuk melakukan bisnis). Jadi mereka tidak akan mencuri pekerjaan Anda tetapi bekerja dengan Anda untuk memperbaikinya. Jadi, jika Anda menyertakan sumber (dengan lisensi yang melindungi Anda dari penjualan kembali yang sederhana), kemungkinan besar mereka akan mendorong kembali perubahan yang mereka buat karena itu akan memastikan perubahan itu ada di versi berikutnya dan mereka tidak harus mempertahankannya . Itu sama-sama menguntungkan: Anda mendapatkan perubahan dan mereka dapat membuat perubahan itu sendiri jika mereka benar-benar membutuhkannya bahkan jika Anda tidak mau memasukkannya ke dalam rilis resmi.

Pernahkah Anda melihat pyminifier ? Itu Minify, mengaburkan, dan kompres kode Python. Contoh kode terlihat sangat buruk untuk teknik reverse kasual.

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

Jangan mengandalkan kebingungan. Seperti yang telah Anda simpulkan dengan benar, ia menawarkan perlindungan yang sangat terbatas. UPDATE: Ini adalah tautan ke kertas yang membalikkan kode python yang dikaburkan di Dropbox. Pendekatan - pemetaan ulang opcode adalah penghalang yang baik, tetapi jelas itu bisa dikalahkan.

Alih-alih, seperti yang telah disebutkan oleh banyak poster:

• Tidak bernilai waktu rekayasa terbalik (Perangkat lunak Anda sangat bagus, masuk akal untuk membayar)
• Buat mereka menandatangani kontrak dan lakukan audit lisensi jika memungkinkan.

Atau, seperti yang dilakukan oleh Python IDE WingIDE IDE: Berikan kode . Itu benar, berikan kodenya dan minta orang kembali untuk meningkatkan dan mendukung.

Gunakan Cython . Ini akan mengkompilasi modul Anda ke file C berkinerja tinggi, yang kemudian dapat dikompilasi ke perpustakaan biner asli. Ini pada dasarnya un-reversable, dibandingkan dengan bypecode .pyc!

Saya telah menulis artikel terperinci tentang cara mengatur Cython untuk proyek Python, periksa:

Melindungi Sumber Python Dengan Cython

Pengiriman file .pyc memiliki masalah - mereka tidak kompatibel dengan versi python lain selain versi python yang mereka buat, yang berarti Anda harus tahu versi python mana yang berjalan pada sistem di mana produk akan berjalan. Itu faktor yang sangat membatasi.

Dalam beberapa keadaan, dimungkinkan untuk memindahkan (semua, atau setidaknya bagian penting) dari perangkat lunak ke dalam layanan web yang dihosting oleh organisasi Anda.

Dengan begitu, pemeriksaan lisensi dapat dilakukan dalam keamanan ruang server Anda sendiri.

Meskipun tidak ada solusi sempurna, berikut ini dapat dilakukan:

1. Pindahkan beberapa bagian penting dari kode startup ke perpustakaan asli.
2. Menegakkan pemeriksaan lisensi di perpustakaan asli.

Jika panggilan ke kode asli dihapus, program tidak akan memulai. Jika tidak dihapus maka lisensi akan diberlakukan.

Meskipun ini bukan platform silang atau solusi Python murni, ini akan berhasil.

Saya pikir ada satu metode lagi untuk melindungi kode Python Anda; bagian dari metode Kebingungan. Saya percaya ada permainan seperti Mount dan Blade atau sesuatu yang mengubah dan mengkompilasi ulang interpreter python mereka sendiri (interpreter asli yang saya percaya adalah open source) dan baru saja mengubah kode OP dalam tabel kode OP menjadi berbeda maka python OP standar kode.

Jadi sumber python tidak dimodifikasi tetapi ekstensi file dari file * .pyc berbeda dan kode op tidak cocok dengan juru bahasa python.exe publik. Jika Anda memeriksa file data game, semua data dalam format sumber Python.

Segala macam trik jahat dapat dilakukan untuk mengacaukan peretas yang tidak dewasa dengan cara ini. Menghentikan banyak peretas yang tidak berpengalaman itu mudah. Ini adalah peretas profesional yang kemungkinan besar tidak akan Anda kalahkan. Tetapi sebagian besar perusahaan tidak menyimpan staf pro hacker sejak lama yang saya bayangkan (kemungkinan karena hal-hal yang diretas). Tetapi para hacker yang tidak dewasa ada di semua tempat (baca staf TI yang penasaran).

Misalnya Anda dapat, dalam penerjemah yang dimodifikasi, mengizinkannya memeriksa komentar atau string dokumen tertentu di sumber Anda. Anda dapat memiliki kode OP khusus untuk baris kode tersebut. Sebagai contoh:

OP 234 adalah untuk baris sumber "# Hak Cipta Saya menulis ini" atau mengkompilasi baris itu ke dalam kode op yang setara dengan "jika Salah:" jika "# Hak Cipta" tidak ada. Pada dasarnya menonaktifkan seluruh blok kode untuk alasan yang tampaknya tidak jelas.

Satu kasus penggunaan di mana kompilasi ulang juru bahasa yang dimodifikasi mungkin dilakukan adalah di mana Anda tidak menulis aplikasi, aplikasi itu besar, tetapi Anda dibayar untuk melindunginya, seperti ketika Anda adalah admin server khusus untuk aplikasi keuangan.

Saya merasa sedikit kontradiktif untuk membiarkan sumber atau opcodes terbuka untuk bola mata, tetapi menggunakan SSL untuk lalu lintas jaringan. SSL juga tidak 100% aman. Tapi ini digunakan untuk menghentikan PALING mata dari membacanya. Tindakan pencegahan wee bit masuk akal.

Juga, jika cukup banyak orang menganggap bahwa sumber dan opcodes Python terlalu terlihat, kemungkinan seseorang akhirnya akan mengembangkan setidaknya alat perlindungan sederhana untuk itu. Jadi semakin banyak orang bertanya "bagaimana melindungi aplikasi Python" hanya mempromosikan pengembangan itu.

Satu-satunya cara yang dapat diandalkan untuk melindungi kode adalah menjalankannya di server yang Anda kontrol dan memberikan klien Anda klien yang berinteraksi dengan server itu.

Saya terkejut karena tidak melihat beton dalam jawaban apa pun. Mungkin karena ini lebih baru daripada pertanyaannya?

Ini bisa menjadi apa yang Anda butuhkan (red).

Alih-alih mengaburkan kode, itu mengenkripsi dan mendekripsi pada waktu buka.

Dari halaman pypi :

Lindungi alur kerja skrip python

• your_script.py import pyconcrete
• pyconcrete akan mengaitkan modul impor
• ketika skrip Anda melakukan impor MODULE, kait impor pyconcrete akan mencoba untuk menemukan MODULE.pyepertama dan kemudian mendekripsi MODULE.pyemelalui _pyconcrete.pyddan mengeksekusi data yang didekripsi (sebagai konten .pyc)
• mengenkripsi & mendekripsi catatan kunci rahasia di _pyconcrete.pyd (seperti DLL atau SO) kunci rahasia akan disembunyikan dalam kode biner, tidak dapat melihatnya secara langsung dalam tampilan HEX

Tergantung pada siapa kliennya, mekanisme perlindungan sederhana, dikombinasikan dengan perjanjian lisensi yang masuk akal akan jauh lebih efektif daripada sistem perizinan / enkripsi / kebingungan yang kompleks.

Solusi terbaik adalah menjual kode sebagai layanan, katakan dengan hosting layanan, atau menawarkan dukungan - meskipun itu tidak selalu praktis.

Mengirim kode sebagai .pycfile akan mencegah perlindungan Anda digagalkan oleh beberapa #detik, tetapi itu hampir tidak efektif perlindungan anti-pembajakan (seolah-olah ada teknologi seperti itu), dan pada akhirnya, itu tidak akan mencapai apa pun yang perjanjian lisensi yang layak dengan perusahaan akan.

Berkonsentrasi pada membuat kode Anda sebaik mungkin untuk digunakan - memiliki pelanggan yang bahagia akan membuat perusahaan Anda jauh lebih banyak uang daripada mencegah beberapa pembajakan teoritis ..

Upaya lain untuk membuat kode Anda lebih sulit untuk dicuri adalah dengan menggunakan jython dan kemudian menggunakan java obfuscator .

Ini seharusnya berfungsi dengan baik ketika jythonc menerjemahkan kode python ke java dan kemudian java dikompilasi ke bytecode. Jadi ounce Anda mengaburkan kelas itu akan sangat sulit untuk memahami apa yang terjadi setelah dekompilasi, belum lagi memulihkan kode yang sebenarnya.

Satu-satunya masalah dengan jython adalah Anda tidak dapat menggunakan modul python yang ditulis dalam c.

Bagaimana dengan menandatangani kode Anda dengan skema enkripsi standar dengan membuat dan menandatangani file penting dan memeriksanya dengan metode kunci publik?

Dengan cara ini Anda dapat mengeluarkan file lisensi dengan kunci publik untuk setiap pelanggan.

Tambahan, Anda dapat menggunakan python obfuscator seperti ini (cukup googled).

Anda harus melihat bagaimana orang-orang di getdropbox.com melakukannya untuk perangkat lunak klien mereka, termasuk Linux. Cukup sulit untuk dipecahkan dan membutuhkan beberapa pembongkaran yang cukup kreatif untuk melewati mekanisme perlindungan.

Hal terbaik yang dapat Anda lakukan dengan Python adalah mengaburkan sesuatu.

• Hapus semua dokumen
• Distribusikan hanya file yang dikompilasi .pyc.
• bekukan itu
• Mengaburkan konstanta Anda di dalam kelas / modul sehingga bantuan (konfigurasi) tidak menunjukkan segalanya

Anda mungkin dapat menambahkan beberapa ketidakjelasan tambahan dengan mengenkripsi bagian dari itu dan mendekripsi dengan cepat dan meneruskannya ke eval (). Tetapi apa pun yang Anda lakukan, seseorang dapat melanggarnya.

Semua ini tidak akan menghentikan penyerang yang gigih untuk tidak membongkar bytecode atau menggali api Anda dengan bantuan, dir, dll.

Gagasan memiliki lisensi terbatas waktu dan memeriksanya dalam program yang dipasang secara lokal tidak akan berfungsi. Bahkan dengan kebingungan yang sempurna, pemeriksaan lisensi dapat dihapus. Namun jika Anda memeriksa lisensi pada sistem jarak jauh dan menjalankan sebagian besar program pada sistem jarak jauh Anda yang tertutup, Anda akan dapat melindungi IP Anda.

Mencegah pesaing dari menggunakan kode sumber sebagai milik mereka atau menulis versi terilhami dari kode yang sama, satu cara untuk melindungi adalah dengan menambahkan tanda tangan ke logika program Anda (beberapa rahasia untuk dapat membuktikan bahwa kode itu dicuri dari Anda) dan mengaburkan Jadi kode sumber python sulit dibaca dan digunakan.

Kebingungan yang baik pada dasarnya menambahkan perlindungan yang sama pada kode Anda, yang mengkompilasinya ke executable (dan menelanjangi biner). Mencari tahu bagaimana kode rumit bekerja mungkin lebih sulit daripada benar-benar menulis implementasi Anda sendiri.

Ini tidak akan membantu mencegah peretasan program Anda. Bahkan dengan kode lisensi hal-hal lisensi akan retak dan program dapat dimodifikasi untuk memiliki perilaku yang sedikit berbeda (dengan cara yang sama bahwa kompilasi kode ke biner tidak membantu perlindungan program asli).

Selain kebingungan simbol mungkin ide yang baik untuk membatalkan kode, yang membuat semuanya lebih membingungkan jika misalnya panggilan grafik menunjuk ke banyak tempat yang berbeda bahkan jika sebenarnya tempat-tempat yang berbeda itu pada akhirnya melakukan hal yang sama.

Tanda tangan logis di dalam kode yang dikaburkan (misalnya Anda dapat membuat tabel nilai yang digunakan oleh logika program, tetapi juga digunakan sebagai tanda tangan), yang dapat digunakan untuk menentukan bahwa kode tersebut berasal dari Anda. Jika seseorang memutuskan untuk menggunakan modul kode Anda yang kabur sebagai bagian dari produk mereka sendiri (bahkan setelah melakukan reobfusi untuk membuatnya tampak berbeda) Anda dapat menunjukkan, kode itu dicuri dengan tanda tangan rahasia Anda.

Saya telah melihat perlindungan perangkat lunak secara umum untuk proyek saya sendiri dan filosofi umum adalah bahwa perlindungan lengkap tidak mungkin. Satu-satunya hal yang dapat Anda capai adalah menambahkan perlindungan ke tingkat yang akan membuat pelanggan Anda lebih banyak memotong daripada membeli lisensi lain.

Dengan mengatakan bahwa saya hanya memeriksa google untuk python obsfucation dan tidak memunculkan banyak hal. Dalam solusi .Net, obsfucation akan menjadi pendekatan pertama untuk masalah Anda pada platform windows, tetapi saya tidak yakin apakah ada yang punya solusi di Linux yang bekerja dengan Mono.

Hal berikutnya adalah menulis kode Anda dalam bahasa yang dikompilasi, atau jika Anda benar-benar ingin melakukannya, maka dalam assembler. Eksekusi yang dilucuti akan jauh lebih sulit untuk didekompilasi daripada bahasa yang ditafsirkan.

Semuanya bermuara pada tradeoffs. Di satu sisi Anda memiliki kemudahan pengembangan perangkat lunak dalam python, di mana juga sangat sulit untuk menyembunyikan rahasia. Di sisi lain Anda memiliki perangkat lunak yang ditulis dalam assembler yang jauh lebih sulit untuk ditulis, tetapi lebih mudah untuk menyembunyikan rahasia.

Bos Anda harus memilih titik di suatu tempat di sepanjang kontinum yang mendukung persyaratannya. Dan kemudian dia harus memberi Anda alat dan waktu sehingga Anda dapat membangun apa yang diinginkannya. Namun taruhan saya adalah bahwa dia akan keberatan dengan biaya pengembangan nyata versus potensi kerugian moneter.

Singkat cerita:

1. Enkripsi kode sumber Anda
2. Tulis pemuat modul python Anda sendiri untuk mendekripsi kode Anda saat mengimpor
3. Terapkan pemuat modul dalam C / C ++
4. Anda dapat menambahkan lebih banyak fitur ke pemuat modul, misalnya anti-debugger, kontrol lisensi, pengikatan sidik jari perangkat keras, dll.

Untuk lebih detail, lihat jawaban ini .

Jika Anda tertarik dengan topik ini, proyek ini akan membantu Anda - melindungi .

Dimungkinkan untuk memiliki kode byte py2exe dalam sumber daya yang dienkripsi untuk peluncur C yang memuat dan menjalankannya dalam memori. Beberapa ide di sini dan di sini .

Beberapa juga memikirkan program modifikasi diri untuk membuat reverse engineering menjadi mahal.

Anda juga dapat menemukan tutorial untuk mencegah debugger , membuat disassembler gagal, mengatur breakpoint debugger palsu dan melindungi kode Anda dengan checksum. Cari ["kode crypted" jalankan "di memori"] untuk tautan lainnya.

Tetapi seperti yang telah dikatakan orang lain, jika kode Anda sepadan, insinyur balik akan berhasil pada akhirnya.

Jika kita fokus pada lisensi perangkat lunak, saya akan merekomendasikan untuk melihat jawaban Stack Overflow lain yang saya tulis di sini untuk mendapatkan inspirasi tentang bagaimana sistem verifikasi kunci lisensi dapat dibangun.

Ada perpustakaan open-source di GitHub yang dapat membantu Anda dengan bit verifikasi lisensi.

Anda dapat menginstalnya dengan pip install licensingdan kemudian menambahkan kode berikut:

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

Anda dapat membaca lebih lanjut tentang cara kunci publik RSA, dll dikonfigurasi di sini .

Gunakan cara yang sama untuk melindungi file biner dari c / c ++, yaitu, mengaburkan setiap fungsi di file biner yang dapat dieksekusi atau pustaka, masukkan instruksi "lompatan" di awal setiap entri fungsi, lompat ke fungsi khusus untuk mengembalikan kode yang dikaburkan. Byte-code adalah kode biner dari skrip Python, jadi

• Pertama kompilasi skrip python ke objek kode
• Kemudian ulangi setiap objek kode, hapus co_code dari masing-masing objek kode sebagai berikut

    0 JUMP_ABSOLUTE n = 3 + len (bytecode)

    3
    ...
    ... Ini bytecode dikaburkan
    ...

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

• Simpan objek kode yang dikaburkan sebagai file .pyc atau .pyo

File-file yang dikaburkan (.pyc atau .pyo) dapat digunakan oleh penerjemah python normal, ketika objek kode tersebut disebut pertama kali

• Operasi pertama adalah JUMP_ABSOLUTE, ia akan melompat ke offset n

• Pada offset n, instruksi adalah memanggil fungsi PyCF. Fungsi ini akan mengembalikan bytecode yang dikaburkan antara offset 3 dan n, dan meletakkan kode byte asli pada offset 0. Kode yang dikaburkan dapat diperoleh dengan kode berikut

      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)
  

• Setelah fungsi ini kembali, instruksi terakhir adalah melompat ke offset 0. Kode byte yang benar sekarang dijalankan.

Ada alat Pyarmor untuk mengaburkan skrip python dengan cara ini.

menggunakan cxfreeze (py2exe untuk linux) akan melakukan pekerjaan itu.

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

ini tersedia di repositori ubuntu

Ada jawaban komprehensif untuk menyembunyikan kode sumber python, yang dapat ditemukan di sini .

Kemungkinan teknik yang dibahas adalah:
- gunakan bytecode yang dikompilasi ( python -m compileall)
- pembuat yang dapat dieksekusi (atau installer seperti PyInstaller )
- perangkat lunak sebagai layanan (solusi terbaik untuk menyembunyikan kode Anda menurut saya)
- obfuscators kode sumber python