ฉันกำลังพัฒนาซอฟต์แวร์บางส่วนใน Python ที่จะแจกจ่ายให้กับลูกค้าของนายจ้างของฉัน นายจ้างของฉันต้องการ จำกัด การใช้ซอฟต์แวร์ด้วยไฟล์ลิขสิทธิ์แบบ จำกัด เวลา

หากเราแจกจ่ายไฟล์. py หรือไฟล์. pyc มันจะง่ายต่อการถอด (ถอดรหัสและ) ลบรหัสที่ตรวจสอบไฟล์ลิขสิทธิ์

อีกแง่มุมหนึ่งก็คือนายจ้างของฉันไม่ต้องการให้ลูกค้าอ่านรหัสของเราเพราะกลัวว่ารหัสอาจถูกขโมยหรืออย่างน้อยก็เป็น "แนวคิดใหม่ ๆ "

มีวิธีที่ดีในการจัดการปัญหานี้หรือไม่? ควรใช้โซลูชันที่ไม่ได้วางจำหน่าย

ซอฟต์แวร์จะทำงานบนระบบ Linux (ดังนั้นฉันไม่คิดว่า py2exe จะทำเคล็ดลับ)

Python เป็นภาษาตีความที่รวบรวมรหัสไบต์ยากที่จะล็อค แม้ว่าคุณจะใช้ exe-packager เช่นpy2exeเลย์เอาท์ของการปฏิบัติการนั้นเป็นที่รู้จักกันดีและ Python byte-code ก็เป็นที่เข้าใจกันดี

โดยปกติในกรณีเช่นนี้คุณต้องทำการแลกเปลี่ยน การปกป้องรหัสมีความสำคัญจริง ๆ หรือไม่ มีความลับที่แท้จริง (เช่นกุญแจสำหรับการเข้ารหัสสมมาตรของการโอนเงินผ่านธนาคาร) หรือคุณแค่หวาดระแวง? เลือกภาษาที่ช่วยให้คุณพัฒนาผลิตภัณฑ์ที่ดีที่สุดเร็วที่สุดและเป็นจริงเกี่ยวกับความคิดใหม่ที่มีค่าของคุณ

หากคุณตัดสินใจว่าคุณจำเป็นต้องบังคับใช้การตรวจสอบใบอนุญาตอย่างปลอดภัยให้เขียนเป็นส่วนขยาย C ขนาดเล็กเพื่อให้รหัสตรวจสอบสิทธิ์การใช้งานนั้นยากเป็นพิเศษ (แต่ไม่ใช่เป็นไปไม่ได้!) เพื่อทำวิศวกรรมย้อนกลับ .

"มีวิธีที่ดีในการจัดการปัญหานี้หรือไม่?" ไม่ไม่มีสิ่งใดที่สามารถป้องกันวิศวกรรมย้อนกลับได้ แม้แต่เฟิร์มแวร์ในเครื่อง DVD ก็ได้รับการออกแบบทางวิศวกรรมย้อนกลับและกุญแจ AACS Encryption ก็ถูกเปิดเผย และถึงกระนั้น DMCA ก็ยังเป็นความผิดทางอาญา

เนื่องจากวิธีการทางเทคนิคไม่สามารถหยุดลูกค้าของคุณจากการอ่านรหัสของคุณคุณต้องใช้วิธีการเชิงพาณิชย์ปกติ

1. ใบอนุญาต สัญญา ข้อกำหนดและเงื่อนไข ยังคงใช้งานได้แม้ว่าผู้คนสามารถอ่านรหัสได้ โปรดทราบว่าองค์ประกอบที่ใช้ Python บางส่วนของคุณอาจต้องให้คุณชำระค่าธรรมเนียมก่อนที่จะขายซอฟต์แวร์โดยใช้ส่วนประกอบเหล่านั้น นอกจากนี้สิทธิการใช้งานโอเพนซอร์สบางอย่างทำให้คุณไม่สามารถปกปิดแหล่งที่มาหรือต้นกำเนิดขององค์ประกอบนั้นได้

2. เสนอคุณค่าที่สำคัญ หากสิ่งของของคุณดีมากในราคาที่ปฏิเสธยากไม่มีแรงจูงใจที่จะเสียเวลาและเงินกลับไปทำสิ่งใด วิศวกรรมย้อนกลับมีราคาแพง ทำให้ผลิตภัณฑ์ของคุณแพงน้อยลงเล็กน้อย

3. เสนอการอัพเกรดและการปรับปรุงที่ทำให้วิศวกรรมย้อนกลับเป็นความคิดที่ไม่ดี เมื่อการเปิดตัวครั้งต่อไปแตกวิศวกรรมย้อนกลับของพวกเขาไม่มีจุด สิ่งนี้สามารถนำไปสู่สุดขั้วที่ไร้สาระ แต่คุณควรนำเสนอคุณลักษณะใหม่ที่ทำให้การเผยแพร่ครั้งต่อไปมีค่ามากกว่าการทำวิศวกรรมย้อนกลับ

