Tôi đang phát triển một phần mềm bằng Python sẽ được phân phối cho khách hàng của chủ nhân. Chủ lao động của tôi muốn giới hạn việc sử dụng phần mềm với tệp giấy phép bị giới hạn thời gian.

Nếu chúng tôi phân phối các tệp .py hoặc thậm chí các tệp .pyc, sẽ dễ dàng (dịch ngược và) xóa mã kiểm tra tệp giấy phép.

Một khía cạnh khác là chủ nhân của tôi không muốn khách hàng của chúng tôi đọc mã, sợ rằng mã có thể bị đánh cắp hoặc ít nhất là "ý tưởng mới lạ".

Có một cách tốt để xử lý vấn đề này? Tốt nhất là với một giải pháp sẵn có.

Phần mềm sẽ chạy trên các hệ thống Linux (vì vậy tôi không nghĩ py2exe sẽ thực hiện thủ thuật này).

Python, là một ngôn ngữ diễn giải được biên dịch mã byte, rất khó để khóa. Ngay cả khi bạn sử dụng một exe-packager như py2exe , bố cục của tệp thực thi là nổi tiếng và mã byte Python được hiểu rõ.

Thông thường trong những trường hợp như thế này, bạn phải đánh đổi. Nó thực sự quan trọng như thế nào để bảo vệ mã? Có những bí mật thực sự trong đó (chẳng hạn như chìa khóa để mã hóa đối xứng chuyển khoản ngân hàng), hay bạn chỉ đang bị hoang tưởng? Chọn ngôn ngữ cho phép bạn phát triển sản phẩm tốt nhất nhanh nhất và thực tế về ý tưởng mới lạ của bạn có giá trị như thế nào.

Nếu bạn quyết định rằng bạn thực sự cần phải thực thi kiểm tra giấy phép một cách an toàn, hãy viết nó dưới dạng một phần mở rộng C nhỏ để mã kiểm tra giấy phép có thể cực kỳ khó khăn (nhưng không phải là không thể!) Để đảo ngược kỹ sư và để lại phần lớn mã của bạn trong Python .

"Có cách nào tốt để xử lý vấn đề này không?" Không có gì có thể được bảo vệ chống lại kỹ thuật đảo ngược. Ngay cả phần sụn trên máy DVD cũng đã được thiết kế ngược và khóa Mã hóa AACS bị lộ. Và đó là bất chấp DMCA làm cho đó là một tội hình sự.

Vì không có phương pháp kỹ thuật nào có thể ngăn khách hàng của bạn đọc mã của bạn, bạn phải áp dụng các phương pháp thương mại thông thường.

1. Giấy phép. Hợp đồng. Các điều khoản và điều kiện. Điều này vẫn hoạt động ngay cả khi mọi người có thể đọc mã. Lưu ý rằng một số thành phần dựa trên Python của bạn có thể yêu cầu bạn trả phí trước khi bán phần mềm bằng các thành phần đó. Ngoài ra, một số giấy phép nguồn mở cấm bạn che giấu nguồn gốc hoặc nguồn gốc của thành phần đó.

2. Cung cấp giá trị đáng kể. Nếu công cụ của bạn tốt như vậy - với mức giá khó từ chối - sẽ không có động cơ để lãng phí thời gian và tiền bạc kỹ thuật đảo ngược bất cứ điều gì. Kỹ thuật đảo ngược là đắt tiền. Làm cho sản phẩm của bạn ít tốn kém hơn.

3. Cung cấp nâng cấp và cải tiến làm cho bất kỳ kỹ thuật đảo ngược là một ý tưởng tồi. Khi phiên bản tiếp theo phá vỡ kỹ thuật đảo ngược của họ, không có điểm nào. Điều này có thể được thực hiện đến mức cực đoan, nhưng bạn nên cung cấp các tính năng mới làm cho bản phát hành tiếp theo có giá trị hơn kỹ thuật đảo ngược.

4. Cung cấp tùy chỉnh ở mức giá hấp dẫn đến mức họ muốn trả cho bạn xây dựng và hỗ trợ các cải tiến.

5. Sử dụng khóa giấy phép hết hạn. Điều này là tàn nhẫn, và sẽ mang lại cho bạn một danh tiếng xấu, nhưng nó chắc chắn làm cho phần mềm của bạn ngừng hoạt động.

6. Cung cấp nó như một dịch vụ web. SaaS liên quan đến việc không tải xuống cho khách hàng.

