给运行代码加密

A. php7代码如何加密

我们先写出函数：

<?php

function encode_file_contents($filename) {

$type=strtolower(substr(strrchr($filename,'.'),1));

if ('php' == $type && is_file($filename) && is_writable($filename)) { //

如果是PHP文件 并且可写 则进行压缩编码

$contents = file_get_contents($filename); // 判断文件是否已经被编码处

理

$contents = php_strip_whitespace($filename);

// 去除PHP头部和尾部标识

$headerPos = strpos($contents,'<?php');

$footerPos = strrpos($contents,'?>');

$contents = substr($contents, $headerPos + 5, $footerPos -

$headerPos);

$encode = base64_encode(gzdeflate($contents)); // 开始编码

$encode = '<?php'." eval(gzinflate(base64_decode("."'".

$encode."'"."))); ?>";

return file_put_contents($filename, $encode);

}

return false;

}

调用此函数：

$filename = 'result1.php';

encode_file_contents($filename);

echo "OK,加密完成！";

?>

3

测试是否加密成功：文件名为result1.php,运行代码

4

运行成功。

B. 如何对公司的源代码加密

对公司源代码加密的话 我推荐使用域之盾软件 以下是软件加密的具体流程 希望可以帮到你。

1，首先安装软件 安装完成后 开启 透明加密。对重要文件进行加密。

2，通过 软件限制陌生u盘的试用，设置只读或禁止使用。对常用U盘设置白名单

3，开启软件的外发审核，外发的一切文件资料 等 需要管理员审核否则非法外发 即为乱码。

C. iOS代码加密的几种方式

众所周知的是大部分iOS代码一般不会做加密加固，因为iOS
APP一般是通过AppStore发布的，而且苹果的系统难以攻破，所以在iOS里做代码加固一般是一件出力不讨好的事情。万事皆有例外，不管iOS、adr还是js，加密的目的是为了代码的安全性，虽然现在开源畅行，但是不管个人开发者还是大厂皆有保护代码安全的需求，所以iOS代码加固有了生存的土壤。下面简单介绍下iOS代码加密的几种方式。

iOS代码加密的几种方式

1.字符串加密

字符串会暴露APP的很多关键信息，攻击者可以根据从界面获取的字符串，快速找到相关逻辑的处理函数，从而进行分析破解。加密字符串可以增加攻击者阅读代码的难度以及根据字符串静态搜索的难度。

一般的处理方式是对需要加密的字符串加密，并保存加密后的数据，再在使用字符串的地方插入解密算法。简单的加密算法可以把NSString转为byte或者NSData的方式，还可以把字符串放到后端来返回，尽量少的暴露页面信息。下面举个简单例子，把NSString转为16进制的字符串：

2.符号混淆

符号混淆的中心思想是将类名、方法名、变量名替换为无意义符号，提高应用安全性；防止敏感符号被class-mp工具提取，防止IDA Pro等工具反编译后分析业务代码。目前市面上的IOS应用基本上是没有使用类名方法名混淆的。

• 别名

在编写代码的时候直接用别名可能是最简单的一种方式，也是比较管用的一种方式。因为你的app被破解后，假如很容易就能从你的类名中寻找到蛛丝马迹，那离hook只是一步之遥，之前微信抢红包的插件应该就是用hook的方式执行的。

b.C重写

编写别名的方式不是很易读，而且也不利于后续维护，这时你可能需要升级一下你的保护方式，用C来重写你的代码吧。这样把函数名隐藏在结构体中，用函数指针成员的形式存储，编译后，只留下了地址，去掉了名字和参数表，让他们无从下手( from 念茜)。如下例子：

c.脚本处理

稍微高级一点的是脚本扫描处理替换代码，因为要用到linux命令来编写脚本，可能会有一点门槛，不过学了之后你就可以出去吹嘘你全栈工程师的名头啦。。。

linux脚本比较常用的几个命令如下：

脚本混淆替换是用上述几个命令扫描出来需要替换的字符串，比如方法名，类名，变量名，并做替换，如果你能熟练应用上述几个命令，恭喜你，已经了解了脚本的一点皮毛了。

如以下脚本搜索遍历了代码目录下的需要混淆的关键字：

替换的方式可以直接扫描文件并对文件中的所有内容替换，也可以采用define的方式定义别名。例如：

d.开源项目ios-class-guard

该项目是基于class-mp的扩展，和脚本处理类似，是用class-mp扫描出编译后的类名、方法名、属性名等并做替换，只是不支持隐式C方法的替换，有兴趣的同学可以使用下。