4. เสนอการปรับแต่งตามอัตราที่น่าสนใจเพื่อให้พวกเขาต้องการจ่ายเงินให้คุณสร้างและสนับสนุนการปรับปรุง

5. ใช้รหัสใบอนุญาตที่หมดอายุ นี่เป็นสิ่งที่โหดร้ายและจะทำให้คุณเสียชื่อเสียง แต่แน่นอนว่าซอฟต์แวร์ของคุณจะหยุดทำงาน

6. เสนอเป็นบริการเว็บ SaaS ไม่เกี่ยวข้องกับการดาวน์โหลดให้กับลูกค้า

Python ไม่ใช่เครื่องมือที่คุณต้องการ

คุณต้องใช้เครื่องมือที่เหมาะสมในการทำสิ่งที่ถูกต้องและ Python ไม่ได้ถูกออกแบบมาให้สับสน มันตรงกันข้าม ทุกอย่างเปิดหรือง่ายต่อการเปิดเผยหรือดัดแปลงใน Python เพราะนั่นคือปรัชญาของภาษา

หากคุณต้องการบางสิ่งที่มองไม่เห็นให้มองหาเครื่องมืออื่น นี่ไม่ใช่สิ่งเลวร้ายมันเป็นสิ่งสำคัญที่มีเครื่องมือต่าง ๆ มากมายสำหรับการใช้งานที่แตกต่างกัน

ความสับสนเป็นเรื่องยากจริงๆ

แม้แต่โปรแกรมที่คอมไพล์แล้วก็ยังสามารถทำการย้อนกลับได้ดังนั้นอย่าคิดว่าคุณสามารถป้องกันโค้ดใด ๆ ได้อย่างสมบูรณ์ คุณสามารถวิเคราะห์ PHP ที่ทำให้ยุ่งเหยิง, ทำลายคีย์การเข้ารหัสแฟลชเป็นต้น Windows รุ่นใหม่จะแตกทุกครั้ง

การมีข้อกำหนดทางกฎหมายเป็นวิธีที่ดี

คุณไม่สามารถป้องกันใครบางคนจากการใช้รหัสของคุณในทางที่ผิด แต่คุณสามารถค้นพบได้อย่างง่ายดายหากมีคนทำ ดังนั้นจึงเป็นเพียงปัญหาทางกฎหมาย

การป้องกันรหัสเกินพิกัด

ทุกวันนี้โมเดลธุรกิจมักจะขายบริการแทนผลิตภัณฑ์ คุณไม่สามารถคัดลอกบริการละเมิดลิขสิทธิ์หรือขโมยได้ อาจถึงเวลาที่จะต้องพิจารณาการไหลของ ...

รวบรวมไพ ธ อนและแจกจ่ายไบนารี!

ความคิดที่สมเหตุสมผล:

ใช้Cython , Nuitka , Shed Skinหรือสิ่งที่คล้ายกับการรวบรวมไพ ธ อนไปยังรหัส C จากนั้นแจกจ่ายแอปของคุณเป็นไพ ธ อนไลบรารีไบนารี (pyd) แทน

ด้วยวิธีนี้ไม่มีรหัส Python (ไบต์) เหลืออยู่และคุณได้ทำสิ่งที่ไม่เหมาะสมสำหรับใครก็ตาม (เช่นนายจ้างของคุณ) ที่คาดหวังจากรหัสปกติฉันคิดว่า (. NET หรือ Java ปลอดภัยน้อยกว่ากรณีนี้เนื่องจาก bytecode นั้นไม่สับสนและสามารถถอดรหัสได้อย่างง่ายดายในแหล่งที่เหมาะสม)

Cython กำลังเข้ากันได้กับ CPython มากขึ้นเรื่อย ๆ ดังนั้นฉันคิดว่ามันควรจะใช้ได้ (จริง ๆ แล้วฉันกำลังพิจารณาเรื่องนี้สำหรับผลิตภัณฑ์ของเรา .. เรากำลังสร้าง libs บุคคลที่สามบางส่วนเป็น pyd / dll ดังนั้นการจัดส่งรหัสไพ ธ อนของเราเองเนื่องจากไบนารีไม่ใช่ขั้นตอนที่ยิ่งใหญ่สำหรับเรา)

ดูโพสต์บล็อกนี้ (ไม่ใช่ฉัน) สำหรับการสอนเกี่ยวกับวิธีการทำ (ขอบคุณ @ hithwen)

ความคิดที่บ้า:

คุณอาจจะได้ Cython เพื่อจัดเก็บไฟล์ C แยกต่างหากสำหรับแต่ละโมดูลจากนั้นเพียงแค่เชื่อมต่อพวกเขาทั้งหมดและสร้างพวกเขาด้วยการอินไลน์อย่างหนัก ด้วยวิธีนี้โมดูล Python ของคุณนั้นใหญ่มากและยากที่จะชิปด้วยเครื่องมือทั่วไป

เกินความบ้าคลั่ง:

