代码加密编译

㈠ Unity3D代码加密如何做到防止反编译

Unity3D主要使用C#语法和开源mono运行开发商的代码逻辑，所有代码都不是编译到EXE，而是位于{APP}\build\game_Data\Managed\Assembly-CSharp.dll。而且mono执行原理跟微软.NET Framework兼容但是执行原理完全不一样。传统的.NET Framework加壳全部失效，因为Assembly-CSharp.dll不是PE格式的动态库也不是.NET的动态库，无法从 .NET Framework 加载，而是由mono.dll读取 Assembly-CSharp.dll的里面C#脚本解释执行。
Virbox Protector 对 Assembly-CSharp.dll 做加密，无需手动加密 Assembly-CSharp.dll 代码，自动编译 mono， Assembly-CSharp.dll 代码按需解密，只有调用到才会在内存解密，不调用不解密，黑客无法一次解出所有的代码。一键加密代码逻辑，无法反编译，无法mp内存。不降低游戏帧数，自带反黑引擎，驱动级别反调试，秒杀市面的所有调试器。
Uinty3D 主要的游戏资源都在 resources.assets ，游戏里面所有放在 resources 文件夹下的东西都会放在这里，DSProtector工具可以对Unity软件中的 .resS和resources等资源文件进行加密防止软件或游戏中的资源被非法提取。

㈡ python写的程序怎样加密

对Python加密时可能会有两种形式，一种是对Python转成的exe进行保护，另一种是直接对.py或者.pyc文件进行保护，下面将列举两种形式的保护流程。

1、对python转exe加壳

下载最新版VirboxProtector加壳工具，使用加壳工具直接对demo.exe进行加壳操作

2、对.py/.pyc加密

第一步，使用加壳工具对python安装目录下的python.exe进行加壳，将python.exe拖入到加壳工具VirboxProtector中，配置后直接点击加壳。

第二步，对.py/.pyc进行加密，使用DSProtector对.py/.pyc进行保护。

安全技术：

l虚拟机外壳：精锐5的外壳保护工具，创新性的引入了预分析和自动优化引擎，有效的解决了虚拟化保护代码时的安全性和性能平衡问题。

l碎片代码执行：利用自身成熟的外壳中的代码提取技术，抽取大量、大段代码，加密混淆后在安全环境中执行，最大程度上减少加密锁底层技术和功能的依赖，同时大量大段地移植又保证了更高的安全性。

lVirbox加密编译引擎：集编译、混淆等安全功能于一身，由于在编译阶段介入，可优化空间是普遍虚拟化技术无法比拟的，对代码、变量的混淆程度也有了根本的提升。

l反黑引擎：内置R0级核心态反黑引擎，基于黑客行为特征 的（反黑数据库）反制手段。精准打击调试、注入、内存修改等黑客行为，由被动挨打到主动防护。

加密效果：

加密之前

以pyinstall 的打包方式为例，使用pyinstxtractor.py文件对log_322.exe进行反编译，执行后会生成log_322.exe_extracted文件夹，文件夹内会生成pyc文件。

成功之后会在同目录下生成一个文件夹

㈢ 关于手机PY编程的加密解密编译反编译问题

源码还源、编译反编都是很好的加密和反编工具、加密方式有很多种、你用哪种方式加的密就得用那种方式反编、谢谢采纳

㈣ C语言编译加密问题

不可能的，二进制文件中只存在机器码，不存在源代码。

㈤ 如何对公司的源代码加密

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

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

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

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

㈥ c++加密怎么编译

#include<iostream>

intmain(){

charc[100000];

inti=0;

std::cin>>c;

while(c[i]!=''){

std::cout.put((c[i]-29)>90?c[i]-55:c[i]-29);

i++;

}

return0;

}

㈦ 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代码加密。

㈧ 如何对编译的dll文件进行加密来防止反编译