3.代码逻辑混淆

代码逻辑混淆有以下几个方面的含义：

对方法体进行混淆，保证源码被逆向后该部分的代码有很大的迷惑性，因为有一些垃圾代码的存在；

对应用程序逻辑结构进行打乱混排，保证源码可读性降到最低，这很容易把破解者带到沟里去；

它拥有和原始的代码一样的功能，这是最最关键的。

一般使用obfuscator-llvm来做代码逻辑混淆，或许会对该开源工具做个简单介绍。

4.加固SDK

adr中一般比较常见的加固等操作，iOS也有一些第三方提供这样的服务，但是没有真正使用过，不知道效果如何。

当然还有一些第三方服务的加固产品，基本上都是采用了以上一种或几种混淆方式做的封装，如果想要直接可以拿来使用的服务，可以采用下，常用的一些服务如下：

几维安全

iOS加密可能市场很小，但是存在必有道理，在越狱/开源/极客的眼中，你的APP并没有你想象的那么安全，如果希望你的代码更加安全，就应给iOS代码加密。

D. 怎么给自己写的程序加密啊

如果你的程序核心模块不希望被第3方知道，可以在代码里直接加密，用时解密，或者你有汇编实力，直接将功能模块写成SHELLCODE，加密SHELLCODE，需要调用时动态解密。都整个文件加密的可行性比较低

E. 如何给代码加密

推荐试试IP-guard

IP-guard支持对多种类型源代码进行自动加密保护，不需要用手手动操作，而只要在部署了IP-guard的授权环境下，用户就可以正常打开使用加密了的源代码，而脱离了授权环境则无法打开，这样即使泄露出去也不用担心泄密发生

IP-guard的加密基于驱动层和应用层，所以在加密强度上能得到保证，建议不要只上加密，对于防泄密，员工的上网行为、桌面操作行为最好也进行管控。

F. 如何用代码给文件夹加密

方法一：利用文件本身的属性对文件进行隐身

准备工作：电脑一台，有效文件夹一个

具体步骤：首先，我们找到需要加密的文件夹。右击打开“属性”，然后选择“隐藏”。其次再选择“将更改应用于此文件夹、子文件夹和文件”，再单击回车确定。这个时候我们的文件就已经隐身成功了。那么怎么样将其恢复打开呢?我们首先要选择工具栏，将其打开然后选择“文件夹选项”。再是在“查看”中选择“显示隐藏的文件、文件夹和驱动器”，再单击回车确定就可以了。

方法二：利用文件压缩加密

准备工作：电脑一台，有效文件夹一个，压缩文件一个(比如说：WinRAR)

具体步骤：首先，找到要加密的文件夹。然后右击选择WinRAR中的“添加到压缩文件”。操作成功后，我们可以看到一个对话框，在其对话框里面设置解压缩的密码。设置好之后，点击“确定”，将文件压缩成功就可以了，然后我们将原文件删除即可。想要查看文件的时候，我们只需要将其压缩包解压即可，不过大家可要牢记解压密码哦!

方法三：加密软件

准备工作：电脑一台，有效文件夹一个，加密软件一个

具体步骤：在网上下载好适宜的加密软件将其安装即可，注册账号。加密软件它有一定的要求，我们要在磁盘上给其单独的划分一个区来作为它的库，并且设置好它的位置，大小以及密码就可以。那么将文件移进加密软件可以了，要查看的时候输入密码就可以打开加密文件了。

综上所述：上述三种办法都是可以对文件夹来进行加密的，并且它们有自己各自的优缺点。大家在选择哪种办法进行加密的时候，可以按照个人的需求来决定，不过加密的秘密是一定要记住的哦!

G. 如何给代码加密

进入js在线加密工具

把要加密的代码复制到这个框中

得到加密后的代码

右键点击复制

回到桌面，创建一个文件

命名为funs.js

如果不能更新文件名后缀，可以打开任意一个文件夹，左侧-组织-文件夹和搜索选项-隐藏已知文件的扩展名，取消勾选

右键点击文件funs.js，选择编辑，然后将加密后的js文件复制到这里，保存即可

H. 源代码加密 C#