คุณอาจสามารถสร้างไฟล์สั่งการเพียงไฟล์เดียวหากคุณสามารถเชื่อมโยงไปยัง (และปรับให้เหมาะสมด้วย) python runtime และไลบรารีทั้งหมด (dll) แบบคงที่ ด้วยวิธีนี้จะเป็นการยากที่จะสกัดกั้นการโทรไปยัง / จาก python และไลบรารีเฟรมเวิร์กที่คุณใช้ สิ่งนี้ไม่สามารถทำได้หากคุณใช้รหัส LGPL

ฉันเข้าใจว่าคุณต้องการให้ลูกค้าใช้พลังของ python แต่ไม่ต้องการให้เปิดเผยซอร์สโค้ด

นี่คือคำแนะนำของฉัน:

(a) เขียนส่วนสำคัญของรหัสเป็นไลบรารี C หรือ C ++ จากนั้นใช้SIPหรือswigเพื่อแสดง C / C ++ APIs ไปที่ Python namespace

(b) ใช้cythonแทน Python

(c) ทั้งใน (a) และ (b) มันควรจะเป็นไปได้ที่จะแจกจ่ายไลบรารี่เป็นไบนารี่ที่ได้รับอนุญาตพร้อมอินเทอร์เฟซ Python

นายจ้างของคุณทราบหรือไม่ว่าเขาสามารถ "ขโมย" คืนความคิดใด ๆ ที่คนอื่นได้รับจากรหัสของคุณ ฉันหมายความว่าถ้าพวกเขาสามารถอ่านงานของคุณได้ บางทีการดูว่าคุณจะได้รับประโยชน์จากสถานการณ์อย่างไรจะให้ผลตอบแทนจากการลงทุนของคุณได้ดีกว่าการกลัวว่าคุณจะแพ้เท่าไหร่

[แก้ไข] ตอบความคิดเห็นของ Nick:

ไม่มีอะไรได้รับและไม่มีอะไรหายไป ลูกค้ามีสิ่งที่เขาต้องการ (และจ่ายให้มันตั้งแต่เขาเปลี่ยนเอง) เนื่องจากเขาไม่ได้ปลดปล่อยการเปลี่ยนแปลงมันก็เหมือนกับว่ามันไม่ได้เกิดขึ้นกับคนอื่น

ตอนนี้ถ้าลูกค้าขายซอฟต์แวร์พวกเขาต้องเปลี่ยนประกาศลิขสิทธิ์ (ซึ่งผิดกฎหมายดังนั้นคุณสามารถฟ้องร้องและจะชนะ -> กรณีง่าย ๆ )

หากพวกเขาไม่เปลี่ยนประกาศเกี่ยวกับลิขสิทธิ์ลูกค้าระดับที่ 2 จะสังเกตเห็นว่าซอฟต์แวร์นั้นมาจากคุณดั้งเดิมและสงสัยว่าเกิดอะไรขึ้น โอกาสที่พวกเขาจะติดต่อคุณและคุณจะได้เรียนรู้เกี่ยวกับการขายงานของคุณ

อีกครั้งเรามีสองกรณี: ลูกค้าเดิมขายเพียงไม่กี่สำเนา นั่นหมายความว่าพวกเขาไม่ได้ทำเงินมากดังนั้นทำไมต้องกังวล หรือพวกเขาขายในปริมาณ นั่นหมายถึงโอกาสที่ดีกว่าสำหรับคุณที่จะเรียนรู้เกี่ยวกับสิ่งที่พวกเขาทำและทำอะไรกับมัน

แต่ในท้ายที่สุด บริษัท ส่วนใหญ่พยายามที่จะปฏิบัติตามกฎหมาย (เมื่อชื่อเสียงของพวกเขาถูกทำลายมันก็ยากที่จะทำธุรกิจ) ดังนั้นพวกเขาจะไม่ขโมยงานของคุณ แต่ทำงานร่วมกับคุณเพื่อปรับปรุง ดังนั้นหากคุณรวมแหล่งที่มา (พร้อมสิทธิ์ใช้งานที่ปกป้องคุณจากการขายต่อที่ง่าย) โอกาสที่พวกเขาจะผลักดันการเปลี่ยนแปลงที่ทำไว้ตั้งแต่นั้นจะทำให้แน่ใจได้ว่าการเปลี่ยนแปลงนั้นอยู่ในรุ่นถัดไปและไม่จำเป็นต้องบำรุงรักษา . นั่นคือ win-win: คุณได้รับการเปลี่ยนแปลงและพวกเขาสามารถทำการเปลี่ยนแปลงเองได้หากพวกเขาต้องการจริงๆแม้ว่าคุณจะไม่ต้องการที่จะรวมไว้ในการเปิดตัวอย่างเป็นทางการก็ตาม

คุณเคยดูpyminifierหรือไม่? มันลดขนาดทำให้งงงวยและบีบอัดรหัสหลาม โค้ดตัวอย่างนั้นดูน่ารังเกียจสำหรับวิศวกรรมย้อนกลับแบบไม่เป็นทางการ

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

