首页 手机软件 手机游戏 单机游戏 资讯文章 专题下载 游戏合集 文章合集 php下载 php教程 电脑软件
+ -
当前位置：首页 → 问答吧 → 求一个文件加密算法

求一个文件加密算法

时间：2010-06-28

来源：互联网

用于对jpg图像文件进行加密，性能第一安全第二，当然也不能完全不考虑安全，像那种简单的逻辑移位是肯定不行的，3des这种复杂的算法效率又跟不上。

作者: tajial   发布时间: 2010-06-28

我只用过一个botan加密库：http://botan.randombit.net/

作者: ecjtubaowp   发布时间: 2010-06-28

回复 ecjtubaowp
好像是C++的
有C版本的吗？

作者: tajial   发布时间: 2010-06-28

jpg图片一般都不大，楼主可以试试aes

作者: c/unix   发布时间: 2010-06-28

本帖最后由 yulihua49 于 2010-06-28 17:13 编辑


QUOTE:
用于对jpg图像文件进行加密，性能第一安全第二，当然也不能完全不考虑安全，像那种简单的逻辑移位是肯定不行 ...
tajial 发表于 2010-06-28 14:12


ENIGMA密码：
http://blog.chinaunix.net/u3/92831/showart_2163335.html

    加入SDBC群，群空间有源码。QQ100807652

加密速度：
enigma1是3DES的27倍，frenz是13.5倍，enigma2是6.5倍。

使用方法：
#include <enigma.h>

ENIGMA2 egm;
//生成密码机
         enigma2_init(&ehm,"key122237@#$$%%");

//加密：

      enigma2_encode(&egm,buf,size);//buf里明码原位便密码
//解密：
      enigma2_decode(&egm,buf,size);//buf里密码原位变明码

安全性，在上文讨论。
适于流媒体加密。

由于是序列密码，对加密信息的长度没有限制，加密前后长度不变。

安全讨论，见80楼：
http://bbs.chinaunix.net/viewthr ... ;page=8#pid12368686

作者: yulihua49   发布时间: 2010-06-28



QUOTE:
ENIGMA密码：


    加入SDBC群，群空间有源码。QQ100807652

加密速度：
enigma1是3DES的27倍，fr ...
yulihua49 发表于 2010-06-28 17:00



兄弟直接上传个源码包吧

作者: c/unix   发布时间: 2010-06-28

本帖最后由 yulihua49 于 2010-06-28 17:19 编辑


QUOTE:
兄弟直接上传个源码包吧
c/unix 发表于 2010-06-28 17:06




    加入SDBC群，在群空间-共享空间有，群论坛有编译方法：
你能看到吗？把part01-04下来，解压到linux'
http://qun.qq.com/air/#100807652/share
好像不行，入群吧，我等你。

只编译string和crypto两个目录即可。

crypt目录下有个t_eni.c,就是demo。

作者: yulihua49   发布时间: 2010-06-28