Python không phải là công cụ bạn cần

Bạn phải sử dụng đúng công cụ để thực hiện đúng và Python không được thiết kế để bị xáo trộn. Đó là điều ngược lại; mọi thứ đều mở hoặc dễ dàng tiết lộ hoặc sửa đổi trong Python vì đó là triết lý của ngôn ngữ.

Nếu bạn muốn một cái gì đó bạn không thể nhìn xuyên qua, hãy tìm một công cụ khác. Đây không phải là một điều xấu, điều quan trọng là một số công cụ khác nhau tồn tại cho các mục đích sử dụng khác nhau.

Obfuscation thực sự khó

Ngay cả các chương trình được biên dịch cũng có thể được thiết kế ngược, vì vậy đừng nghĩ rằng bạn có thể bảo vệ hoàn toàn bất kỳ mã nào. Bạn có thể phân tích PHP bị xáo trộn, phá khóa mã hóa flash, v.v ... Các phiên bản Windows mới hơn bị bẻ khóa mỗi lần.

Có một yêu cầu pháp lý là một cách tốt để đi

Bạn không thể ngăn ai đó lạm dụng mã của mình, nhưng bạn có thể dễ dàng khám phá nếu có ai đó làm như vậy. Vì vậy, nó chỉ là một vấn đề pháp lý thông thường.

Mã bảo vệ được đánh giá cao

Ngày nay, các mô hình kinh doanh có xu hướng đi bán dịch vụ thay vì sản phẩm. Bạn không thể sao chép một dịch vụ, cướp biển cũng không ăn cắp nó. Có lẽ đã đến lúc cân nhắc để đi theo dòng chảy ...

Biên dịch python và phân phối nhị phân!

Ý tưởng hợp lý:

Sử dụng Cython , Nuitka , Shed Skin hoặc một cái gì đó tương tự để biên dịch python thành mã C, sau đó phân phối ứng dụng của bạn dưới dạng thư viện nhị phân python (pyd).

Theo cách đó, tôi không còn mã Python (byte) nào và bạn đã thực hiện bất kỳ số lượng che khuất hợp lý mà bất kỳ ai (tức là chủ nhân của bạn) có thể mong đợi từ Mã thông thường, tôi nghĩ vậy. (.NET hoặc Java kém an toàn hơn trường hợp này, vì mã byte đó không bị xáo trộn và có thể dễ dàng dịch ngược thành nguồn hợp lý.)