อย่าพึ่งพาความงงงวย ตามที่คุณได้ข้อสรุปอย่างถูกต้องมันมีการป้องกันที่ จำกัด มาก ปรับปรุง: นี่คือลิงค์ไปยังกระดาษที่ย้อนกลับรหัสหลาม obfuscated วิศวกรรมใน Dropbox วิธีการ - การแมป opcode เป็นอุปสรรคที่ดี แต่ก็สามารถเอาชนะได้อย่างชัดเจน

แต่เนื่องจากมีผู้โพสต์มากมายที่กล่าวถึงทำให้:

• ไม่คุ้มค่ากับเวลาวิศวกรรมย้อนกลับ (ซอฟต์แวร์ของคุณดีมากมันสมเหตุสมผลที่จะจ่าย)
• ทำให้พวกเขาเซ็นสัญญาและทำการตรวจสอบใบอนุญาตหากทำได้

หรืออีกทางหนึ่งขณะที่เตะตูดหลาม IDE WingIDE ไม่: ให้ไปรหัส ถูกต้องให้รหัสไปและมีคนกลับมาอัพเกรดและสนับสนุน

ใช้Cython มันจะรวบรวมโมดูลของคุณไปยังไฟล์ C ที่มีสมรรถนะสูงซึ่งสามารถรวบรวมไปยังไลบรารีไบนารีดั้งเดิมได้ โดยทั่วไปจะไม่สามารถย้อนกลับได้เมื่อเทียบกับ. pyc bytecode!

ฉันได้เขียนบทความโดยละเอียดเกี่ยวกับวิธีตั้งค่า Cython สำหรับโครงการ Python ลองดู:

การปกป้องแหล่ง Python ด้วย Cython

การจัดส่งไฟล์. pyc มีปัญหา - ไม่รองรับเวอร์ชัน python อื่น ๆ นอกเหนือจากรุ่น python ที่สร้างขึ้นด้วยซึ่งหมายความว่าคุณต้องทราบว่าเวอร์ชันใดของ python ที่ทำงานบนระบบที่ผลิตภัณฑ์จะทำงาน นั่นเป็นปัจจัยที่ จำกัด มาก

ในบางสถานการณ์อาจเป็นไปได้ที่จะย้ายซอฟต์แวร์ (ทั้งหมดหรืออย่างน้อยก็เป็นส่วนสำคัญ) ไปยังบริการบนเว็บที่องค์กรของคุณเป็นโฮสต์

ด้วยวิธีนี้การตรวจสอบใบอนุญาตสามารถดำเนินการได้อย่างปลอดภัยในห้องเซิร์ฟเวอร์ของคุณเอง

แม้ว่าจะไม่มีวิธีแก้ปัญหาที่สมบูรณ์แบบ แต่ก็สามารถทำได้ดังต่อไปนี้:

1. ย้ายรหัสเริ่มต้นบางส่วนที่สำคัญไปยังไลบรารีดั้งเดิม
2. บังคับใช้การตรวจสอบใบอนุญาตในไลบรารี่เนทีฟ

หากการโทรไปยังรหัสเนทีฟนั้นถูกลบโปรแกรมจะไม่เริ่มทำงาน หากยังไม่ถูกลบออกจะมีการบังคับใช้สิทธิ์ใช้งาน

แม้ว่านี่จะไม่ใช่ cross-platform หรือ pure-Python แต่มันก็ใช้ได้

ฉันคิดว่ามีอีกวิธีหนึ่งในการปกป้องรหัส Python ของคุณ ส่วนหนึ่งของวิธีการทำให้งงงวย ฉันเชื่อว่ามีเกมเช่น Mount and Blade หรือสิ่งที่เปลี่ยนแปลงและคอมไพล์เตอร์ไพ ธ อนของตัวเองใหม่ (ล่ามดั้งเดิมที่ฉันเชื่อว่าเป็นโอเพ่นซอร์ส) และเพิ่งเปลี่ยนรหัส OP ในตารางรหัส OP เพื่อแตกต่างจากไพ ธ อนมาตรฐาน OP รหัส

ดังนั้นแหล่งไพ ธ อนจึงไม่ถูกแก้ไข แต่ส่วนขยายไฟล์ของไฟล์ * .pyc นั้นแตกต่างกันและรหัส op ไม่ตรงกับล่ามสาธารณะไพ ธ อน หากคุณตรวจสอบไฟล์ข้อมูลเกมข้อมูลทั้งหมดที่อยู่ในรูปแบบแหล่งหลาม

เทคนิคที่น่ารังเกียจทุกประเภทสามารถทำได้เพื่อยุ่งกับแฮกเกอร์ที่ยังไม่บรรลุนิติภาวะด้วยวิธีนี้ การหยุดแฮ็กเกอร์ที่ไม่มีประสบการณ์เป็นเรื่องง่าย แฮกเกอร์มืออาชีพที่คุณจะไม่ชนะ แต่ บริษัท ส่วนใหญ่ไม่เก็บแฮ็กเกอร์มืออาชีพไว้กับพนักงานมานานเท่าที่ฉันจะจินตนาการได้ แต่แฮ็กเกอร์ที่ยังไม่บรรลุนิติภาวะอยู่ทั่วสถานที่ (อ่านว่าเป็นพนักงานไอทีที่อยากรู้อยากเห็น)