QUOTE:
兄弟直接上传个源码包吧
c/unix 发表于 2010-06-28 17:06




    测试demo：
  1. /* enigma 加密测试 */
  2. #include <strproc.h>
  3. #include <enigma.h>
  4. #include <sys/time.h>

  6. //#define TEST_SPEED

  8. long interval(struct timeval *begtime,struct timeval *endtime)
  9. {
  10. long ret;
  11.         ret=endtime->tv_sec-begtime->tv_sec;
  12.         ret*=1000000;
  13.         ret += endtime->tv_usec - begtime->tv_usec;
  14.         return ret;
  15. }


  18. int main(int ac,char *av[])
  19. {
  20. char buf[131702];
  21. int len,i,len1;
  22. ENIGMA t;
  23. ENIGMA2 egm;
  24. struct timeval beg,end;

  26.         enigma1_init(t,"永 垂 不 朽，Enigma");
  27.         printf("t1:");
  28.         for(i=0;i<256;i++) {
  29.                 if(!(i&7)) putchar('\n');
  30.                 printf("%3d:%d\t",i,255&t[0][i]);
  31.         }
  32.         printf("\nt3:");
  33.         for(i=0;i<256;i++) {
  34.                 if(!(i&7)) putchar('\n');
  35.                 printf("%3d:%d\t",i,255&t[2][i]);
  36.         }
  37.         enigma2_init(&egm,"永 垂 不 朽 的 Enigma");
  38.         printf("\ncrc=%d\n",egm.crc);
  39. //      enigma2_init(&egm,"\x01\xff\x35\xf8\xef\x97\x22\x14\x80\x7f\t\b\r\n\377\177\225");
  40.         memset(buf,'\373',sizeof(buf));
  41.         buf[sizeof(buf)-1]=0;
  42. #ifndef TEST_SPEED
  43.         while(!ferror(stdin)) {
  44.                 fgets(buf,sizeof(buf),stdin);
  45.                 if(feof(stdin)) break;
  46.                 TRIM(buf);
  47. #endif
  48.                 len=strlen(buf);
  49.                 gettimeofday(&beg,0);
  50.                 enigma1(t,buf,len);
  51.                 gettimeofday(&end,0);
  52.                 len1=len>32?32:len;
  53.                 printf("enigma1 encode:");
  54.                 for(i=0;i<len1;i++) printf("%02X ",buf[i]&255);
  55.                 printf("\nenigma1 encode 64K:");
  56.                 for(i=0;i<len1;i++) printf("%02X ",buf[i+65536]&255);
  57.                 printf("\ntimeval=%ld\n",interval(&beg,&end));
  58.                 enigma1(t,buf,len);
  59.                 printf("enigma1 decode:\n%.100s\n",buf);
  60. //test frenz
  61.                 gettimeofday(&beg,0);
  62.                 frenz_encode(t,buf,len);
  63.                 gettimeofday(&end,0);
  64.                 printf("frenz encode:");
  65.                 for(i=0;i<len1;i++) printf("%02X ",buf[i]&255);
  66.                 printf("\nfrenz encode 64K:");
  67.                 for(i=0;i<len1;i++) printf("%02X ",buf[i+65536]&255);
  68.                 printf("\ntimeval=%ld\n",interval(&beg,&end));
  69.                 frenz_decode(t,buf,len);
  70.                 printf("frenz decode:\n%.100s\n",buf);
  71. //test enigma2
  72.                 gettimeofday(&beg,0);
  73.                 enigma2_encode(&egm,buf,len);
  74.                 gettimeofday(&end,0);
  75.                 printf("enigma2 encode:");
  76.                 for(i=0;i<len1;i++) printf("%02X ",buf[i]&255);
  77.                 printf("\nenigma2 encode 64K:");
  78.                 for(i=0;i<len1;i++) printf("%02X ",buf[i+65536]&255);
  79.                 printf("\ntimeval=%ld\n",interval(&beg,&end));
  80.                 enigma2_decode(&egm,buf,len);
  81.                 printf("enigma2 decode:\n%.100s\n",buf);
  82. #ifndef TEST_SPEED
  83.         }
  84. #endif
  85.         return 0;
  86. }
复制代码

作者: yulihua49   发布时间: 2010-06-28

没想到ENIGMA还这么强大啊，没用过。

作者: ecjtubaowp   发布时间: 2010-06-28



QUOTE:
测试demo：
yulihua49 发表于 2010-06-28 17:20




    源码：
enigma.h：
  1. #ifndef ENIGMA_H
  2. #define ENIGMA_H

  4. #define ROTORSZ 256

  6. typedef char ENIGMA[3][ROTORSZ];
  7. typedef struct {
  8.         ENIGMA t;
  9.         ENIGMA r;
  10.         INT4 crc;
  11. } ENIGMA2;

  13. #ifdef __cplusplus
  14. extern "C" {
  15. #endif
  16. /* 改进的 ENIGMA 程序 */
  17. void enigma1_init(ENIGMA t,char *key);
  18. void enigma1(ENIGMA t,char *buf,int len);
  19. //疯狂旋转的转轮机，完全屏蔽了列表特征，不存在周期性
  20. void frenz_encode(ENIGMA t,char *string,int len);
  21. void frenz_decode(ENIGMA t,char *string,int len);

  23. /* 加密后扰码，用于配合多种加密手段 */
  24. void enigma_rev(ENIGMA t,char *buf,int len);
  25. /* 解扰后解密，用于解密 */
  26. void rev_enigma(ENIGMA t,char *buf,int len);

  28. /* 加强的ENIGMA程序，完全消除了密文与相似明文的对应关系 */
  29. void enigma2_init(ENIGMA2 *ep,char *key); //初始化
  30. void enigma2_encode(ENIGMA2 *ep,char *buf,int len);     //加密
  31. void enigma2_decode(ENIGMA2 *ep,char *buf,int len); //解密
  32. /*
  33. void enigma3_encode(ENIGMA2 *ep,char *buf,int len);     //加密
  34. void enigma3_decode(ENIGMA2 *ep,char *buf,int len); //解密
  35. */

  37. #ifdef __cplusplus
  38. }
  39. #endif

  41. #endif
