(加密代码1.0免费下载!)猫老师首创Lisp源代码加密技术,无法批量还原！加密思路大公开

不死猫

为了方便大家学习研究,提供当时第一版加密工具的完整源码!
有兴趣的朋友可以不断改进这段代码.

单一函数加密正式版看这里
http://bbs.mjtd.com/thread-111133-1-1.html


在线演示加密非正式版点我进入
http://nonsmall.mjtd.com/myweb/default.aspx



下面是代码混淆器的1.0版完整源码!!!!
这个版本功能比较弱,不过后面的代码都是根据这个代码改进出来的.



其中部分源码预览:

1. (while (< i (length newlst))
   
2.     (setq item (nth i newlst))
   
3.     (cond
   
4.       ((= item "setq")
   
5.         (setq allstr (strcat allstr "(setq " 前缀 (itoa i) " " "set" " )"))
   
6.         (setq nowstr (strcat nowstr " " 前缀 (itoa i)))
   
7.         (setq i (+ 1 i))
   
8.         (setq item (nth i newlst))
   
9.         (cond              
   
10.           ((= (type (read item)) 'STR)
    
11.             (setq nowstr (strcat nowstr " " item))
    
12.           )
    
13.           ((setq pos (vl-position item 变量表))
    
14.             (setq allstr (strcat allstr "(setq " 前缀 (itoa i) " " item " )"))
    
15.             (setq nowstr (strcat nowstr " (read \"" (nth pos 变量混乱表) "\") "))
    
16.           )
    
17.           (1
    
18.             (setq allstr (strcat allstr "(setq " 前缀 (itoa i) " " item " )"))
    
19.             (setq nowstr (strcat nowstr " (read \"" 前缀 (itoa i) "\") "))
    
20.             (setq 变量表 (append 变量表 (list item)))
    
21.             (setq 变量混乱表 (append 变量混乱表 (list (strcat " " 前缀 (itoa i)))))
    
22.           )
    
23.         )
    
24.       )
    
25.       ((setq pos (vl-position item 变量表))
    
26.         (setq allstr (strcat allstr "(setq " 前缀 (itoa i) " " item " )"))
    
27.         (setq nowstr (strcat nowstr (nth pos 变量混乱表)))
    
28.       )
    
29.       ((vl-string-position (ascii ";") item)
    
30.         item
    
31.       )
    
32.       ((and
    
33.           (not (vl-string-position (ascii ":") item))
    
34.           (not (vl-string-position (ascii ")") item))
    
35.           (not (vl-string-position (ascii "(") item))
    
36.           (not (vl-string-position (ascii " ") item))
    
37.           (/= "DEFUN" item)
    
38.           (/= "WHILE" item)
    
39.           (/= "REPEAT" item)
    
40.           (/= "PROGN" item)
    
41.           (/= "IF" item)
    
42.           (/= "COMMAND" item)
    
43.           (/= "COND" item)
    
44.           (/= "/" item)
    
45.           (/= "\t" item)
    
46.           (/= "OR" item)
    
47.           (/= "nil" item)
    
48.         )
    
49.         (setq allstr (strcat allstr "(setq " 前缀 (itoa i) " " item " )"))
    
50.         (setq nowstr (strcat nowstr " " 前缀 (itoa i)))
    
51.       )
    
52.       (1
    
53.         (setq nowstr (strcat nowstr " " item))
    
54.       )
    
55.     )
    
56.     (setq i (1+ i))
    
57.   )

(while (< i (length newlst))<br />     (setq item (nth i newlst))<br />     (cond<br />       ((= item "setq")<br />         (setq allstr (strcat allstr "(setq " 前缀 (itoa i) " " "set" " )"))<br />         (setq nowstr (strcat nowstr " " 前缀 (itoa i)))<br />         (setq i (+ 1 i))<br />         (setq item (nth i newlst))<br />         (cond              <br />           ((= (type (read item)) 'STR)<br />             (setq nowstr (strcat nowstr " " item))<br />           )<br />           ((setq pos (vl-position item 变量表))<br />             (setq allstr (strcat allstr "(setq " 前缀 (itoa i) " " item " )"))<br />             (setq nowstr (strcat nowstr " (read \"" (nth pos 变量混乱表) "\") "))<br />           )<br />           (1<br />             (setq allstr (strcat allstr "(setq " 前缀 (itoa i) " " item " )"))<br />             (setq nowstr (strcat nowstr " (read \"" 前缀 (itoa i) "\") "))<br />             (setq 变量表 (append 变量表 (list item)))<br />             (setq 变量混乱表 (append 变量混乱表 (list (strcat " " 前缀 (itoa i)))))<br />           )<br />         )<br />       )<br />       ((setq pos (vl-position item 变量表))<br />         (setq allstr (strcat allstr "(setq " 前缀 (itoa i) " " item " )"))<br />         (setq nowstr (strcat nowstr (nth pos 变量混乱表)))<br />       )<br />       ((vl-string-position (ascii ";") item)<br />         item<br />       )<br />       ((and<br />           (not (vl-string-position (ascii ":") item))<br />           (not (vl-string-position (ascii ")") item))<br />           (not (vl-string-position (ascii "(") item))<br />           (not (vl-string-position (ascii " ") item))<br />           (/= "DEFUN" item)<br />           (/= "WHILE" item)<br />           (/= "REPEAT" item)<br />           (/= "PROGN" item)<br />           (/= "IF" item)<br />           (/= "COMMAND" item)<br />           (/= "COND" item)<br />           (/= "/" item)<br />           (/= "\t" item)<br />           (/= "OR" item)<br />           (/= "nil" item)<br />         )<br />         (setq allstr (strcat allstr "(setq " 前缀 (itoa i) " " item " )"))<br />         (setq nowstr (strcat nowstr " " 前缀 (itoa i)))<br />       )<br />       (1<br />         (setq nowstr (strcat nowstr " " item))<br />       )<br />     )<br />     (setq i (1+ i))<br />   )

=======================思路的分割线=============================

随着技术的不断增强,vlx fas都已经不够安全,vlx-fas已经不是秘密，fas还原lsp也已经实现.
但其实加密技术也可以不断的创新,代码混淆就是个不错的办法
源码加密方式可以千变万化,完全可以达到几乎"不可逆"的程度,而且不影响正常功能的使用.
先简单加密一个小程序作为加密的范例,有需要的朋友可以按这个思路来写自己的加密工具!
谁偷走了我的源码?

程序源码:
加密后的:

===========版本2分割线==============
第二版:

(defun c:aa ()
(alert "aa")
(setq s (+ 3 4))
)

加密后(加密过程中,使用随机密码表,可以防止批量的可逆操作)

(setq setq6 (eval (read (vl-list->string (mapcar '(lambda (x) (- x 5 0)) '(102 113 106 119 121))))) )(setq setq7 (eval (read (vl-list->string (mapcar '(lambda (x) (- x 5 0)) '(39 102 102 39))))) )(setq setq10 set )(setq setq11 s )(setq setq13 (eval (read (vl-list->string (mapcar '(lambda (x) (- x 5 192)) '(240))))) )(setq setq14 (eval (read (vl-list->string (mapcar '(lambda (x) (- x 5 1)) '(57))))) )(setq setq15 (eval (read (vl-list->string (mapcar '(lambda (x) (- x 5 0)) '(57))))) )
( defun c:aa ( ) ( setq6 setq7 ) ( setq10 (read "setq11")  ( setq13 setq14 setq15 ) ) )

===========版本3分割线==============
第三版:
我们已经知道,对于command setq or cond if while等核心函数无法重定义,那有什么办法进行隐藏呢?
答案是肯定的,因为lisp语言允许字符串和符号互转.
(read (strcat "(command " "\"line\" " "pt1 " "pt2 " "\"\")"))
OK 然后把其中的字符串再用第二版的方法进行替换隐藏:)
这样在主程序中就看不见写了神马.(每个字符串可以拆分单独定义,并且可以打乱定义顺序)
程序加密的基本意义在于程序能用,难读,难改,隐藏核心代码,极大的提高解密难度.
在后续的发展中,如果能巧妙的隐藏用户注册部分的代码,解密需要花费很多工日,相信对代码的保护会有一定的帮助.

===========版本4分割线==============
第四版
在加密字符串的过程中,使用自定义的随机密码表,可以提高批量还原的难度.
这个范例中的原代码是这个帖子的
http://bbs.mjtd.com/thread-101021-1-1.html
初步加密后的样子是这样的,通过不断增加加密的方法,最终还原的难度会大于写一个新的程序.




===========版本5分割线==============
第五版  加入真正的随机变量分布,而且变量长度也是随机的...


===========版本6分割线==============
第六版的加密度达到5级了!(假设10级是不可逆转的)
其中的变量都做了隐藏,想通过简单的替换来处理,比较困难.
手工还原的可能性越来越低了,而且写程序还原的难度也很大(随便改进一下加密方式,解密程序就废了.)
以后如果搞几种加密方式,并且加密方式的选择是系统随机性组合的话:)

原代码121KB  加密后1165KB !!


===========版本7分割线==============
对所有可重新定义的函数做了隐藏
源代码:

1. (defun tt (a b c)
   
2.   (+ a b c)
   
3. )
   
4. (defun c:tt()
   
5.   (print (tt 1 2 3))
   
6. )

(defun tt (a b c)<br />   (+ a b c)<br /> )<br /> (defun c:tt()<br />   (print (tt 1 2 3))<br /> )

经过加密后:

===========版本8分割线==============
第八版
加密度上升到6级!(假设10级是不可逆转的)，主要是把定义函数放到程序内部，这样就不能简单的替换了。
同时加入随机扰乱代码！！这个步骤很重要，终于实现了无法用反编译程序完全自动还原的目的，因为任何程序都无法判断代码是否有用！
加密前：

加密后：



===========版本9分割线==============
第九版
加密度6.5
在完成上面的加密后,把每行代码重新定义为随机函数,然后把这些行代码函数顺序随机打乱.

1. (defun c:tt()
   
2. a
   
3. b
   
4. c
   
5. )
   

(defun c:tt()<br /> a<br /> b<br /> c<br /> )<br />

1. (defun c:tt()
   
2. (defun bb ()
   
3.   b
   
4. )
   
5. (defun cc ()
   
6.   c
   
7. )
   
8. (defun aa ()
   
9.   a
   
10. )
    
11. (aa)
    
12. (bb)
    
13. (cc)
    
14. )
    

(defun c:tt()<br /> (defun bb ()<br />   b<br /> )<br /> (defun cc ()<br />   c<br /> )<br /> (defun aa ()<br />   a<br /> )<br /> (aa)<br /> (bb)<br /> (cc)<br /> )<br />

之后将执行函数按正确顺序排列.可正确执行.
再次重新定义执行函数为新的一组函数,把原顺序的执行函数再次打乱.
打乱步骤重复执行多次.
这样所有行代码的文本内顺序均为随机乱序排列了.

1. (defun c:tt()
   
2. (defun bb ()
   
3.   b
   
4. )
   
5. (defun cc ()
   
6.   c
   
7. )
   
8. (defun bbb()
   
9.   (bb)
   
10. )
    
11. (defun aa ()
    
12.   a
    
13. )
    
14. (defun ccc()
    
15.   (cc)
    
16. )
    
17. (defun aaa()
    
18.   (aa)
    
19. )
    
20. (aaa)
    
21. (bbb)
    
22. (ccc)
    
23. )

(defun c:tt()<br /> (defun bb ()<br />   b<br /> )<br /> (defun cc ()<br />   c<br /> )<br /> (defun bbb()<br />   (bb)<br /> )<br /> (defun aa ()<br />   a<br /> )<br /> (defun ccc()<br />   (cc)<br /> )<br /> (defun aaa()<br />   (aa)<br /> )<br /> (aaa)<br /> (bbb)<br /> (ccc)<br /> )

加密前

加密后

人工还原的可能性降低了很多,因为嵌套的函数定义和乱序可以不断自我加密.


===========版本10分割线==============
在这个版本完成后,密级应该达到了7级以上.
如果想用编程来还原,也将很难实现,原始代码只有5句话,我就不贴源码了,
加密后的中间代码请看:
简单测试

添加点难度

---

===========版本N分割线==============
中间已经不记得改过多少次了,新的加密思路很简单,对于之前所进行加密过的代码,再次进行加密.对vl-list->string 中的数字,用变量替换,并把变量隐藏到其他地方去.
例如:增加扰乱的函数定义,隐藏所有的函数调用,隐藏加密过程数据,替换加密后的代码等等.

经过测试,这样的加密已经无法进行批量替换还原.因为代码执行时正确,执行后变量释放,想批量处理,几乎没可能了.
我已经彻底放弃批量逆向的想法,退路全部堵死.
在国内,能够逆向这套加密算法的程序,相信在未来很多年都不会有人开发出来,包括我自己.只要稍微改进加密手段,破解者之前的工作就白白浪费了.这也是比fas加密最大的优势.想想去破解这样的代码,如果替换出了错误根本找不到哪里出错,这才是最头疼的.
加密前代码:
加密后代码: (本代码无法使用vlide打开调试,也算是一种保护呦)

关于效率部分的说明:对于需要高效率执行的部分,简单加密,对于注册部分,超级加密.不影响执行速度,又保障了注册代码的安全.

千秋雪

楼主你好，你的《单一函数加密正式版》不能识别变量值为 > 或 <的变量。
如：当某变量名为aa  其值为 >   经《单一函数加密正式版》加工过的变量aa便无法识别了，即便在程序内部

f4800

为了方便大家学习研究,提供当时第一版加密工具的完整源码!
有兴趣的朋友可以不断改进这段代码.

疯球

看看，希望不是太高深，太高深看不懂

nonsmall

,通过不断增加加密的方法,最终还原的难度会大于写一个新的程序[em01]

rjtiantian

回复可见源码

linshiyin2

顶顶小猫猫

xshrimp

参观一下呢.

ivde

矛与盾的关系

328302216

看看，希望不是太高深，太高深看不懂

vang

学习猫猫大作

yjpzc

老师的贴一定要顶

cmbcmbcjh

打酱油的 谢谢老大