ตัวอย่างเช่นคุณสามารถใช้ล่ามที่ได้รับการแก้ไขอนุญาตให้มันตรวจสอบความคิดเห็นหรือสตริงเอกสารในแหล่งที่มาของคุณ คุณสามารถมีรหัส OP พิเศษสำหรับบรรทัดของรหัสดังกล่าว ตัวอย่างเช่น:

OP 234 สำหรับบรรทัดซอร์ส "# ลิขสิทธิ์ฉันเขียนสิ่งนี้" หรือคอมไพล์บรรทัดนั้นเป็นรหัส op ที่เทียบเท่ากับ "if False:" ถ้า "# Copyright" หายไป โดยพื้นฐานแล้วการปิดใช้งานบล็อกทั้งหมดของรหัสสำหรับสิ่งที่ดูเหมือนจะเป็นเหตุผลที่คลุมเครือ

กรณีใช้งานหนึ่งกรณีที่แปลภาษาที่แปลใหม่อาจเป็นไปได้คือที่ที่คุณไม่ได้เขียนแอพแอพมีขนาดใหญ่ แต่คุณจะได้รับเงินเพื่อปกป้องมันเช่นเมื่อคุณเป็นผู้ดูแลเซิร์ฟเวอร์เฉพาะสำหรับแอพทางการเงิน

ฉันคิดว่ามันขัดแย้งเล็กน้อยที่จะปล่อยให้ซอร์สหรือ opcodes เปิดสำหรับดวงตา แต่ใช้ SSL สำหรับการรับส่งข้อมูลเครือข่าย SSL นั้นไม่ปลอดภัย 100% เช่นกัน แต่มันใช้เพื่อหยุดสายตาจากการอ่านมากที่สุด ข้อควรระวังบิต wee มีเหตุผล

นอกจากนี้หากมีคนพอเห็นว่าแหล่งที่มาของ Python และ opcode นั้นปรากฏชัดเกินไปก็เป็นไปได้ว่าบางคนจะพัฒนาเครื่องมือป้องกันอย่างน้อยที่สุดในที่สุด ผู้คนจำนวนมากถาม "วิธีการป้องกันแอพ Python" เท่านั้นที่ส่งเสริมการพัฒนานั้น

วิธีเดียวที่เชื่อถือได้ในการป้องกันรหัสคือการเรียกใช้บนเซิร์ฟเวอร์ที่คุณควบคุมและให้ลูกค้าของคุณมีไคลเอนต์ที่เชื่อมต่อกับเซิร์ฟเวอร์นั้น

ฉันรู้สึกประหลาดใจที่ไม่เห็นpyconcreteในคำตอบใด ๆ อาจเป็นเพราะมันใหม่กว่าคำถามหรือไม่

มันอาจเป็นสิ่งที่คุณต้องการ (ed)

แทนที่จะทำให้งงงวยรหัสมันเข้ารหัสและถอดรหัสในเวลาโหลด

จากหน้า pypi :

ป้องกันการทำงานของสคริปต์ python

• your_script.py import pyconcrete
• pyconcrete จะขอนำเข้าโมดูล
• เมื่อสคริปต์ของคุณนำเข้าMODULEpyconcrete hook นำเข้าจะพยายามค้นหาMODULE.pyeก่อนแล้วจึงถอดรหัสMODULE.pyeผ่าน_pyconcrete.pydและดำเนินการถอดรหัสข้อมูล (เป็นเนื้อหา. pyc)
• เข้ารหัส & ถอดรหัสลับคีย์เรคคอร์ดใน_pyconcrete.pyd (เช่น DLL หรือดังนั้น) คีย์ลับจะถูกซ่อนในรหัสไบนารี่ไม่สามารถดูได้โดยตรงในมุมมอง HEX

ทั้งนี้ขึ้นอยู่ในที่ลูกค้าที่เป็นกลไกการป้องกันง่ายรวมกับข้อตกลงใบอนุญาตที่เหมาะสมจะไกลมีประสิทธิภาพมากขึ้นกว่าที่ซับซ้อนใบอนุญาต / การเข้ารหัส / obfuscation ระบบใด ๆ

ทางออกที่ดีที่สุดคือการขายรหัสเป็นบริการพูดโดยให้บริการหรือเสนอการสนับสนุนแม้ว่าจะไม่ได้ใช้งานได้จริง

การจัดส่งรหัสเป็น.pycไฟล์จะทำให้การป้องกันของคุณถูกขโมย#วินาที แต่การป้องกันการละเมิดลิขสิทธิ์ที่มีประสิทธิภาพแทบจะไม่มีประสิทธิภาพ (ราวกับว่ามีเทคโนโลยีดังกล่าว) และในตอนท้ายของวัน ข้อตกลงใบอนุญาตที่ดีกับ บริษัท จะ