Cython ngày càng tương thích với CPython, vì vậy tôi nghĩ rằng nó nên hoạt động. (Tôi thực sự đang xem xét điều này cho sản phẩm của chúng tôi

Xem Bài đăng trên Blog này (không phải bởi tôi) để biết hướng dẫn về cách thực hiện. (thx @hithwen)

Ý tưởng điên rồ:

Bạn có thể có thể khiến Cython lưu trữ các tệp C riêng biệt cho từng mô-đun, sau đó chỉ cần ghép tất cả chúng và xây dựng chúng với nội tuyến nặng. Bằng cách đó, mô-đun Python của bạn khá nguyên khối và khó xử lý bằng các công cụ phổ biến.

Ngoài điên

Bạn có thể xây dựng một tệp thực thi duy nhất nếu bạn có thể liên kết đến (và tối ưu hóa với) thời gian chạy python và tất cả các thư viện (dlls) tĩnh. Theo cách đó, chắc chắn rất khó để chặn các cuộc gọi đến / từ python và bất kỳ thư viện khung nào bạn sử dụng. Điều này không thể được thực hiện nếu bạn đang sử dụng mã LGPL.

Tôi hiểu rằng bạn muốn khách hàng của mình sử dụng sức mạnh của python nhưng không muốn tiết lộ mã nguồn.

Dưới đây là những gợi ý của tôi:

(a) Viết các đoạn quan trọng của mã dưới dạng thư viện C hoặc C ++ và sau đó sử dụng SIP hoặc swig để hiển thị API C / C ++ cho không gian tên Python.

(b) Sử dụng cython thay vì Python

(c) Trong cả (a) và (b), có thể phân phối các thư viện dưới dạng nhị phân được cấp phép với giao diện Python.

Chủ nhân của bạn có biết rằng anh ta có thể "đánh cắp" lại bất kỳ ý tưởng nào mà người khác nhận được từ mã của bạn không? Ý tôi là, nếu họ có thể đọc tác phẩm của bạn, thì bạn cũng có thể là của họ. Có lẽ nhìn vào cách bạn có thể hưởng lợi từ tình huống sẽ mang lại lợi tức đầu tư tốt hơn so với việc sợ bạn có thể mất bao nhiêu.

[EDIT] Trả lời bình luận của Nick:

Không có gì đạt được và không mất gì. Khách hàng có những gì anh ta muốn (và trả tiền cho nó kể từ khi anh ta tự thay đổi). Vì anh ta không phát hành thay đổi, nên dường như điều đó không xảy ra với những người khác.

Bây giờ nếu khách hàng bán phần mềm, họ phải thay đổi thông báo bản quyền (đó là bất hợp pháp, vì vậy bạn có thể kiện và sẽ thắng -> trường hợp đơn giản).

Nếu họ không thay đổi thông báo bản quyền, khách hàng cấp 2 sẽ nhận thấy phần mềm đến từ bản gốc của bạn và tự hỏi chuyện gì đang xảy ra. Rất có thể họ sẽ liên lạc với bạn và vì vậy bạn sẽ tìm hiểu về việc bán lại công việc của bạn.

Một lần nữa chúng tôi có hai trường hợp: Khách hàng ban đầu chỉ bán một vài bản. Điều đó có nghĩa là dù sao họ cũng không kiếm được nhiều tiền, vậy tại sao phải bận tâm. Hoặc họ bán với số lượng lớn. Điều đó có nghĩa là cơ hội tốt hơn để bạn tìm hiểu về những gì họ làm và làm một cái gì đó về nó.

Nhưng cuối cùng, hầu hết các công ty đều cố gắng tuân thủ luật pháp (một khi danh tiếng của họ bị hủy hoại, việc kinh doanh sẽ khó khăn hơn nhiều). Vì vậy, họ sẽ không ăn cắp công việc của bạn mà làm việc với bạn để cải thiện nó. Vì vậy, nếu bạn bao gồm nguồn (có giấy phép bảo vệ bạn khỏi việc bán lại đơn giản), rất có thể họ sẽ đơn giản đẩy lùi các thay đổi họ đã thực hiện vì điều đó sẽ đảm bảo thay đổi trong phiên bản tiếp theo và họ không phải duy trì nó . Đó là đôi bên cùng có lợi: Bạn nhận được các thay đổi và họ có thể tự thực hiện thay đổi nếu họ thực sự, rất cần nó ngay cả khi bạn không muốn đưa nó vào bản phát hành chính thức.

Bạn đã có một cái nhìn tại pyminifier ? Nó làm giảm thiểu, làm mờ và nén mã Python. Mã ví dụ trông khá khó chịu đối với kỹ thuật đảo ngược thông thường.

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

Đừng dựa vào obfuscation. Như bạn đã kết luận chính xác, nó cung cấp bảo vệ rất hạn chế. CẬP NHẬT: Đây là một liên kết đến giấy mà đảo ngược mã python bị xáo trộn trong Dropbox. Cách tiếp cận - ánh xạ lại mã opcode là một rào cản tốt, nhưng rõ ràng nó có thể bị đánh bại.

Thay vào đó, như nhiều áp phích đã đề cập làm cho nó:

• Không có giá trị thời gian kỹ thuật đảo ngược (Phần mềm của bạn rất tốt, có ý nghĩa để trả tiền)
• Làm cho họ ký hợp đồng và kiểm toán giấy phép nếu khả thi.

Ngoài ra, như Python IDE WingIDE thực hiện: Cho đi mã . Điều đó đúng, đưa mã đi và yêu cầu mọi người quay lại để nâng cấp và hỗ trợ.

Sử dụng Cython . Nó sẽ biên dịch các mô-đun của bạn thành các tệp C hiệu suất cao, sau đó có thể được biên dịch sang các thư viện nhị phân riêng. Điều này về cơ bản là không thể đảo ngược, so với mã byte .pyc!

Tôi đã viết một bài viết chi tiết về cách thiết lập Cython cho một dự án Python, hãy kiểm tra nó:

Bảo vệ nguồn Python với Cython

Các tệp .pyc vận chuyển có vấn đề của nó - chúng không tương thích với bất kỳ phiên bản python nào khác so với phiên bản python mà chúng được tạo cùng, điều đó có nghĩa là bạn phải biết phiên bản python nào đang chạy trên hệ thống mà sản phẩm sẽ chạy. Đó là một yếu tố rất hạn chế.

Trong một số trường hợp, có thể di chuyển (tất cả hoặc ít nhất là một phần quan trọng) của phần mềm vào một dịch vụ web mà tổ chức của bạn lưu trữ.

Bằng cách đó, kiểm tra giấy phép có thể được thực hiện trong sự an toàn của phòng máy chủ của riêng bạn.

Mặc dù không có giải pháp hoàn hảo, những điều sau đây có thể được thực hiện:

1. Di chuyển một số phần quan trọng của mã khởi động vào một thư viện riêng.
2. Thực thi kiểm tra giấy phép trong thư viện bản địa.

Nếu cuộc gọi đến mã gốc bị xóa, chương trình sẽ không bắt đầu. Nếu nó không bị xóa thì giấy phép sẽ được thực thi.

Mặc dù đây không phải là một nền tảng chéo hoặc giải pháp Python thuần túy, nhưng nó sẽ hoạt động.

Tôi nghĩ có một phương pháp nữa để bảo vệ mã Python của bạn; một phần của phương pháp Obfuscation. Tôi tin rằng có một trò chơi như Mount and Blade hoặc thứ gì đó đã thay đổi và biên dịch lại trình thông dịch python của riêng họ (trình thông dịch gốc mà tôi tin là mã nguồn mở) và chỉ thay đổi mã OP trong bảng mã OP để khác với OPthon tiêu chuẩn mã số.

Vì vậy, nguồn python không được sửa đổi nhưng phần mở rộng tệp của các tệp * .pyc khác nhau và mã op không khớp với trình thông dịch python.exe công khai. Nếu bạn đã kiểm tra các tệp dữ liệu trò chơi, tất cả dữ liệu ở định dạng nguồn Python.

Tất cả các loại thủ đoạn khó chịu có thể được thực hiện để gây rối với các tin tặc chưa trưởng thành theo cách này. Ngăn chặn một loạt các tin tặc thiếu kinh nghiệm là dễ dàng. Đó là những tin tặc chuyên nghiệp mà bạn sẽ không thể đánh bại. Nhưng hầu hết các công ty không giữ các hacker chuyên nghiệp trong đội ngũ nhân viên lâu như tôi tưởng tượng (có thể là do mọi thứ bị hack). Nhưng tin tặc chưa trưởng thành ở khắp mọi nơi (đọc là nhân viên CNTT tò mò).

Ví dụ, bạn có thể, trong một trình thông dịch đã sửa đổi, cho phép nó kiểm tra các nhận xét hoặc chuỗi tài liệu nhất định trong nguồn của bạn. Bạn có thể có mã OP đặc biệt cho các dòng mã như vậy. Ví dụ:

OP 234 dành cho dòng nguồn "# Bản quyền tôi đã viết này" hoặc biên dịch dòng đó thành mã op tương đương với "nếu Sai:" nếu thiếu "# Bản quyền". Về cơ bản vô hiệu hóa toàn bộ một khối mã cho những gì dường như là một lý do mơ hồ.

Một trường hợp sử dụng khi biên dịch lại trình thông dịch đã sửa đổi có thể khả thi là khi bạn không viết ứng dụng, ứng dụng này rất lớn, nhưng bạn được trả tiền để bảo vệ nó, chẳng hạn như khi bạn là quản trị viên máy chủ chuyên dụng cho ứng dụng tài chính.

Tôi thấy có một chút mâu thuẫn khi để nguồn hoặc opcodes mở cho nhãn cầu, nhưng sử dụng SSL cho lưu lượng mạng. SSL cũng không an toàn 100%. Nhưng nó được sử dụng để ngăn đôi mắt MOST đọc nó. Một chút đề phòng nhỏ là hợp lý.

Ngoài ra, nếu đủ người cho rằng nguồn Python và opcodes quá rõ ràng, có khả năng ai đó cuối cùng sẽ phát triển ít nhất một công cụ bảo vệ đơn giản cho nó. Vì vậy, càng có nhiều người hỏi "cách bảo vệ ứng dụng Python" chỉ thúc đẩy sự phát triển đó.

Cách duy nhất đáng tin cậy để bảo vệ mã là chạy mã trên máy chủ mà bạn kiểm soát và cung cấp cho khách hàng của mình một máy khách có giao diện với máy chủ đó.

Tôi đã ngạc nhiên khi không thấy pyconcret trong bất kỳ câu trả lời. Có lẽ bởi vì nó mới hơn câu hỏi?

Nó có thể chính xác là những gì bạn cần (ed).

Thay vì làm xáo trộn mã, nó mã hóa nó và giải mã khi tải.

Từ trang pypi :

Bảo vệ luồng công việc kịch bản python

• your_script.py import pyconcrete
• pyconcittle sẽ móc mô-đun nhập khẩu
• khi tập lệnh của bạn thực hiện nhập MODULE, hook nhập pyconcret sẽ cố gắng tìm MODULE.pyetrước rồi giải mã MODULE.pyequa _pyconcrete.pydvà thực hiện dữ liệu được giải mã (dưới dạng nội dung .pyc)
• mã hóa và giải mã bản ghi khóa bí mật trong _pyconcrete.pyd (như DLL hoặc SO), khóa bí mật sẽ được ẩn trong mã nhị phân, không thể nhìn thấy nó trực tiếp trong chế độ xem HEX

Tùy thuộc vào ai là khách hàng là một cơ chế bảo vệ đơn giản, kết hợp với một thỏa thuận cấp phép hợp lý sẽ xa hiệu quả hơn bất kỳ cấp phép phức tạp / mã hóa / obfuscation hệ thống.

Giải pháp tốt nhất sẽ là bán mã dưới dạng dịch vụ, bằng cách lưu trữ dịch vụ hoặc cung cấp hỗ trợ - mặc dù điều đó không phải lúc nào cũng thực tế.

Vận chuyển mã dưới dạng .pyctệp sẽ ngăn chặn sự bảo vệ của bạn trong vài #giây, nhưng việc bảo vệ chống vi phạm bản quyền hầu như không hiệu quả (như thể có một công nghệ như vậy), và vào cuối ngày, nó không đạt được bất cứ điều gì thỏa thuận cấp phép tốt với công ty sẽ.

Tập trung vào việc làm cho mã của bạn trở nên tốt đẹp để sử dụng càng tốt - có được những khách hàng hài lòng sẽ giúp công ty của bạn kiếm được nhiều tiền hơn là ngăn chặn một số vi phạm bản quyền lý thuyết ..

Một nỗ lực khác để làm cho mã của bạn khó bị đánh cắp hơn là sử dụng jython và sau đó sử dụng java obfuscator .

Điều này sẽ hoạt động khá tốt khi jythonc dịch mã python sang java và sau đó java được biên dịch sang mã byte. Vì vậy, bạn làm xáo trộn các lớp sẽ thực sự khó hiểu những gì đang diễn ra sau khi dịch ngược, chưa kể đến việc khôi phục mã thực tế.

Vấn đề duy nhất với jython là bạn không thể sử dụng các mô-đun python được viết bằng c.

Còn việc ký mã của bạn với các sơ đồ mã hóa tiêu chuẩn bằng cách băm và ký các tệp quan trọng và kiểm tra nó bằng các phương thức khóa chung thì sao?

Bằng cách này, bạn có thể cấp tệp giấy phép với khóa chung cho mỗi khách hàng.

Ngoài ra, bạn có thể sử dụng một obfuscator python như thế này (chỉ cần googled nó).

Bạn nên xem cách các chàng trai tại getdropbox.com làm điều đó cho phần mềm máy khách của họ, bao gồm cả Linux. Nó khá khó để bẻ khóa và đòi hỏi một số cách tháo gỡ khá sáng tạo để vượt qua các cơ chế bảo vệ.

Điều tốt nhất bạn có thể làm với Python là làm mờ mọi thứ.

• Loại bỏ tất cả các tài liệu
• Chỉ phân phối các tệp được biên dịch .pyc.
• Đóng băng nó
• Che khuất các hằng số của bạn bên trong một lớp / mô-đun để giúp (config) không hiển thị mọi thứ

Bạn có thể thêm một số che khuất bổ sung bằng cách mã hóa một phần của nó và giải mã nó một cách nhanh chóng và chuyển nó đến eval (). Nhưng không có vấn đề gì bạn làm ai đó có thể phá vỡ nó.

Không ai trong số này sẽ ngăn kẻ tấn công xác định tháo rời mã byte hoặc đào qua api của bạn với sự trợ giúp, thư mục, v.v.

Ý tưởng có giấy phép hạn chế thời gian và kiểm tra nó trong chương trình được cài đặt cục bộ sẽ không hoạt động. Ngay cả với obfuscation hoàn hảo, kiểm tra giấy phép có thể được gỡ bỏ. Tuy nhiên, nếu bạn kiểm tra giấy phép trên hệ thống từ xa và chạy một phần quan trọng của chương trình trên hệ thống từ xa đã đóng, bạn sẽ có thể bảo vệ IP của mình.

Ngăn chặn các đối thủ cạnh tranh sử dụng mã nguồn là của riêng họ hoặc viết phiên bản lấy cảm hứng của cùng một mã, một cách để bảo vệ là thêm chữ ký vào logic chương trình của bạn (một số bí mật để có thể chứng minh rằng mã đã bị đánh cắp từ bạn) và làm xáo trộn Mã nguồn python vì vậy, thật khó để đọc và sử dụng.

Obfuscation tốt về cơ bản bổ sung sự bảo vệ tương tự cho mã của bạn, việc biên dịch nó thành mã thực thi (và tước nhị phân). Tìm hiểu làm thế nào mã phức tạp bị xáo trộn hoạt động thậm chí có thể khó hơn so với việc thực hiện viết triển khai của riêng bạn.

Điều này sẽ không giúp ngăn chặn hack chương trình của bạn. Ngay cả với công cụ cấp phép mã obfuscation sẽ bị bẻ khóa và chương trình có thể được sửa đổi để có hành vi hơi khác nhau (giống như cách biên dịch mã thành nhị phân không giúp bảo vệ các chương trình gốc).

Ngoài việc che giấu biểu tượng có thể là một ý tưởng tốt để giải mã mã, điều này làm cho mọi thứ trở nên khó hiểu hơn, ví dụ như biểu đồ cuộc gọi chỉ đến nhiều nơi khác nhau ngay cả khi những nơi khác nhau thực sự giống nhau.

Chữ ký logic bên trong mã bị xáo trộn (ví dụ: bạn có thể tạo bảng giá trị được sử dụng bởi logic chương trình, nhưng cũng được sử dụng làm chữ ký), có thể được sử dụng để xác định mã đó có nguồn gốc từ bạn. Nếu ai đó quyết định sử dụng mô-đun mã bị xáo trộn của bạn như một phần của sản phẩm của họ (ngay cả sau khi kích hoạt lại để làm cho nó có vẻ khác biệt), bạn có thể hiển thị, mã đó bị đánh cắp với chữ ký bí mật của bạn.

Tôi đã xem xét bảo vệ phần mềm nói chung cho các dự án của riêng tôi và triết lý chung là bảo vệ hoàn toàn là không thể. Điều duy nhất mà bạn có thể hy vọng đạt được là thêm sự bảo vệ đến một mức độ khiến khách hàng của bạn phải trả nhiều tiền hơn để vượt qua việc mua một giấy phép khác.

Với điều đó nói rằng tôi chỉ kiểm tra google để xem lỗi python và không bật lên nhiều thứ. Trong một giải pháp .Net, obsfucation sẽ là cách tiếp cận đầu tiên cho vấn đề của bạn trên nền tảng windows, nhưng tôi không chắc có ai có giải pháp trên Linux hoạt động với Mono không.

Điều tiếp theo sẽ là viết mã của bạn bằng một ngôn ngữ được biên dịch, hoặc nếu bạn thực sự muốn đi hết con đường, thì trong trình biên dịch chương trình. Một chương trình thực thi bị loại bỏ sẽ khó dịch hơn rất nhiều so với ngôn ngữ được dịch.

Tất cả đi xuống để đánh đổi. Một đầu bạn có thể dễ dàng phát triển phần mềm trong python, trong đó cũng rất khó để che giấu bí mật. Mặt khác, bạn có phần mềm được viết bằng trình biên dịch mã khó viết hơn nhiều, nhưng dễ dàng che giấu bí mật hơn nhiều.

Sếp của bạn phải chọn một điểm ở đâu đó dọc theo sự liên tục đó hỗ trợ các yêu cầu của anh ta. Và sau đó anh ta phải cung cấp cho bạn các công cụ và thời gian để bạn có thể xây dựng những gì anh ta muốn. Tuy nhiên, đặt cược của tôi là anh ta sẽ phản đối chi phí phát triển thực tế so với tổn thất tiền tệ tiềm năng.

Mẩu chuyện dài:

1. Mã hóa mã nguồn của bạn
2. Viết trình tải mô-đun python của riêng bạn để giải mã mã của bạn khi nhập
3. Triển khai trình tải mô-đun trong C / C ++
4. Bạn có thể thêm nhiều tính năng hơn vào trình tải mô-đun, ví dụ như trình gỡ lỗi, kiểm soát giấy phép, ràng buộc dấu vân tay phần cứng, v.v.

Để biết thêm chi tiết, hãy xem câu trả lời này .

Nếu bạn quan tâm đến chủ đề này, dự án này sẽ giúp bạn - pyprotect .

Có thể có mã byte py2exe trong tài nguyên được mã hóa cho trình khởi chạy C tải và thực thi nó trong bộ nhớ. Một số ý tưởng ở đây và ở đây .

Một số người cũng đã nghĩ đến một chương trình tự sửa đổi để làm cho kỹ thuật đảo ngược trở nên đắt đỏ.

Bạn cũng có thể tìm thấy các hướng dẫn để ngăn chặn trình gỡ lỗi , làm cho trình phân tách không thành công, đặt các điểm dừng trình gỡ lỗi sai và bảo vệ mã của bạn bằng tổng kiểm tra. Tìm kiếm ["mã hóa" thực thi "trong bộ nhớ"] để biết thêm liên kết.

Nhưng như những người khác đã nói, nếu mã của bạn có giá trị, cuối cùng các kỹ sư sẽ thành công.

Nếu chúng tôi tập trung vào cấp phép phần mềm, tôi khuyên bạn nên xem một câu trả lời Stack Overflow khác mà tôi đã viết ở đây để có cảm hứng về cách hệ thống xác minh khóa giấy phép có thể được xây dựng.

Có một thư viện mã nguồn mở trên GitHub có thể giúp bạn với bit xác minh giấy phép.

Bạn có thể cài đặt nó bằng cách pip install licensingsau đó thêm mã sau đây:

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

Bạn có thể đọc thêm về cách khóa công khai RSA, v.v. được cấu hình ở đây .

Sử dụng cùng một cách để bảo vệ tệp nhị phân của c / c ++, nghĩa là làm xáo trộn từng thân hàm trong tệp nhị phân thực thi hoặc thư viện, chèn một lệnh "nhảy" vào đầu mỗi mục nhập hàm, nhảy đến hàm đặc biệt để khôi phục mã bị ẩn. Mã byte là mã nhị phân của tập lệnh Python, vì vậy

• Đầu tiên biên dịch tập lệnh python vào mã đối tượng
• Sau đó lặp lại từng đối tượng mã, mã hóa co_code của từng đối tượng mã như sau

    0 JUMP_ABSOLUTE n = 3 + len (mã byte)

    3
    ...
    ... Đây là mã byte bị xáo trộn
    ...

    n LOAD_GLOBAL? (__pyarmor__)
    n + 3 CUỘC GỌI 0
    n + 6 POP_TOP
    n + 7 JUMP_ABSOLUTE 0

• Lưu đối tượng mã bị xáo trộn dưới dạng tệp .pyc hoặc .pyo

Các tệp bị xáo trộn (.pyc hoặc .pyo) có thể được sử dụng bởi trình thông dịch python bình thường, khi các đối tượng mã đó được gọi lần đầu tiên

• Op đầu tiên là JUMP_ABSOLUTE, nó sẽ nhảy để bù n

• Tại offset n, hướng dẫn là gọi PyCFunction. Hàm này sẽ khôi phục các mã byte bị che khuất giữa offset 3 và n và đặt mã byte gốc ở offset 0. Mã bị xáo trộn có thể nhận được bằng mã sau

      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)
  

• Sau khi hàm này trả về, lệnh cuối cùng là chuyển sang offset 0. Mã byte thực sự bây giờ được thực thi.

Có một công cụ Pyarmor để làm xáo trộn các kịch bản python bằng cách này.

sử dụng cxfreeze (py2exe cho linux) sẽ thực hiện công việc.

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

nó có sẵn trong kho ubfox

Có một câu trả lời toàn diện về việc che giấu mã nguồn python, có thể tìm thấy ở đây .

Các kỹ thuật có thể được thảo luận là:
- sử dụng trình biên dịch bytecode ( python -m compileall)
- trình tạo thực thi (hoặc trình cài đặt như PyInstaller )
- phần mềm như một dịch vụ (giải pháp tốt nhất để che giấu mã của bạn theo ý kiến ​​của tôi)
- trình mã hóa mã nguồn python