c# dll 加密最快的方法使用加壳工具Virbox Protector，直接加密，Virbox Protectorke可以对dll进行性能分析，分析每个函数的调用次数，对每个函数选择保护方式如：混淆/虚拟化/碎片化/代码加密等；每种加密方法的特点是什么呢？
代码加密（X86）：
针对X86汇编代码：一种代码自修改技术（SMC）保护代码。把当前代码加密存储为密文，存储起来，当程序运行到被保护函数时候自动解密并且执行，执行之后再擦除代码，运行到哪里才解密哪里的代码，黑客无法获得原始机器指令和内存完整性的代码，由于是纯内存操作所以运行速度快， 性价高的保护手段，建议全加
代码加密(IL)
针对dotNet程序，保护IL代码：一种动态运行方法解密被保护代码。把当前代码加密存储为密文，存储起来，当程序运行到被保护函数时候自动解密并且执行，执行之后再擦除代码，执行之后再擦除代码，运行到哪里才解密哪里的代码，黑客无法获得原始的中间语言的指令和内存完整性的代码，由于是纯内存操作所以运行速度快， 性价高的保护手段，建议全加
压缩
类似zip等压缩软件把代码和数据段压缩，由于带有动态密码，没有任何工具可以自动脱壳，是防止反编译和反汇编关键手段。
代码混淆（IL）：
将代码中的各种元素，如变量，函数，类的名字改写成无意义的名字。比如改写成单个字母，或是简短的无意义字母组合，甚至改写成“__”这样的符号，使得阅读的人无法根据名字猜测其用途。
a)重写代码中的部分逻辑，将其变成功能上等价，但是更难理解的形式。比如将for循环改写成while循环，将循环改写成递归，精简中间变量，等等。
b) 打乱代码的格式。比如删除空格，将多行代码挤到一行中，或者将一行代码断成多行等等。
c) 添加花指令，通过特殊构造的指令来使得反汇编器出错，进而干扰反编译工作的进行。
代码混淆器也会带来一些问题。主要的问题包括：· 被混淆的代码难于理解，因此调试除错也变得困难起来。开发人员通常需要保留原始的未混淆的代码用于调试。· 对于支持反射的语言，代码混淆有可能与反射发生冲突。· 代码混淆并不能真正阻止反向工程，只能增大其难度。因此，对于对安全性要求很高的场合，仅仅使用代码混淆并不能保证源代码的安全。
代码混淆的特点是安全度低、不会影响效率。
代码虚拟化：
针对X86代码： 是指将机器代码翻译为机器和人都无法识别的一串伪代码字节流；在具体执行时再对这些伪代码进行一一翻译解释，逐步还原为原始代码并执行。 这段用于翻译伪代码并负责具体执行的子程序就叫作虚拟机VM（好似一个抽象的CPU）。它以一个函数的形式存在，函数的参数就是字节码的内存地址。 由于虚拟机代码和虚拟机CPU的实现可以做到每次都是随机设计和随机执行 并且代码每次可以随机变化，包括一些逻辑上的等价变化可以参考硬件N个与非门NOT-AND实现各种逻辑门，算法和访问内存形式的变化，包括数学上的非等价变化，代码体积几乎可以膨胀达到100到10000倍，造成机器无法做算法还原到原有逻辑。
代码虚拟化的特点是：安全度中、不会影响效率。
代码碎片化：
深思自主知识产权的最新技术：基于 LLVM 和 ARM 虚拟机技术，自动抽取海量代码移入 SS 内核态模块，极大的降低了使用门槛， 不再需要手动移植算法，可移植的算法从有限的几个增长到几乎无限多，支持的语言也不再限于 C， 这是加密技术的一次综合应用，效果上类似于将软件打散执行，让破解者无从下手。
安全度高、建议关键函数或调用加密锁方法；使用太多会影响效率

I. 如何给c/c++源代码加密

#include#include#includevoid findKey(char* key, char* mark){int len = strlen(key);int i = 0;int j = 0;memset(mark,0,26);for (i = 0; i 96){encrypt[i] = map[encrypt[i] - 97];}}outputFile = fopen("output.txt", "w+");fwrite(encrypt,nFileLen,1,outputFile);printf("加密的密文:%s\n", encrypt);fclose(outputFile);fclose(inputFile);free(encrypt);system("pause");return 0;}

J. 如何给代码加密

下面是一个Step by Step的教程，教你如何把一个清晰的代码变得复杂难懂的。当然，这只是一个“简明教程”了。还是那句话——“本文仅供朋友们“消遣作乐”，如果你要觉得有意思的话，顶个贴。如果你觉得没什么意思的话，一笑了之。仅供娱乐而已，不必太过认真。”
开始程序
下面是一个找出素数的程序：void primes(int cap)
{
int i, j, composite;

for(i = 2; i < cap; ++i) {
composite = 0;
for(j = 2; j * j < i; ++j) {
composite += !(i % j);
}
if(!composite){
printf("%dt", i);
}
}
}