มุ่งมั่นในการสร้างรหัสของคุณให้น่าใช้มากที่สุดการมีลูกค้าที่มีความสุขจะทำให้ บริษัท ของคุณมีรายได้มากกว่าการป้องกันการละเมิดลิขสิทธิ์ตามทฤษฎี

อีกหนึ่งความพยายามที่จะทำให้รหัสของคุณยากที่จะขโมยคือการใช้ Jython แล้วใช้Obfuscator Java

สิ่งนี้น่าจะใช้งานได้ดีเช่นเดียวกับ jythonc แปลรหัสไพ ธ อนเป็นจาวาแล้วจาวาก็คอมไพล์เป็นไบต์ ดังนั้นคุณจึงทำให้สับสนในคลาสที่จะยากที่จะเข้าใจสิ่งที่เกิดขึ้นหลังจาก decompilation ไม่พูดถึงการกู้คืนรหัสจริง

ปัญหาเดียวของ jython คือคุณไม่สามารถใช้โมดูลหลามที่เขียนด้วย c

สิ่งที่เกี่ยวกับการเซ็นชื่อรหัสของคุณด้วยการเข้ารหัสมาตรฐานโดย hashing และเซ็นชื่อไฟล์สำคัญและตรวจสอบด้วยวิธีการคีย์สาธารณะ?

ด้วยวิธีนี้คุณสามารถออกไฟล์ลิขสิทธิ์ด้วยรหัสสาธารณะสำหรับลูกค้าแต่ละราย

เพิ่มเติมคุณสามารถใช้ pfm obfuscator แบบนี้ (เพิ่ง googled มัน)

คุณควรดูว่าคนที่ getdropbox.com ทำเพื่อลูกค้าซอฟต์แวร์ของพวกเขารวมถึงลินุกซ์ มันค่อนข้างยากที่จะถอดรหัสและต้องการการถอดแยกชิ้นส่วนที่สร้างสรรค์เพื่อให้ผ่านกลไกการป้องกัน

สิ่งที่ดีที่สุดที่คุณสามารถทำได้กับ Python คือการปิดบังสิ่งต่าง ๆ

• แกะเอกสารทั้งหมดออกมา
• แจกจ่ายเฉพาะไฟล์ที่รวบรวม. pyc
• ตรึงมันไว้
• ปิดบังค่าคงที่ของคุณภายในคลาส / โมดูลเพื่อให้ความช่วยเหลือ (config) ไม่แสดงทุกอย่าง

คุณสามารถเพิ่มความสับสนเพิ่มเติมได้โดยการเข้ารหัสบางส่วนและถอดรหัสทันทีและส่งผ่านไปยัง eval () แต่ไม่ว่าคุณจะทำอะไรบางคนสามารถทำลายมันได้

สิ่งนี้จะไม่หยุดการโจมตีที่กำหนดจากการแยกส่วนของรหัสไบต์หรือขุดผ่าน API ของคุณด้วยความช่วยเหลือผบ ฯลฯ

แนวคิดของการมีสิทธิ์ใช้งานแบบ จำกัด เวลาและตรวจสอบในโปรแกรมที่ติดตั้งในเครื่องจะไม่ทำงาน แม้จะมีการทำให้งงงวยที่สมบูรณ์แบบการตรวจสอบใบอนุญาตสามารถลบออกได้ อย่างไรก็ตามหากคุณตรวจสอบใบอนุญาตในระบบระยะไกลและเรียกใช้ส่วนสำคัญของโปรแกรมในระบบระยะไกลปิดของคุณคุณจะสามารถปกป้อง IP ของคุณ

การป้องกันคู่แข่งไม่ให้ใช้ซอร์สโค้ดเป็นของตัวเองหรือเขียนโค้ดที่ได้รับการดลใจของพวกเขาวิธีหนึ่งในการป้องกันคือการเพิ่มลายเซ็นให้กับโปรแกรมตรรกะของคุณ (ความลับบางอย่างเพื่อพิสูจน์ว่ารหัสนั้นถูกขโมยจากคุณ) ไพ ธ อนซอร์สโค้ดดังนั้นจึงยากที่จะอ่านและใช้งาน

การทำให้งงงวยที่ดีจะเพิ่มการป้องกันรหัสของคุณโดยทั่วไปซึ่งเป็นการรวบรวมเพื่อปฏิบัติการ (และการปอกไบนารี) การหาว่ารหัสที่ซับซ้อนที่ซับซ้อนนั้นอาจทำงานได้ยากกว่าการเขียนการใช้งานของคุณเอง