复制代码

作者: yulihua49   发布时间: 2010-06-28

本帖最后由 yulihua49 于 2010-06-28 17:31 编辑


QUOTE:
兄弟直接上传个源码包吧
c/unix 发表于 2010-06-28 17:06


enigma1.c：
  1. #include <strproc.h>
  2. #include <enigma.h>
  3. #include <arpa/inet.h>
  4. #include <crc.h>
  5. #include <des.h>
  6. /*
  7. *      A one-rotor machine designed along the lines of Enigma
  8. *      but considerably trivialized.
  9. */

  11. #define MASK 0377
  12. // 随机串长度，如果你想使用MD5，加大这个值
  13. #define RAN_LEN 17

  15. /* 生成密码轮 */
  16. void enigma1_init(ENIGMA t,char *pw)
  17. {
  18. int ic, i, k, temp;
  19. int random,seed;
  20. char *buf,buf1[RAN_LEN+1];
  21. char    *t1,*t2,*t3,salt[3];
  22. int len;
  23. int32_t crc,*ip;
  24. char *h;
  25. int hlen;

  27.         if(!t || !pw || !*pw) return;
  28.         t1=t[0];
  29.         t2=t[1];
  30.         t3=t[2];
  31.         len=strlen(pw);
  32.         crc=(int32_t)ssh_crc32((const unsigned char *)pw,len);
  33.         ip=(int *)buf1;
  34.         *ip=htonl(crc);//CRC在不同系统上具有相同的值，作为随机串的使用，必须保证在所有系统上相同的字节次序

  36.         seed=0xFFFF&gencrc((unsigned char *)pw,len);
  37.         salt[0]=seed&127;
  38.         if(!salt[0]) salt[0]=0X41;
  39.         seed >>= 7;
  40.         salt[1]=seed&127;
  41.         if(!salt[1]) salt[1]=0X41;
  42.         salt[2]=0;
  43.         if(seed==0) seed=pw[len-1];

  45. // 设置ic，初始化的自旋
  46.         ic=len;
  47.         for(i=0;i<len;i++) ic += pw[i];
  48.         ic &= 127;
  49.         ic|=(seed & 128);

  51.         if(len>13) {
  52.                 hlen=13;
  53.                 h=pw+len-13;
  54.         } else {
  55.                 hlen=len;
  56.                 h=pw;
  57.         }

  59. /* 你可以在buf1里添加任何散列数据  如MD5等 */
  60.         buf=des_fcrypt(pw,salt,buf1+sizeof(int32_t));
  61.         for (i=0; i<13; i++) {
  62.                 seed = seed*buf[i] + i;
  63. //随机串由原来的6-7bit提升到8bit，并与密钥的最后13位直接相关
  64.                 buf[i] = (buf[i] << 1) ^ h[i % hlen];
  65.         }
  66. // ic，初始化的自旋
  67.         for(i=0;i<ROTORSZ;i++) {
  68.                 t1[i] = (i+ic) & MASK;
  69.                 t3[i] = 0;
  70.         }
  71.         for(i=0;i<ROTORSZ;i++) {
  72.                 seed = len*seed + buf1[i%RAN_LEN];
  73.                 random = (seed&0X7FFFFFFF) % 65529;     //random(key);
  74. // 以上生成尽可能随机的random，你有充分的自由度选择你的算法
  75. /* 生成主编码轮 t1 */
  76.                 k = ROTORSZ-1 - i;
  77.                 ic = random % (k+1);

  79.                 temp = t1[k];
  80.                 t1[k] = t1[ic];
  81.                 t1[ic] = temp;
  82. /************************************************************************
  83. * 生成反射板 反射板只要不重不漏的把各点两两连接起来?
  84. ************************************************************************/
  85.                 if(t3[k]!=0) continue;
  86.                 ic = (random>>8) % k;
  87.                 while(t3[ic]!=0) ic = (ic+1) % k;
  88.                 t3[k] = ic;
  89.                 t3[ic] = k;
  90.         }
  91. /* t2为t1的逆 */
  92.         for(i=0;i<ROTORSZ;i++)
  93.                 t2[t1[i]&MASK] = i;
  94. }
  95. void enigma1(ENIGMA t,char *string,int len)
  96. {
  97. register char *p;
  98. register int  n1,n2, k, x;      //x旋转因子
  99. char *t1,*t2,*t3;

  101.         if(!t || !string || len <= 0) return;
  102.         t1=t[0];
  103.         t2=t[1];
  104.         t3=t[2];
  105. //初始位置和旋转因子与len和T有关，不知道T就不知道它们，也无法通过明文、密文的关系推断T。
  106.         n2=t[len&1][(len>>9)&MASK]&MASK;
  107.         n1=t3[(len>>1)&MASK]&MASK;

  109.         x=((t3[((len>>17)+n1)&MASK]&3)<<1)+1;   //x=1,3,5,7

  111.         p=string;
  112.         for(k=0;k<len;k++){
  113.                 *p = t2[(t3[(t1[(*p+n1)&MASK]+n2)&MASK]-n2)&MASK]-n1;
  114.                 ++p;
  115.                 n1 += x;
  116.                 if (n1 >= ROTORSZ) {
  117.                         n1 &= MASK;
  118.                         if(++n2==ROTORSZ) n2 = 0;
  119.                 }
  120.         }
  121. }

  123. void frenz_encode(ENIGMA t,char *string,int len)
  124. {
  125. register char *p;
  126. register int x,n1;       //x旋转因子
  127. char *t1,*t2,*t3;
  128. int  n2, k;
  129. //int r=0;

  131.         if(!t || !string || len <= 0) return;
  132.         t1=t[0];
  133.         t2=t[1];
  134.         t3=t[2];
  135. //初始位置和旋转因子与len和T有关，不知道T就不知道它们，也无法通过明文、密文的关系推断T。

  137.         n2=t[len&1][(len>>9)&MASK]&MASK;
  138.         n1=t3[(len>>1)&MASK]&MASK;

  140.         p=string;
  141.         for(k=0;k<len;k++){
  142.                 x=t2[(*p+k)&MASK];
  143.                 *p = t2[(t3[(t1[(*p+n1)&MASK]+n2)&MASK]-n2)&MASK]-n1;
  144.                 ++p;
  145.                 n1 += x;
  146.                 if(n1<0) {
  147.                         n1&=MASK;
  148.                         continue;
  149.                 }
  150.                 if (n1 >= ROTORSZ) {
  151.                         n1 &= MASK;
  152.                         if(++n2==ROTORSZ) n2 = 0;
  153. //                      r++;
  154.                 }
  155.         }
  156. }
  157. void frenz_decode(ENIGMA t,char *string,int len)
  158. {
  159. register char *p;
  160. register int x,n1;       //x旋转因子
  161. char *t1,*t2,*t3;
  162. int  n2, k;

  164.         if(!t || !string || len <= 0) return;
  165.         t1=t[0];
  166.         t2=t[1];
  167.         t3=t[2];
  168. //初始位置和旋转因子与len和T有关，不知道T就不知道它们，也无法通过明文、密文的关系推断T。
  169.         n2=t[len&1][(len>>9)&MASK]&MASK;
  170.         n1=t3[(len>>1)&MASK]&MASK;

  172.         p=string;
  173.         for(k=0;k<len;k++){
  174.                 *p = t2[(t3[(t1[(*p+n1)&MASK]+n2)&MASK]-n2)&MASK]-n1;
  175.                 x=t2[(*p+k)&MASK];
  176.                 ++p;
  177.                 n1 += x;
  178.                 if(n1<0) {
  179.                         n1&=MASK;
  180.                         continue;
  181.                 }
  182.                 if (n1 >= ROTORSZ) {
  183.                         n1 &= MASK;
  184.                         if(++n2==ROTORSZ) n2 = 0;
  185.                 }
  186.         }
  187. }