为防止这类反向工程的威胁，最有效的办法是模糊。
模糊工具运用各种手段达到这一目标，但主要的途径是让变量名字不再具有指示其作用的能力、加密字符串和文字、插入各种欺骗指令使反编译得到的代码不可再编译。
例子：
对未经模糊处理的代码执行反向工程：
Private
Sub
CalcPayroll(ByVal
employeeGroup
As
SpecialList)
While
employeeGroup.HasMore
employee
=
employeeGroup.GetNext(True)
employee.updateSalary
DistributeCheck(employee)
End
While
End
Sub
同样的代码，经过模糊处理再执行反向工程：
Private
Sub
a(ByVal
b
As
a)
While
b.a
a
=
b.a(True)
a.a
a(a)
End
While
End
Sub
显然，两段代码的处理逻辑相同。但是，要说清楚第二段代码到底在做些什么极其困难，甚至要判断它正在访问哪些方法、哪些变量也很困难。
这种改变变量名称的功能是可配置的，例如，假设正在构造一个DLL，可以要求不改动API，有趣的是，这一处理过程显然只是简单地把大量变量的名称简缩成单个字符，但获得了非常好的模糊效果。

㈨ aes加密解密完整可编译的C代码~~~急求

#include <stdio.h>
#include <memory.h>
#include <time.h>
#include <stdlib.h>
#define PLAIN_FILE_OPEN_ERROR -1
#define KEY_FILE_OPEN_ERROR -2
#define CIPHER_FILE_OPEN_ERROR -3
#define OK 1
typedef char ElemType;
/*初始置换表IP*/
int IP_Table[64] = { 57,49,41,33,25,17,9,1,
59,51,43,35,27,19,11,3,
61,53,45,37,29,21,13,5,
63,55,47,39,31,23,15,7,
56,48,40,32,24,16,8,0,
58,50,42,34,26,18,10,2,
60,52,44,36,28,20,12,4,
62,54,46,38,30,22,14,6};
/*逆初始置换表IP^-1*/
int IP_1_Table[64] = {39,7,47,15,55,23,63,31,
38,6,46,14,54,22,62,30,
37,5,45,13,53,21,61,29,
36,4,44,12,52,20,60,28,
35,3,43,11,51,19,59,27,
34,2,42,10,50,18,58,26,
33,1,41,9,49,17,57,25,
32,0,40,8,48,16,56,24};
/*扩充置换表E*/
int E_Table[48] = {31, 0, 1, 2, 3, 4,
3, 4, 5, 6, 7, 8,
7, 8,9,10,11,12,
11,12,13,14,15,16,
15,16,17,18,19,20,
19,20,21,22,23,24,
23,24,25,26,27,28,
27,28,29,30,31, 0};
/*置换函数P*/
int P_Table[32] = {15,6,19,20,28,11,27,16,
0,14,22,25,4,17,30,9,
1,7,23,13,31,26,2,8,
18,12,29,5,21,10,3,24};
/*S盒*/
int S[8][4][16] =
/*S1*/
{{{14,4,13,1,2,15,11,8,3,10,6,12,5,9,0,7},
{0,15,7,4,14,2,13,1,10,6,12,11,9,5,3,8},
{4,1,14,8,13,6,2,11,15,12,9,7,3,10,5,0},
{15,12,8,2,4,9,1,7,5,11,3,14,10,0,6,13}},
/*S2*/
{{15,1,8,14,6,11,3,4,9,7,2,13,12,0,5,10},
{3,13,4,7,15,2,8,14,12,0,1,10,6,9,11,5},
{0,14,7,11,10,4,13,1,5,8,12,6,9,3,2,15},
{13,8,10,1,3,15,4,2,11,6,7,12,0,5,14,9}},
/*S3*/
{{10,0,9,14,6,3,15,5,1,13,12,7,11,4,2,8},
{13,7,0,9,3,4,6,10,2,8,5,14,12,11,15,1},
{13,6,4,9,8,15,3,0,11,1,2,12,5,10,14,7},
{1,10,13,0,6,9,8,7,4,15,14,3,11,5,2,12}},
/*S4*/
{{7,13,14,3,0,6,9,10,1,2,8,5,11,12,4,15},
{13,8,11,5,6,15,0,3,4,7,2,12,1,10,14,9},
{10,6,9,0,12,11,7,13,15,1,3,14,5,2,8,4},
{3,15,0,6,10,1,13,8,9,4,5,11,12,7,2,14}},
/*S5*/
{{2,12,4,1,7,10,11,6,8,5,3,15,13,0,14,9},
{14,11,2,12,4,7,13,1,5,0,15,10,3,9,8,6},
{4,2,1,11,10,13,7,8,15,9,12,5,6,3,0,14},
{11,8,12,7,1,14,2,13,6,15,0,9,10,4,5,3}},
/*S6*/

{{12,1,10,15,9,2,6,8,0,13,3,4,14,7,5,11},
{10,15,4,2,7,12,9,5,6,1,13,14,0,11,3,8},
{9,14,15,5,2,8,12,3,7,0,4,10,1,13,11,6},
{4,3,2,12,9,5,15,10,11,14,1,7,6,0,8,13}},
/*S7*/
{{4,11,2,14,15,0,8,13,3,12,9,7,5,10,6,1},
{13,0,11,7,4,9,1,10,14,3,5,12,2,15,8,6},
{1,4,11,13,12,3,7,14,10,15,6,8,0,5,9,2},
{6,11,13,8,1,4,10,7,9,5,0,15,14,2,3,12}},
/*S8*/
{{13,2,8,4,6,15,11,1,10,9,3,14,5,0,12,7},
{1,15,13,8,10,3,7,4,12,5,6,11,0,14,9,2},
{7,11,4,1,9,12,14,2,0,6,10,13,15,3,5,8},
{2,1,14,7,4,10,8,13,15,12,9,0,3,5,6,11}}};
/*置换选择1*/
int PC_1[56] = {56,48,40,32,24,16,8,
0,57,49,41,33,25,17,
9,1,58,50,42,34,26,
18,10,2,59,51,43,35,
62,54,46,38,30,22,14,
6,61,53,45,37,29,21,
13,5,60,52,44,36,28,
20,12,4,27,19,11,3};
/*置换选择2*/
int PC_2[48] = {13,16,10,23,0,4,2,27,
14,5,20,9,22,18,11,3,
25,7,15,6,26,19,12,1,
40,51,30,36,46,54,29,39,
50,44,32,46,43,48,38,55,
33,52,45,41,49,35,28,31};
/*对左移次数的规定*/
int MOVE_TIMES[16] = {1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1};
int ByteToBit(ElemType ch,ElemType bit[8]);
int BitToByte(ElemType bit[8],ElemType *ch);
int Char8ToBit64(ElemType ch[8],ElemType bit[64]);
int Bit64ToChar8(ElemType bit[64],ElemType ch[8]);
int DES_MakeSubKeys(ElemType key[64],ElemType subKeys[16][48]);
int DES_PC1_Transform(ElemType key[64], ElemType tempbts[56]);
int DES_PC2_Transform(ElemType key[56], ElemType tempbts[48]);
int DES_ROL(ElemType data[56], int time);
int DES_IP_Transform(ElemType data[64]);
int DES_IP_1_Transform(ElemType data[64]);
int DES_E_Transform(ElemType data[48]);
int DES_P_Transform(ElemType data[32]);
int DES_SBOX(ElemType data[48]);
int DES_XOR(ElemType R[48], ElemType L[48],int count);
int DES_Swap(ElemType left[32],ElemType right[32]);
int DES_EncryptBlock(ElemType plainBlock[8], ElemType subKeys[16][48], ElemType cipherBlock[8]);
int DES_DecryptBlock(ElemType cipherBlock[8], ElemType subKeys[16][48], ElemType plainBlock[8]);
int DES_Encrypt(char *plainFile, char *keyStr,char *cipherFile);
int DES_Decrypt(char *cipherFile, char *keyStr,char *plainFile);
/*字节转换成二进制*/
int ByteToBit(ElemType ch, ElemType bit[8]){
int cnt;
for(cnt = 0;cnt < 8; cnt++){
*(bit+cnt) = (ch>>cnt)&1;
}
return 0;
}
/*二进制转换成字节*/
int BitToByte(ElemType bit[8],ElemType *ch){
int cnt;
for(cnt = 0;cnt < 8; cnt++){
*ch |= *(bit + cnt)<<cnt;
}
return 0;
}
/*将长度为8的字符串转为二进制位串*/
int Char8ToBit64(ElemType ch[8],ElemType bit[64]){

int cnt;
for(cnt = 0; cnt < 8; cnt++){
ByteToBit(*(ch+cnt),bit+(cnt<<3));
}
return 0;
}
/*将二进制位串转为长度为8的字符串*/
int Bit64ToChar8(ElemType bit[64],ElemType ch[8]){
int cnt;
memset(ch,0,8);
for(cnt = 0; cnt < 8; cnt++){
BitToByte(bit+(cnt<<3),ch+cnt);
}
return 0;
}
/*生成子密钥*/
int DES_MakeSubKeys(ElemType key[64],ElemType subKeys[16][48]){
ElemType temp[56];
int cnt;
DES_PC1_Transform(key,temp);/*PC1置换*/
for(cnt = 0; cnt < 16; cnt++){/*16轮跌代，产生16个子密钥*/
DES_ROL(temp,MOVE_TIMES[cnt]);/*循环左移*/
DES_PC2_Transform(temp,subKeys[cnt]);/*PC2置换，产生子密钥*/
}
return 0;
}
/*密钥置换1*/
int DES_PC1_Transform(ElemType key[64], ElemType tempbts[56]){
int cnt;
for(cnt = 0; cnt < 56; cnt++){
tempbts[cnt] = key[PC_1[cnt]];
}
return 0;
}
/*密钥置换2*/
int DES_PC2_Transform(ElemType key[56], ElemType tempbts[48]){
int cnt;
for(cnt = 0; cnt < 48; cnt++){
tempbts[cnt] = key[PC_2[cnt]];
}
return 0;
}
/*循环左移*/
int DES_ROL(ElemType data[56], int time){
ElemType temp[56];
/*保存将要循环移动到右边的位*/
memcpy(temp,data,time);
memcpy(temp+time,data+28,time);
/*前28位移动*/
memcpy(data,data+time,28-time);
memcpy(data+28-time,temp,time);
/*后28位移动*/
memcpy(data+28,data+28+time,28-time);
memcpy(data+56-time,temp+time,time);
return 0;
}
/*IP置换*/
int DES_IP_Transform(ElemType data[64]){
int cnt;
ElemType temp[64];
for(cnt = 0; cnt < 64; cnt++){
temp[cnt] = data[IP_Table[cnt]];
}
memcpy(data,temp,64);
return 0;

}
/*IP逆置换*/
int DES_IP_1_Transform(ElemType data[64]){
int cnt;
ElemType temp[64];
for(cnt = 0; cnt < 64; cnt++){
temp[cnt] = data[IP_1_Table[cnt]];
}
memcpy(data,temp,64);
return 0;
}
/*扩展置换*/
int DES_E_Transform(ElemType data[48]){
int cnt;
ElemType temp[48];
for(cnt = 0; cnt < 48; cnt++){
temp[cnt] = data[E_Table[cnt]];
}
memcpy(data,temp,48);
return 0;
}
/*P置换*/
int DES_P_Transform(ElemType data[32]){
int cnt;
ElemType temp[32];
for(cnt = 0; cnt < 32; cnt++){
temp[cnt] = data[P_Table[cnt]];
}
memcpy(data,temp,32);
return 0;
}
/*异或*/
int DES_XOR(ElemType R[48], ElemType L[48] ,int count){
int cnt;
for(cnt = 0; cnt < count; cnt++){
R[cnt] ^= L[cnt];
}
return 0;
}
/*S盒置换*/
int DES_SBOX(ElemType data[48]){
int cnt;
int line,row,output;
int cur1,cur2;
for(cnt = 0; cnt < 8; cnt++){
cur1 = cnt*6;
cur2 = cnt<<2;
/*计算在S盒中的行与列*/
line = (data[cur1]<<1) + data[cur1+5];
row = (data[cur1+1]<<3) + (data[cur1+2]<<2)
+ (data[cur1+3]<<1) + data[cur1+4];
output = S[cnt][line][row];
/*化为2进制*/
data[cur2] = (output&0X08)>>3;
data[cur2+1] = (output&0X04)>>2;
data[cur2+2] = (output&0X02)>>1;
data[cur2+3] = output&0x01;
}
return 0;
}
/*交换*/
int DES_Swap(ElemType left[32], ElemType right[32]){
ElemType temp[32];
memcpy(temp,left,32);
memcpy(left,right,32);
memcpy(right,temp,32);
return 0;

}
/*加密单个分组*/
int DES_EncryptBlock(ElemType plainBlock[8], ElemType subKeys[16][48], ElemType cipherBlock[8]){
ElemType plainBits[64];
ElemType Right[48];
int cnt;
Char8ToBit64(plainBlock,plainBits);
/*初始置换（IP置换）*/
DES_IP_Transform(plainBits);
/*16轮迭代*/
for(cnt = 0; cnt < 16; cnt++){
memcpy(Right,plainBits+32,32);
/*将右半部分进行扩展置换，从32位扩展到48位*/
DES_E_Transform(Right);
/*将右半部分与子密钥进行异或操作*/
DES_XOR(Right,subKeys[cnt],48);
/*异或结果进入S盒，输出32位结果*/
DES_SBOX(Right);
/*P置换*/
DES_P_Transform(Right);
/*将明文左半部分与右半部分进行异或*/
DES_XOR(plainBits,Right,32);
if(cnt != 15){
/*最终完成左右部的交换*/
DES_Swap(plainBits,plainBits+32);
}
}
/*逆初始置换（IP^1置换）*/
DES_IP_1_Transform(plainBits);
Bit64ToChar8(plainBits,cipherBlock);
return 0;
}
/*解密单个分组*/
int DES_DecryptBlock(ElemType cipherBlock[8], ElemType subKeys[16][48],ElemType plainBlock[8]){
ElemType cipherBits[64];
ElemType Right[48];
int cnt;
Char8ToBit64(cipherBlock,cipherBits);
/*初始置换（IP置换）*/
DES_IP_Transform(cipherBits);
/*16轮迭代*/
for(cnt = 15; cnt >= 0; cnt--){
memcpy(Right,cipherBits+32,32);
/*将右半部分进行扩展置换，从32位扩展到48位*/
DES_E_Transform(Right);
/*将右半部分与子密钥进行异或操作*/
DES_XOR(Right,subKeys[cnt],48);
/*异或结果进入S盒，输出32位结果*/
DES_SBOX(Right);
/*P置换*/
DES_P_Transform(Right);
/*将明文左半部分与右半部分进行异或*/
DES_XOR(cipherBits,Right,32);
if(cnt != 0){
/*最终完成左右部的交换*/
DES_Swap(cipherBits,cipherBits+32);
}
}
/*逆初始置换（IP^1置换）*/
DES_IP_1_Transform(cipherBits);
Bit64ToChar8(cipherBits,plainBlock);
return 0;
}
/*加密文件*/
int DES_Encrypt(char *plainFile, char *keyStr,char *cipherFile){
FILE *plain,*cipher;
int count;
ElemType plainBlock[8],cipherBlock[8],keyBlock[8];

ElemType bKey[64];
ElemType subKeys[16][48];
if((plain = fopen(plainFile,"rb")) == NULL){
return PLAIN_FILE_OPEN_ERROR;
}
if((cipher = fopen(cipherFile,"wb")) == NULL){
return CIPHER_FILE_OPEN_ERROR;
}
/*设置密钥*/
memcpy(keyBlock,keyStr,8);
/*将密钥转换为二进制流*/
Char8ToBit64(keyBlock,bKey);
/*生成子密钥*/
DES_MakeSubKeys(bKey,subKeys);
while(!feof(plain)){
/*每次读8个字节，并返回成功读取的字节数*/
if((count = fread(plainBlock,sizeof(char),8,plain)) == 8){
DES_EncryptBlock(plainBlock,subKeys,cipherBlock);
fwrite(cipherBlock,sizeof(char),8,cipher);
}
}
if(count){
/*填充*/
memset(plainBlock + count,'\0',7 - count);
/*最后一个字符保存包括最后一个字符在内的所填充的字符数量*/
plainBlock[7] = 8 - count;
DES_EncryptBlock(plainBlock,subKeys,cipherBlock);
fwrite(cipherBlock,sizeof(char),8,cipher);
}
fclose(plain);
fclose(cipher);
return OK;
}
/*解密文件*/
int DES_Decrypt(char *cipherFile, char *keyStr,char *plainFile){
FILE *plain, *cipher;
int count,times = 0;
long fileLen;
ElemType plainBlock[8],cipherBlock[8],keyBlock[8];
ElemType bKey[64];
ElemType subKeys[16][48];
if((cipher = fopen(cipherFile,"rb")) == NULL){
return CIPHER_FILE_OPEN_ERROR;
}
if((plain = fopen(plainFile,"wb")) == NULL){
return PLAIN_FILE_OPEN_ERROR;
}
/*设置密钥*/
memcpy(keyBlock,keyStr,8);
/*将密钥转换为二进制流*/
Char8ToBit64(keyBlock,bKey);
/*生成子密钥*/
DES_MakeSubKeys(bKey,subKeys);
/*取文件长度 */
fseek(cipher,0,SEEK_END);/*将文件指针置尾*/
fileLen = ftell(cipher); /*取文件指针当前位置*/
rewind(cipher); /*将文件指针重指向文件头*/
while(1){
/*密文的字节数一定是8的整数倍*/
fread(cipherBlock,sizeof(char),8,cipher);
DES_DecryptBlock(cipherBlock,subKeys,plainBlock);
times += 8;
if(times < fileLen){
fwrite(plainBlock,sizeof(char),8,plain);
}
else{
break;
}
}
/*判断末尾是否被填充*/
if(plainBlock[7] < 8){

for(count = 8 - plainBlock[7]; count < 7; count++){
if(plainBlock[count] != '\0'){
break;
}
}
}
if(count == 7){/*有填充*/
fwrite(plainBlock,sizeof(char),8 - plainBlock[7],plain);
}
else{/*无填充*/
fwrite(plainBlock,sizeof(char),8,plain);
}
fclose(plain);
fclose(cipher);
return OK;
}
int main()
{
clock_t a,b;
a = clock();
DES_Encrypt("1.txt","key.txt","2.txt");
b = clock();
printf("加密消耗%d毫秒\n",b-a);
system("pause");
a = clock();
DES_Decrypt("2.txt","key.txt","3.txt");
b = clock();
printf("解密消耗%d毫秒\n",b-a);
getchar();
return 0;
}