สิ่งนี้จะไม่ช่วยป้องกันการแฮกโปรแกรมของคุณ แม้จะมีสิทธิ์ใช้งานรหัสสิ่งที่ทำให้งงงวยจะแตกและโปรแกรมอาจถูกปรับเปลี่ยนให้มีพฤติกรรมที่แตกต่างกันเล็กน้อย (ในลักษณะเดียวกับที่การคอมไพล์โค้ดเป็นไบนารี่ไม่ได้ช่วยป้องกันโปรแกรมดั้งเดิม)

นอกจากนี้การทำให้งงงวยสัญลักษณ์อาจเป็นความคิดที่ดีที่จะไม่สร้างรหัสซึ่งทำให้ทุกอย่างสับสนยิ่งขึ้นหากเช่นกราฟโทรชี้ไปยังสถานที่ต่าง ๆ มากมายแม้ว่าจริง ๆ แล้วสถานที่ต่าง ๆ เหล่านั้นทำสิ่งเดียวกัน

ลายเซ็นแบบลอจิคัลภายในรหัสที่สับสน (เช่นคุณอาจสร้างตารางค่าที่ใช้โดยตรรกะของโปรแกรม แต่ใช้เป็นลายเซ็นด้วย) ซึ่งสามารถใช้เพื่อกำหนดว่ารหัสนั้นมาจากคุณ หากมีคนตัดสินใจที่จะใช้โมดูลรหัสที่ทำให้เข้าใจผิดของคุณเป็นส่วนหนึ่งของผลิตภัณฑ์ของตนเอง (แม้หลังจาก reobfuscating เพื่อให้ดูเหมือนแตกต่าง) คุณสามารถแสดงรหัสนั้นถูกขโมยด้วยลายเซ็นลับของคุณ

ฉันได้ดูการป้องกันซอฟต์แวร์โดยทั่วไปสำหรับโครงการของฉันและปรัชญาทั่วไปคือการป้องกันที่สมบูรณ์นั้นเป็นไปไม่ได้ สิ่งเดียวที่คุณสามารถหวังได้คือเพิ่มการป้องกันให้กับระดับที่จะทำให้ลูกค้าของคุณต้องเสียมากกว่าที่จะซื้อใบอนุญาตอื่น

ด้วยที่กล่าวว่าฉันเพียงแค่ตรวจสอบ google สำหรับหลาม obsfucation และไม่เปิดขึ้นมากอะไร ในโซลูชัน. Net, obsfucation จะเป็นแนวทางแรกในการแก้ไขปัญหาของคุณบนแพลตฟอร์ม windows แต่ฉันไม่แน่ใจว่ามีใครมีโซลูชันบน Linux ที่ทำงานกับ Mono ได้หรือไม่

สิ่งต่อไปคือการเขียนโค้ดของคุณในภาษาที่คอมไพล์หรือถ้าคุณต้องการไปจนสุดทางในแอสเซมเบลอร์ ไฟล์ที่ถอดออกได้จะยากในการแปลมากกว่าภาษาที่แปล

ทุกอย่างลงมาเพื่อแลกเปลี่ยน ในปลายด้านหนึ่งคุณจะมีความสะดวกในการพัฒนาซอฟต์แวร์ในไพ ธ อนซึ่งมันยากมากที่จะซ่อนความลับ ในอีกด้านหนึ่งคุณมีซอฟต์แวร์ที่เขียนในแอสเซมเบลอร์ซึ่งเขียนได้ยากกว่า แต่ซ่อนความลับได้ง่ายกว่ามาก

เจ้านายของคุณต้องเลือกจุดใดจุดหนึ่งตามความต่อเนื่องที่รองรับความต้องการของเขา จากนั้นเขาก็ต้องมอบเครื่องมือและเวลาให้คุณเพื่อให้คุณสามารถสร้างสิ่งที่เขาต้องการ อย่างไรก็ตามการเดิมพันของฉันคือเขาจะคัดค้านต้นทุนการพัฒนาที่แท้จริงเมื่อเทียบกับการสูญเสียเงินที่อาจเกิดขึ้น

เรื่องสั้นสั้น:

1. เข้ารหัสรหัสต้นฉบับของคุณ
2. เขียนไพ ธ อนเดอร์โมดูลของคุณเองเพื่อถอดรหัสรหัสของคุณเมื่อนำเข้า
3. ติดตั้งโมดูลโหลดเดอร์ใน C / C ++
4. คุณสามารถเพิ่มคุณสมบัติเพิ่มเติมลงในโมดูลโหลดเดอร์ได้เช่นตัวป้องกันการดีบั๊กการควบคุมใบอนุญาตการเชื่อมลายนิ้วมือกับฮาร์ดแวร์เป็นต้น

สำหรับรายละเอียดเพิ่มเติมดูคำตอบนี้นี้

หากคุณมีความสนใจในหัวข้อโครงการนี้จะช่วยให้คุณ - pyprotect

เป็นไปได้ที่จะมีรหัส py2exe ในทรัพยากรที่เข้ารหัสสำหรับตัวเรียกใช้งาน C ที่โหลดและดำเนินการในหน่วยความจำ แนวคิดบางอย่างที่นี่และที่นี่ที่นี่

