c解压缩
由于有一个重要的Rar文件，极需解开，首先试用了ARPC，但是解压的速度极慢，每秒只有30个左右，所以断了穷举破解的念头，却仍不死心，因为我从不崇尚穷举破解的方法，除非每秒可以跑几千万次的，我或许可以一试，所以决定研究一下Winrar3.x密码算法，以期是否可以破解该密码。查看了网络上的资料，包括看雪FAQ里的回答，都声称只能用穷举法破解，起先并不理解，但通过研究，我理解了看雪前辈们在FAQ里所说的原因，不禁让我佩服
Winrar加密思路的成熟。虽然研究的结果没有什么新意，但我还是决定把我的研究结果与大家一起分享，为那些仍然以为winrar密码可以象破解注册码一样的，通过修改winrar弹出框之类的更改文件流程指向可以达到跳过密码检验的朋友，做一个简要的说明。
一、Rar文件生成的流程。
Winrar加密文件时，总的分两个步骤：
1：先把源文件压缩，压成一段数据段。
2：再将压缩完的数据段加密。
对于同一个源文件来说，不进行加密，压缩完，其rar文件中的数据段是一模一样的。但是如果对同一个源文件来说，即使使用同一个密码，加密完rar文件中的数据段是不一样的，这是由于加密的密钥是依赖于一个Salt(8个字节的密钥，用来加密时使用，存放在rar文件头中里）
所以要解密rar加密文件关键在于数据解密这一步，那我们接下来研究一下如何加密的。
二、加密“压缩完的数据段”的流程
1、获取密钥：
将明文的密码与Salt一起，通过HASH算法，生成两个16字节的密钥。（一个是KEY(AES算法的参数)，一个是initVector）
2、以Key和initVector来加密压缩数据：
这里，是一个循环加密的结构，每16字节作为一个块，进行加密（这可能正是为什么加密完的文件长度总为16倍数的原因）。加密采用AES算法（RAR采用的是AES的rijndael的标准应用）。这里注意：AES加密前，有一个异或运算，是先将每16字节块与上一个16字节块加密结果进行异或，然后再进行AES算法的。我用一个简单的示意代码看说明：
;===============================================
packblock[0]=packblock[i]^initVector
encryptBlock[0]=AES(packblock[0]) ；（KEY为AES的密钥）
for i=1to 块数量-1
packblock[i]=packblock[i]^encryptBlock[i-1]
encryptBlock[i]=AES(packblock[i])；（KEY为AES的密钥）
next
;packblock[i]表示压缩完的每16字节数据
;encryptBlock[i]表示加密完的每16字节数据
;===============================================
三、解密的过程
由于AES算法是对称的，所以解密的过程，是加密过程的逆运算。但解密时AES算法过程与加密所用的不一样（是因为解密过程中由KEY生成的子密钥表不一样）。仍然需要我们将密码输入，与salt一起生成两个16字节密钥，KEY和initVector。
;===============================================
packblock[0]=AES1(encryptBlock[0]) ；（KEY为AES的密钥）
packblock[0]=packblock[i]^initVector
for i=1to 块数量-1
packblock[i]=AES1(encryptBlock[i]) ；（KEY为AES的密钥）
packblock[i]=packblock[i]^encryptBlock[i-1]
next
;===============================================
那判断密码是否正确的在什么地方呢？
解密的过程是解密后的数据块进行解压缩，然后解成源文件，对该文件进行CRC校验，存在RAR文件中的源文件CRC校验码比较，相同则密码正确，不相同则密码错误。
四、无法秒破的原因
从上面，我们了解了RAR文件的整体思路。地球人都知道，解密时，肯定有个步骤是来判断密码的正确与否。而且，依据以往的经验，我们也许可以将某些判断的点移动，那样可以缩减破解的流程思路。那RAR的这一步在哪里？它把校验放在了最后的一步。如果要秒破，我们该怎么做泥？至少我认为目前是不可能的。
我们从解密过程逆反过来看看：
1、CRC检验这一块修改跳转？根本毫无意义，因为它已经是最后一步了。你可以修改RAR文件头的CRC值，你可以将它改得和你用任意密码解压出来的文件CRC值一样，但你的文件根本就不是原来的文件了。可能已经完全面目全非了。所以，对这一过程不可行。CRC校验本身是不可逆的
2、那么把判断提前到压缩完的数据？
解压的时候，有没有什么来判断压缩数据是否正确？压缩完的数据，有没有固定的特征，是否可以做为解压的判断，在这一步里，我们也无法找到有效的可用的固定特征。因为这一步涉及到RAR的压缩算法。即使一个源文件，即使你的文件前一部分是完全相同的，只对后面的部分进行改过，那么压缩完，数据也是完全一样的。因为压缩完的数据首先是一个压缩表，后面是编码。文件不一样，扫描完的压缩表也不一样，编码又是依赖于压缩表，所以，这里头找不到压缩完的数据有任何的固定特征可以用来判断的。
不管压缩数据是什么样的，Winrar都一如既往地进行解压，没有进行压缩数据是否有效的判断。
3、那假如我们破解了AES了泥？
由于AES只依赖于KEY，如果AES算法被破解了，我们知道了KEY，我们可以解出压缩完的数据，但是这里有一个问题，还有一个initVector密钥，用来第一个16字节块的异或，你没有initVector参数，你第一个16字节块的数据便无法解得出来。
4、那就只能从第一步Hash的算法入手
即使你能破解hash，但hash后的结果泥？没有结果，你怎么返推密码。
所以综上，我发现rar的加密是由hash和AES两种算法互相牵制，而两种算法当前都无法破解，至少目前还没有办法秒破，也理解了看雪高手讲的道理。
五、对穷举提高算法效率的一些设想。
我用汇编写完了RAR穷举解密的算法模块，但是如何提高效率，优化穷举的速度泥？我有如下的想法：
1、从压缩数据里找寻特征，省掉解压缩、CRC检验代码和生成initVector生成代码。目前，通过多次实验，我找到的一个特征（不知道这个是否正确），即解密完的最后一个16字节块的最后一个字节必须为0。因为经过多次的试验，我发现有加密的数据段长度都会比未加密前的数据长，那么，最后一个
16个字节的数据块解密完，多出的部分就都为0，但多出几个字节泥？多次实验，长度不一，我试想着从加密数据段最后一个16个字节块着手，只解这一块，看是否一个字节为0，这样，只解密16个字节的数据，来大大提高效率？如果能进行到这一步了，再通过解全部数据，进行CRC校验的判断。
2、如果第一个特征不成立的话，针对特定格式的压缩文件，比如doc、jpg等，部分数据固定，压缩完的数据是否存在相互牵制的数据？从而把判断提前，这一步，我不知道如何找到压缩完的数据是否存在相互牵制的数据。
② 请问如何用C语言写一个输入路径，压缩和解压文件的代码 能分享一下源码吗 我想学习一下
这个如果是在linux下面的话可以调用系统自带的压缩工具
大致给你说一下步骤吧。具体还是靠你自己实现
输入路径。这个就不多说。scanf
分析输入的文件路径，或者后缀名。然后调用 tar gzip等压缩，解压缩命令。
压缩的算法如果有兴趣你也可以自己去实现一下。不过不容易实现。还是调用系统自带的压缩命令吧。
③ c语言，如何解压缩字符串，例如：a12g5y8，反解压后变成aaaaaaaaaaaagggggyyyyyyyy,,求代码，谢谢
#include<stdio.h>
voidstrjieya(charsrc[],charres[])
{
intsrc_pos=0;
intres_pos=0;
intchar_num=0;
inti;
while(src[src_pos]!=0)
{
if(src[src_pos]<'0'||src[src_pos]>'9')
{
res[res_pos]=src[src_pos];
src_pos++;
res_pos++;
}
else
{
sscanf(&src[src_pos],"%d",&char_num);
char_num=char_num-1;//因为上面已经放进去一个了
for(i=0;i<char_num;i++)
{
res[res_pos]=src[src_pos-1];
res_pos++;
}
while(src[src_pos]>='0'&&src[src_pos]<='9')
{
src_pos++;
}
}
}
res[res_pos]=0;
}
intmain()
{
chara[]="a12g5y8";
charb[1000];
strjieya(a,b);
printf("%s ",a);
printf("%s ",b);
return0;
}
结果：
a12g5y8
aaaaaaaaaaaagggggyyyyyyyy
Pressanykeytocontinue
④ 如何用c语言压缩解压文件夹
你是想自己写代码实现解压缩的功能，还是只是在代码中调用命令来解压，system()找到你的解压缩工具在加相应的参数
⑤ (20分)用C语言编译的文件压缩解压缩程序
是用霍夫曼树做的
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <conio.h>
struct head
{
unsigned char b; /*the charactor*/
long count; /*the frequency*/
long parent,lch,rch; /*make a tree*/
char bits[256]; /*the haffuman code*/
}
header[512],tmp;
void compress()
{
char filename[255],outputfile[255],buf[512];
unsigned char c;
long i,j,m,n,f;
long min1,pt1,flength;
FILE *ifp,*ofp;
printf("source filename:");
gets(filename);
ifp=fopen(filename,"rb");
if(ifp==NULL)
{
printf("source file open error!\n");
return;
}
printf("destination filename:");
gets(outputfile);
ofp=fopen(outputfile,"wb");
if(ofp==NULL)
{
printf("destination file open error!\n");
return;
}
flength=0;
while(!feof(ifp))
{
fread(&c,1,1,ifp);
header[c].count++;
flength++;
}
flength--;
header[c].count--;
for(i=0;i<512;i++)
{
if(header[i].count!=0) header[i].b=(unsigned char)i;
else header[i].b=0;
header[i].parent=-1;
header[i].lch=header[i].rch=-1;
}
for(i=0;i<256;i++)
{
for(j=i+1;j<256;j++)
{
if(header[i].count<header[j].count)
{
tmp=header[i];
header[i]=header[j];
header[j]=tmp;
}
}
}
for(i=0;i<256;i++) if(header[i].count==0) break;
n=i;
m=2*n-1;
for(i=n;i<m;i++)
{
min1=999999999;
for(j=0;j<i;j++)
{
if(header[j].parent!=-1) continue;
if(min1>header[j].count)
{
pt1=j;
min1=header[j].count;
continue;
}
}
header[i].count=header[pt1].count;
header[pt1].parent=i;
header[i].lch=pt1;
min1=999999999;
for(j=0;j<i;j++)
{
if(header[j].parent!=-1) continue;
if(min1>header[j].count)
{
pt1=j;
min1=header[j].count;
continue;
}
}
header[i].count+=header[pt1].count;
header[i].rch=pt1;
header[pt1].parent=i;
}
for(i=0;i<n;i++)
{
f=i;
header[i].bits[0]=0;
while(header[f].parent!=-1)
{
j=f;
f=header[f].parent;
if(header[f].lch==j)
{
j=strlen(header[i].bits);
memmove(header[i].bits+1,header[i].bits,j+1);
header[i].bits[0]='0';
}
else
{
j=strlen(header[i].bits);
memmove(header[i].bits+1,header[i].bits,j+1);
header[i].bits[0]='1';
}
}
}
fseek(ifp,0,SEEK_SET);
fwrite(&flength,sizeof(int),1,ofp);
fseek(ofp,8,SEEK_SET);
buf[0]=0;
f=0;
pt1=8;
while(!feof(ifp))
{
c=fgetc(ifp);
f++;
for(i=0;i<n;i++)
{
if(c==header[i].b) break;
}
strcat(buf,header[i].bits);
j=strlen(buf);
c=0;
while(j>=8)
{
for(i=0;i<8;i++)
{
if(buf[i]=='1') c=(c<<1)|1;
else c=c<<1;
}
fwrite(&c,1,1,ofp);
pt1++;
strcpy(buf,buf+8);
j=strlen(buf);
}
if(f==flength) break;
}
if(j>0)
{
strcat(buf,"00000000");
for(i=0;i<8;i++)
{
if(buf[i]=='1') c=(c<<1)|1;
else c=c<<1;
}
fwrite(&c,1,1,ofp);
pt1++;
}
fseek(ofp,4,SEEK_SET);
fwrite(&pt1,sizeof(long),1,ofp);
fseek(ofp,pt1,SEEK_SET);
fwrite(&n,sizeof(long),1,ofp);
for(i=0;i<n;i++)
{
fwrite(&(header[i].b),1,1,ofp);
c=strlen(header[i].bits);
fwrite(&c,1,1,ofp);
j=strlen(header[i].bits);
if(j%8!=0)
{
for(f=j%8;f<8;f++)
strcat(header[i].bits,"0");
}
while(header[i].bits[0]!=0)
{
c=0;
for(j=0;j<8;j++)
{
if(header[i].bits[j]=='1') c=(c<<1)|1;
else c=c<<1;
}
strcpy(header[i].bits,header[i].bits+8);
fwrite(&c,1,1,ofp);
}
}
fclose(ifp);
fclose(ofp);
printf("compress successfully!\n");
return;
}
void uncompress()
{
char filename[255],outputfile[255],buf[255],bx[255];
unsigned char c;
long i,j,m,n,f,p,l;
long flength;
FILE *ifp,*ofp;
printf("source filename:");
gets(filename);
ifp=fopen(filename,"rb");
if(ifp==NULL)
{
printf("source file open error!\n");
return;
}
printf("destination filename:");
gets(outputfile);
ofp=fopen(outputfile,"wb");
if(ofp==NULL)
{
printf("destination file open error!\n");
return;
}
fread(&flength,sizeof(long),1,ifp);
fread(&f,sizeof(long),1,ifp);
fseek(ifp,f,SEEK_SET);
fread(&n,sizeof(long),1,ifp);
for(i=0;i<n;i++)
{
fread(&header[i].b,1,1,ifp);
fread(&c,1,1,ifp);
p=(long)c;
header[i].count=p;
header[i].bits[0]=0;
if(p%8>0) m=p/8+1;
else m=p/8;
for(j=0;j<m;j++)
{
fread(&c,1,1,ifp);
f=c;
itoa(f,buf,2);
f=strlen(buf);
for(l=8;l>f;l--)
{
strcat(header[i].bits,"0");
}
strcat(header[i].bits,buf);
}
header[i].bits[p]=0;
}
for(i=0;i<n;i++)
{
for(j=i+1;j<n;j++)
{
if(strlen(header[i].bits)>strlen(header[j].bits))
{
tmp=header[i];
header[i]=header[j];
header[j]=tmp;
}
}
}
p=strlen(header[n-1].bits);
fseek(ifp,8,SEEK_SET);
m=0;
bx[0]=0;
while(1)
{
while(strlen(bx)<(unsigned int)p)
{
fread(&c,1,1,ifp);
f=c;
itoa(f,buf,2);
f=strlen(buf);
for(l=8;l>f;l--)
{
strcat(bx,"0");
}
strcat(bx,buf);
}
for(i=0;i<n;i++)
{
if(memcmp(header[i].bits,bx,header[i].count)==0) break;
}
strcpy(bx,bx+header[i].count);
c=header[i].b;
fwrite(&c,1,1,ofp);
m++;
if(m==flength) break;
}
fclose(ifp);
fclose(ofp);
printf("Uncompress successfully!\n");
return;
}
int main()
{
int c;
printf("1--Compress file\n");
printf("2--Uncompress file\n");
printf("Select 1 or 2:");
c=getch();
printf("%c\n",c);
if(c=='1') compress();
else if(c=='2') uncompress();
return 0;
}
⑥ C语言 解压缩字符串
#include<stdio.h>
intmain()
{
chars[50],s1[100];
inti=0,j=0,k,n;
gets(s);//输入压缩后的字符串
while(s[i])
{
s1[j]=s[i];
//因为形式是先字符后数字，所以第一个肯定是字符，先赋入另一个数组以便后续操作。
i++;j++;//递增，开始处理下一位的数字
n=0;
while(s[i]>='0'&&s[i]<='9')//只要是数字就要进入循环统计
{
n*=10;
n+=s[i]-'0';
i++;
}
for(k=0;k<n-1;k++)
//因为解压缩的字符已经存入数组s1，所以只剩下n-1要再放入s1
s1[j+k]=s1[j-1];
if(n>0)//注意，一定要n>0因为有可能是连续字符，本来就没被压缩这时如果还把j加上n-1就反而是让j减小了。
j+=n-1;
}
s1[j]=' ';//处理结束后，最后一个设为空字符结束。
printf("%s ",s1);
return0;
}
(6)c解压缩扩展阅读
C语言：数据结构-稀疏矩阵的压缩存储
稀疏矩阵的压缩存储原理，只存储非零元素ai，j和相应的行、列序号i、j。具体方法：对稀疏矩阵中每一个非零元素设定一个三元组（i,j,ai,j）。
将所有三元组按行优先排列，组成一个三元组表（线性表）。只要存储三元组表和该矩阵的行、列数，就能唯一确定该矩阵。
⑦ 如何用C语言编写暴力破解压缩文件解压密码
winrar有个命令行解压
rar.exe -y x -p密码 "c:\test.rar" "d:\"
只需要在C语言里把要爆破用的密码生成或者从别的字典导入
然后拼接成命令循环执行就好了
⑧ 如何用C语言解压缩文件
如果你自己设计算法,就另当别论,如果想利用第3方的算法,我推荐用zlib,生成的压缩包是流行的zip格式.源代码很好找(www.zlib.net)
⑨ C++怎么实现解压RAR或者ZIP文件
用Zlib库，下载地址： http://download.chinaunix.net/download/0013000/12241.shtml
BOOL ZipCompress(LPCTSTR lpszSourceFiles, LPCTSTR lpszDestFile);
BOOL ZipExtract(LPCTSTR lpszSourceFile, LPCTSTR lpszDestFolder); 要引入的源文件 ZLib 主目录下的代码，除 minigzip.c、example.c 外； contrib\minizip 下的代码，除 minizip.c、miniunz.c 外。压缩相关： zipOpen64 zipClose zipOpenNewFileInZip zipCloseFileInZip zipWriteInFileInZip解压相关： unzOpen64 unzClose unzGetGlobalInfo64 unzGoToNextFile unzGetCurrentFileInfo64 unzOpenCurrentFile unzCloseCurrentFile unzReadCurrentFile
⑩ c语言压缩文本文件 求解答
#include"stdio.h"
#include"string.h"
#include"malloc.h"
#defineMOD_ADLER65521
#defineHASHMAX1000
#defineMAX_INT9999999//最大读取数字为99999999
#defineCHARBUFLEN40960
#defineDECOMPRESSINITLEN1024
structstringInfo
{
intNo;//字符串出现的次序
char*str;//字符串
structstringInfo*next;//下一节点
}*strTable[HASHMAX];//用于压缩
intisCompress;
char**strTableDe;//解压缩表，用于解压缩
longdeTableLen;//解压缩表长度
longcurStrNum;//目前的字符串数量
//程序初始化
voidinit()
{
inti;
curStrNum=1;
isCompress=1;//压缩模式，等于0时解压缩
if(isCompress)
{
for(i=0;i<HASHMAX;i++)strTable[i]=NULL;
deTableLen=0;
strTableDe=NULL;
}
else
{
deTableLen=DECOMPRESSINITLEN;
strTableDe=(char**)malloc(deTableLen*sizeof(char*));
for(i=0;i<deTableLen;i++)strTableDe[i]=NULL;
}
}
//重新申请内存
voidReMallocDeTable()
{
deTableLen<<=1;
strTableDe=(char**)realloc(strTableDe,deTableLen*sizeof(char*));
}
//程序结束，释放内存
voidover()
{
inti;
structstringInfo*pNext,*pDel;
for(i=0;i<HASHMAX;i++)
{
pNext=strTable[i];
while(pNext)
{
free(pNext->str);
pDel=pNext;
pNext=pNext->next;
free(pDel);
}
}
if(strTableDe)
{
for(i=0;i<curStrNum;i++)
{
//printf("%d %s ",i,strTableDe[i]);
free(strTableDe[i]);
}
free(strTableDe);
}
}
//adler32校验和算法
unsignedlongadler32(unsignedchar*data,size_tlen)
{
unsignedlonga=1,b=0;
size_tindex;
for(index=0;index<len;++index)
{
a=(a+data[index])%MOD_ADLER;
b=(b+a)%MOD_ADLER;
}
return(b<<16)|a;
}
//求字符串的Hash，实现快速查找,这里用的是adler32算法，可以使用其它任何hash方法
unsignedlongHash(constchar*str)
{
returnadler32((unsignedchar*)str,strlen(str))%HASHMAX;
}
//复制新字符串
char*NewStr(constchar*str)
{
char*r=(char*)malloc(strlen(str)+1);
strcpy(r,str);
returnr;
}
//取得字符串出现的次序
intgetStrPos(constchar*str)
{
unsignedlonghash;
structstringInfo*pFirst,*pNext,*pNew;
hash=Hash(str);
pNext=pFirst=strTable[hash];
while(pNext)
{
if(strcmp(pNext->str,str)==0)returnpNext->No;
pNext=pNext->next;
}
//没有找到匹配的字符串
pNew=(structstringInfo*)malloc(sizeof(structstringInfo));
pNew->next=NULL;
pNew->No=curStrNum++;
pNew->str=NewStr(str);
if(pFirst==NULL)strTable[hash]=pNew;
else
{
pNext=pFirst;
while(pNext->next)pNext=pNext->next;
pNext->next=pNew;
}
return-1;
}
//读取字符串,字符串以空格为结束符
//返回负数的绝对值是读取的是字符串长度，正数为读取的数字
intReadStr(char*out,constchar*in)
{
char*po,*pn;
constchar*pi;
intr;
po=out;
pi=in;
while(('a'<=*pi&&*pi<='z')||('A'<=*pi&&*pi<='Z')||('0'<=*pi&&*pi<='9'))
*po++=*pi++;//只复制大小写字母和数字
*po=0;
//试着转化为纯数字
r=0;
pn=out;
while('0'<=*pn&&*pn<='9')
{
if(r>MAX_INT)break;
r*=10;
r+=*pn++-'0';
}
if(*pn)returnout-po;//未成功转化为数字
elsereturn(r&0x7FFFFFF)|(((po-out)&0xF)<<27);
}
voidmain()
{
charreadFileBuf[CHARBUFLEN],readStrBuf[CHARBUFLEN];
char*prfb;
intnum;
FILE*fpr,*fpw;
fpr=fopen("source.txt","r");//输入文件
fpw=fopen("object.txt","w");//输出文件
if(fpr==NULL||fpw==NULL)return;
init();
while(!feof(fpr))
{
if(fgets(readFileBuf,CHARBUFLEN-1,fpr)==NULL)break;
prfb=readFileBuf;
while(*prfb)
{
num=ReadStr(readStrBuf,prfb);
if(num==0)fputc(*prfb++,fpw);//没有读取成功
elseif(num>0)//读入数字
{
prfb+=(num>>27)&0xF;//移动读取的位数
if(isCompress)fprintf(fpw,"0%d",num&0x7FFFFFF);//压缩模式写入数字，前面添加个数字0
else
{
num&=0x7FFFFFF;
if(num==0)//如果读到数字0
{
prfb+=1;
num=ReadStr(readStrBuf,prfb);//读取下一格数据串
if(num>0)
{
prfb+=(num>>27)&0xF;//移动读取的位数
fprintf(fpw,"%d",num&0x7FFFFFF);
}
elsefprintf(fpw,"0",num&0x7FFFFFF);//下一个不是数字
}
elseif(num<curStrNum)fprintf(fpw,"%s",strTableDe[num]);//解压模式写入字符串
else
{
printf("Error:%d,%d ",num,curStrNum);
fprintf(fpw,"%d",num);//num大于已知的字符串数量，写入数字
}
}
}
else
{
num=-num;
prfb+=num;//移动读取的位数
if(isCompress)
{
num=getStrPos(readStrBuf);
if(num<0)fprintf(fpw,"%s",readStrBuf);//未出现过的字符串
elsefprintf(fpw,"%d",num);//写入位置
}
else
{
fprintf(fpw,"%s",readStrBuf);
if(curStrNum>=deTableLen)ReMallocDeTable();//解压表长度不够，重新申请空间
strTableDe[curStrNum++]=NewStr(readStrBuf);//加入解压表
}
}
}
}
if(isCompress)printf("Compresssuccessful! ");
elseprintf("DecompressSuccessful! ");
over();
}