㈩ 如何将Linux Shell程序使用shc编译加密

第一步非常简单，就是获取到
shc
程序的源码文件，这个可以从官方站点（现在视乎无法访问）下载，或者从参考资料里面提供的地址下载。
2
下载到源文件后，先要解压出来，使用Tarball工具进行解压，命令时
tar
-xvf
shc.tar
这样就能得到解压后的文件，。
3
这时候我们自己编译shc得到可以使用的可执行程序，过程如下：
make
make
install
等待系统完成即可，我这里因为权限问题，帮助文件安装出了些问题，但整体还是没有问题的。
4
我们准备一个程序，这里就使用简单的显示语句，文件名
test.sh
echo
"
this
is
a
shell"
然后
sch
-f
test.sh
完成编译操作，会发现目录下多出如下图所示的文件
5
这里是编译完成后的目录内容，可以看到
.x
的已经编译后的二进制可执行文件，而
.x.c
的是转化的C语言源文件。
6
这里显示的是经过转化过的C语言源文件，可以在同一目录下看到，内容已经经过处理，字符串都进行了编码处理。
7
我们直接执行对应的编译后的二进制程序，可以看到，效果和shell文件是一样的，但是这样源代码隐藏了起来，保密性强。
END
注意事项
shc需要自己编译，因此您需要有GCC的环境
shc
在使用了
-r
选项的时候具有通用性，很多系统之间可以直接运行，参数如下：
shc
并不是真正意义的高强度加密，因此很容易被逆向工程，所以不要依靠这个的安全性