บางคนก็คิดว่าโปรแกรมปรับเปลี่ยนด้วยตนเองเพื่อให้วิศวกรรมย้อนกลับมีราคาแพง

คุณยังสามารถค้นหา บทช่วยสอนเพื่อป้องกันการดีบั๊กเกอร์ทำให้การถอดแอสเซมเบลอร์ล้มเหลวตั้งจุดพักการดีบักเกอร์ที่ผิดและป้องกันโค้ดของคุณด้วย checksums ค้นหา ["crypted code" execute "ในหน่วยความจำ"] เพื่อหาลิงค์เพิ่มเติม

แต่อย่างที่คนอื่น ๆ พูดกันแล้วถ้ารหัสของคุณมีค่ามันวิศวกรย้อนกลับจะประสบความสำเร็จในที่สุด

หากเรามุ่งเน้นไปที่การให้สิทธิ์ใช้งานซอฟต์แวร์ฉันขอแนะนำให้ดูคำตอบของ Stack Overflow คำตอบที่ฉันเขียนไว้ที่นี่เพื่อรับแรงบันดาลใจเกี่ยวกับวิธีการสร้างระบบการตรวจสอบคีย์ใบอนุญาต

มีห้องสมุดโอเพนซอร์ซบนGitHubที่สามารถช่วยคุณในการตรวจสอบใบอนุญาตบิต

คุณสามารถติดตั้งได้โดยpip install licensingเพิ่มรหัสต่อไปนี้:

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

คุณสามารถอ่านเพิ่มเติมเกี่ยวกับวิธีการคีย์สาธารณะ RSA ฯลฯ มีการกำหนดค่าที่นี่

ใช้วิธีเดียวกันเพื่อปกป้องไฟล์ไบนารีของ c / c ++ นั่นคือทำให้งงงวยแต่ละฟังก์ชั่นร่างกายในไฟล์ปฏิบัติการหรือไลบรารีไฟล์ไบนารีแทรกคำสั่ง "กระโดด" ที่จุดเริ่มต้นของรายการฟังก์ชั่นแต่ละข้ามไปที่ฟังก์ชั่นพิเศษเพื่อเรียกคืนรหัส obfuscated Byte-code เป็นรหัสไบนารี่ของสคริปต์ Python ดังนั้น

• ไพ ธ อนสคริปต์คอมไพล์แรกไปยังวัตถุรหัส
• จากนั้นวนแต่ละรหัสวัตถุ obfuscate co_code ของแต่ละรหัสวัตถุดังต่อไปนี้

    0 JUMP_ABSOLUTE n = 3 + len (bytecode)

    3
    ...
    ... ที่นี่เป็นรหัสไบต์ที่สับสน
    ...

    มี LOAD_GLOBAL หรือไม่ (__pyarmor__)
    n + 3 CALL_FUNCTION 0
    n + 6 POP_TOP
    n + 7 JUMP_ABSOLUTE 0

• บันทึกออบเจ็กต์รหัสที่ยุ่งเหยิงเป็นไฟล์. pyc หรือ. pyo

ไฟล์ obfuscated เหล่านี้ (.pyc หรือ. pyo) สามารถใช้งานได้โดยล่ามไพ ธ อนปกติเมื่อวัตถุรหัสเหล่านั้นถูกเรียกครั้งแรก

• op ตัวแรกคือ JUMP_ABSOLUTE มันจะข้ามไปที่ offset n

• ที่ offset n คำสั่งคือเรียก PyCFunction ฟังก์ชั่นนี้จะทำการคืนค่าโค้ดไบต์ที่ยุ่งเหยิงระหว่างอ็อฟเซ็ต 3 และ n และใส่โค้ดไบต์ดั้งเดิมที่ออฟเซ็ต 0 รหัสที่ยุ่งเหยิงสามารถรับได้โดยรหัสต่อไปนี้

      ถ่าน * 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)
  

• หลังจากฟังก์ชั่นนี้กลับมาคำสั่งสุดท้ายคือการข้ามไปยังออฟเซ็ต 0 ตอนนี้ไบต์รหัสจริงๆจะถูกดำเนินการ

มีเครื่องมือPyarmorเพื่อทำให้สคริปต์ Python ทำให้งงงวยด้วยวิธีนี้

การใช้ cxfreeze (py2exe สำหรับ linux) จะทำงานได้

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

มันมีอยู่ในที่เก็บอูบุนตู

มีคำตอบที่ครอบคลุมเกี่ยวกับการปกปิดรหัสที่มาหลามซึ่งสามารถพบคือที่นี่

เทคนิคที่เป็นไปได้ที่กล่าวถึงคือ:
- ใช้คอมไพล์ bytecode ( python -m compileall)
- ผู้สร้างที่ปฏิบัติการได้ (หรือตัวติดตั้งอย่างPyInstaller )
- ซอฟต์แวร์เป็นบริการ (ทางออกที่ดีที่สุดในการซ่อนรหัสของคุณในความคิดของฉัน)
- python