复制代码
里边用到的散列函数;
des_fcrypt,ssh_crc32是ssl里的，crcgen（）是crc16,ccitt的，用别的也行，只要加密解密是一套就行。

作者: yulihua49   发布时间: 2010-06-28

本帖最后由 yulihua49 于 2010-06-28 17:37 编辑


QUOTE:
enigma1.c：
yulihua49 发表于 2010-06-28 17:25



enigma2.c:
  1. #include <strproc.h>
  2. #include "enigma.h"

  4. void b_revers(char *buf,int len)
  5. {
  6. char *p,*p1,c;
  7.         if(!buf || len<2) return;
  8.         p=buf;
  9.         p1=p+len-1;
  10.         while(p1>p) {
  11.                 c=*p1;
  12.                 *p1--=*p;
  13.                 *p++=c;
  14.         }
  15.         return;
  16. }

  18. void enigma_rev(ENIGMA ep,char *buf,int len)
  19. {
  20. int i;
  21. char *p;
  22.         if(!buf||len<=0) return;
  23.         frenz_encode(ep,buf,len);
  24.         b_revers(buf,len);
  25.         p=buf;
  26.         for(i=0;i<len-1;i++) {
  27.                 p[1]^=*p;
  28.                 p++;
  29.         }
  30. }
  31. void rev_enigma(ENIGMA ep,char *buf,int len)
  32. {
  33. int i;
  34. char *p;
  35.         if(!buf||len<=0) return;
  36.         b_revers(buf,len);
  37.         p=buf;
  38.         for(i=0;i<len-1;i++) {
  39.                 *p^=p[1];
  40.                 p++;
  41.         }
  42.         frenz_decode(ep,buf,len);
  43. }
  44. void enigma2_init(ENIGMA2 *ep,char *key)
  45. {
  46. int len;
  47.         if(!ep||!key||!*key) return;
  48.         len=strlen(key);
  49. char rk[len+1];
  50.         strcpy(rk,key);
  51.         enigma1_init(ep->t,key);
  52.         b_revers(rk,len);
  53.         enigma1_init(ep->r,rk);
  54.         ep->crc=0X7FFFFFFF & ssh_crc32(ep->t,2*sizeof(ep->t));
  55. //ShowLog(5,"%s:crc=%d",__FUNCTION__,ep->crc);
  56.         return;
  57. }

  59. static void str_rotor(char *str,int len,int rotor)
  60. {
  61. char *p;
  62.         if(!rotor) return;
  63. char buf[rotor];//WINDOWS不能如此，改alloca

  65.         memcpy(buf,str,rotor);
  66.         memcpy(str,str+rotor,len-rotor);
  67.         memcpy(str+len-rotor,buf,rotor);
  68. }

  70. void enigma2_encode(ENIGMA2 *ep,char *buf,int len)
  71. {
  72. char *p;
  73.         if(!ep) return;
  74.         enigma_rev(ep->t,buf,len);
  75.         str_rotor(buf,len,ep->crc%len);
  76.         enigma1(ep->r,buf,len);
  77. }

  79. void enigma2_decode(ENIGMA2 *ep,char *buf,int len)
  80. {
  81. int i;
  82. char *p;
  83.         if(!ep) return;
  84.         enigma1(ep->r,buf,len);
  85.         i=ep->crc%len;
  86.         if(i) str_rotor(buf,len,len-i);
  87.         rev_enigma(ep->t,buf,len);
  88. }
复制代码
有些.h你没有就删掉，看看缺啥，给你补。缺少ShowLog,删掉吧，那只是个日志。你要下载整个SDBC就没问题了。

作者: yulihua49   发布时间: 2010-06-28



QUOTE:
没想到ENIGMA还这么强大啊，没用过。
ecjtubaowp 发表于 2010-06-28 17:21




   原始 ENIGMA不行，但他的先天体质不错，可改造，这些是我根据现代密码学的理论改造过的。

作者: yulihua49   发布时间: 2010-06-28

AES

作者: nhuczp   发布时间: 2010-06-28

相关阅读 更多

热门阅读

热门下载

更多
关于本站 免责申明 联系我们

Copyright 2006-2020 php爱好者(phpfans.net) All Rights Reserved.备案号：湘ICP备2023016114号-2

本站为非盈利性网站，不接受任何广告。本站所有资源均由网友上传，如有侵权，请发邮件至 [email protected] phpfans.net