int main()
{
primes(100);
}


下面我们来看看如何把上面这段代码搞得复杂难懂。
第一步、把for变成while
通常来说，for循坏要以while循坏简单一些，上面的程序有二重for循环，我们不但要把其变成while循环，而且还要把二重循环的变成一重的循环，然后使用大量的if-else语句来判断。void primes(int cap)
{
int i, j, composite, t = 0;

while(t < cap * cap) {
i = t / cap;
j = t++ % cap;
if(i <= 1);
else if(!j)
composite = j;
else if(j == i && !composite)
printf("%dt",i);
else if(j > 1 && j < i)
composite += !(i % j);
}
}

int main()
{
primes(100);
}


第二步，把循坏变成递归
递归在某些时候是可以把代码变得简单，但大多数的情况下是把代码变得复杂，而且很没有效率。下面是把上面的while循环变成了递归。变成了递归后，函数的参数都变成3个了。void primes(int cap, int t, int composite)
{
int i,j;
i = t / cap;
j = t % cap;
if(i <= 1)
primes(cap,t+1,composite);
else if(!j)
primes(cap,t+1,j);
else if(j == i && !composite)
(printf("%dt",i), primes(cap,t+1,composite));
else if(j > 1 && j < i)
primes(cap,t+1, composite + !(i % j));
else if(t < cap * cap)
primes(cap,t+1,composite);
}

int main()
{
primes(100,0,0);
}


第三步，弄乱代码结构/使用没有含义的变量名
关于如何弄乱代码结构，其中一个小技巧是，使用“？”表达式代替if-else语句。void primes(int m, int t, int c)
{
int i,j;
i = t / m;
j = t % m;
(i <= 1) ? primes(m,t+1,c) : (!j) ? primes(m,t+1,j) : (j == i && !c) ?
(printf("%dt",i), primes(m,t+1,c)) : (j > 1 && j < i) ?
primes(m,t+1,c + !(i % j)) : (t < m * m) ? primes(m,t+1,c) : 0;
}

int main()
{
primes(100,0,0);
}


第四步，取消临时变量
临时变量一般用来保存反复使用的一个表达式的值。使用大量重复的表达式来取消这些临时变量的也可以让代码复杂起来。void primes(int m, int t, int c)
{
((t / m) <= 1) ? primes(m,t+1,c) : !(t % m) ? primes(m,t+1, t % m) :
((t % m)==(t / m) && !c) ? (printf("%dt",(t / m)), primes(m,t+1,c)) :
((t % m)> 1 && (t % m) < (t / m)) ? primes(m,t+1,c + !((t / m) % (t % m))) :
(t < m * m) ? primes(m,t+1,c) : 0;
}

int main()
{
primes(100,0,0);
}


第五步，继续弄乱变量名
我们知道，下划线是合法的变量名，所以，我们不妨用__，___，____来代替m，t，c。函数名也可以使用下划线来代替。让我们来看看求素数的函数能变成什么。


void _(int __, int ___, int ____)
{
((___ / __) <= 1) ? _(__,___+1,____) : !(___ % __) ? _(__,___+1,___ % __) :
((___ % __)==(___ / __) && !____) ? (printf("%dt",(___ / __)),
_(__,___+1,____)) : ((___ % __) > 1 && (___ % __) < (___ / __)) ?
_(__,___+1,____ + !((___ / __) % (___ % __))) : (___ < __ * __) ?
_(__,___+1,____) : 0;
}

int main()
{
_(100,0,0);
}


第六步，移除常量
在上面的程序中，还有一些常量，你可以通过增加一个宏定义，或是增加一个函数的形参来取代这一常量。void _(int __, int ___, int ____, int _____)
{
((___ / __) <= _____) ? _(__,___+_____,____,_____) : !(___ % __) ? _(__,___+_____,___ % __, _____) :
((___ % __)==(___ / __) && !____) ? (printf("%dt",(___ / __)),
_(__,___+_____,____,_____)) : ((___ % __) > _____ && (___ % __) < (___ / __)) ?
_(__,___+_____,____,_____ + !((___ / __) % (___ % __))) : (___ < __ * __) ?
_(__,___+_____,____,_____) : 0;
}

int main() {
_(100,0,0,1);
}


程序到这里应该差不多了。还是那句话——“每一个程序员都有把源代码弄复杂的潜质”，大家好自为之。
转载