Chinaunix首页 | 论坛 | 博客

kaede_1的ChinaUnix博客

首页　| 　博文目录　| 　关于我

kaede_1

  • 博客访问： 91707
  • 博文数量： 12
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 170
  • 用 户 组： 普通用户
  • 注册时间： 2013-06-19 08:56
文章分类

全部博文（12）

文章存档

2015年（8）

2014年（4）

我的朋友
最近访客
推荐博文
相关博文
C++ file.eof 在encrypt中遇到问题小结

分类： LINUX

2015-05-06 20:49:06

解密程序如下：

点击(此处)折叠或打开


  2. #include <stdlib.h>
  3. #include <stdio.h>
  4. #include <fstream>
  5. #include <sstream>
  6. #include <iostream>
  7. #include <string>
  8. #include <string.h>

  10. #define FAILED 1
  11. #define SUCCESS 0
  12. using namespace std;

  14. const char *stampKey = "linfang2b";
  15. static string stampFile= "/etc/measure/measured.conf";
  16. void strToByte(const char *sptr,int slen,char *bptr)
  17. {
  18.     int i,j,op,tmp;
  19.     for(i=0;i<slen;i++)
  20.     {
  21.     op=0x80;
  22.     for(j=0;j<8;j++)
  23.     {
  24.      tmp=sptr[i]&op;

  26.      if(tmp == 0)

  28.         bptr[i*8+j] = 0x0;
  29.      else

  31.         bptr[i*8+j] = 0x1;
  32.      op>>=1;
  33.     }
  34.     }
  35. }

  37. void byteTostr(const char* bptr,int blen,char* sptr)
  38. {

  40.     int j,op;
  41.     op=0;
  42.     for(j=0;j<blen;j++)
  43.     {
  44.     op|=bptr[j];

  46.     if (j%8 == 7)
  47.     {
  48.      sptr[(j+1)/8-1]=op;
  49.      op=0;
  50.     }
  51.     else
  52.      op<<=1;
  53.     }
  54. }

  56. char* alignStr(const char* src,int slen)
  57. {
  58.     char* dest;
  59.     int alignLen=0,i;
  60.     if(slen%8 != 0)
  61.     alignLen = 8-slen%8;
  62.     dest = (char*)malloc((slen+alignLen+1)*sizeof(char));
  63.     strncpy(dest,src,slen);
  64.     for(i=0;i<alignLen;i++)
  65.     dest[slen+i]='$';
  66.     dest[slen+alignLen]='\0';
  67.     return dest;
  68. }

  70. int unAlignStr(char *string, int slen)
  71. {

  73.     int tlen=slen;
  74.     while(1)
  75.     {
  76.     if(string[tlen-1]=='$')
  77.      string[tlen-1]='\0';

  79.     else

  81.      return tlen;
  82.     tlen--;
  83.     }
  84. }

  86. int enCryptStamp(char* string,int slen,const char* key,int flag)
  87. {
  88.     char* ptr,*buffer,bytekey[64];
  89.     int i,buflen;
  90.     strToByte(key,8,bytekey);
  91.     setkey(bytekey);
  92.     buflen=slen*8;
  93.     buffer=(char*)malloc(buflen*sizeof(char));
  94.     if(NULL == buffer)
  95.     {
  96.     cout << "malloc failed" << endl;
  97.     return FAILED;
  98.     }
  99.     strToByte(string,slen,buffer);
  100.     for(i=0;i<buflen;i+=64)
  101.     {
  102.     ptr=&buffer[i];
  103.     encrypt(ptr,flag);
  104.     }
  105.     byteTostr(buffer,buflen,string);
  106.     free(buffer);
  107.     buffer = NULL;
  108.     return SUCCESS;
  109. }
  110. //int readFromStampConf(string &str)
  111. //{
  112. // fstream file;
  113. // file.open(stampFile.c_str(), ios::in);
  114. // if(!file)
  115. // {
  116. //    cout << "File op failed" << endl;
  117. // return FAILED;
  118. // }
  119. // file >> str;
  120. //
  121. // file.close();
  122. // return SUCCESS;
  123. //
  124. //}
  125. int readFromStampConf(char *str)
  126. {
  127.     fstream file;
  128.     file.open(stampFile.c_str(), ios::in);
  129.     if(!file)
  130.     {
  131.     cout << "File op failed" << endl;
  132.         return FAILED;
  133.     }
  134.     int len = 0;

  136.     //------存在问题，len多加一----------------
  137.     //------在file判断eof时，eof（）返回true时是读到文件结束符0xFF，而文件结束符是最后一个字符的下一个字符
  138.     //------因此多加一
  139.     //while(!file.eof())
  140.     //{
  141.     // file.get(str[len++]);
  142.     //}
  143.     //----------------------------------------

  145.     //------在网上搜了一下，有人说通过file.good()方法判断，本人试过，无效！
  146.     //------也可能是使用方法有误，请指出，谢！
  147.     //while(!file.eof())
  148.     //{
  149.     // if(file.good())
  150.     // file.get(str[len++]);
  151.     //}
  152.     //----------------------------------------


  155.     //------也有人说通过file.fail()方法判断，本人试过，无效！
  156.     //------也可能是使用方法有误，请指出，谢！
  157.     //while(!file.eof())
  158.     //{
  159.     // if(file.fail())
  160.     // break;
  161.     // file.get(str[len++]);
  162.     //}
  163.     //----------------------------------------



  167.     //------通过file.peek方法判断，可行！-----
  168.     //while(file.peek() != EOF)
  169.     //{
  170.     // file.get(str[len++]);
  171.     //}
  172.     //---------------------------------------

  174.     //-----下面形式的get也有问题，导致len多加一
  175.     //while(file.get(str[len++]));
  176.     //-----------------------------------------

  178.     //-----下面方法经尝试也可行！
  179.     char c;
  180.     while(file.get(c))
  181.      str[len++] = c;


  184.     str[len] = '\0';
  185.     file.close();
  186.     return SUCCESS;

  188. }
  189. int main()
  190. {
  191.     char str[100];
  192.     //memset(str, 0, 100);
  193.     readFromStampConf(str);
  194.     
  195.     enCryptStamp((char*)str, strlen(str), stampKey, 1);
  196.     int len = unAlignStr((char*)str, strlen(str));
  197.     str[len] = '\0';
  198.     cout <<"The encrypt content is " << str<< endl;


  201.     return 0;
  202. }
加密程序如下：

点击(此处)折叠或打开

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <string>
  5. #include <iostream>
  6. #include <fstream>
  7. using namespace std;
  8. #define SUCCESS 0
  9. #define FAILED 1
  10. static string stampFile= "/etc/measure/measured.conf";
  11. const char *stampKey = "linfang2b";
  12. void strToByte(const char *sptr,int slen,char *bptr)
  13. {

  15.     int i,j,op,tmp;
  16.     for(i=0;i<slen;i++)
  17.     {
  18.     op=0x80;
  19.     for(j=0;j<8;j++)
  20.     {
  21.      tmp=sptr[i]&op;

  23.      if(tmp == 0)

  25.         bptr[i*8+j] = 0x0;
  26.      else

  28.         bptr[i*8+j] = 0x1;
  29.      op>>=1;
  30.     }
  31.     }
  32. }

  34. void byteTostr(const char* bptr,int blen,char* sptr)
  35. {

  37.     int j,op;
  38.     op=0;
  39.     for(j=0;j<blen;j++)
  40.     {
  41.     op|=bptr[j];

  43.     if (j%8 == 7)
  44.     {
  45.      sptr[(j+1)/8-1]=op;
  46.      op=0;
  47.     }
  48.     else
  49.      op<<=1;
  50.     }
  51. }

  53. char* alignStr(const char* src,int slen)
  54. {
  55.     char* dest;
  56.     int alignLen=0,i;
  57.     if(slen%8 != 0)
  58.     alignLen = 8-slen%8;
  59.     dest = (char*)malloc((slen+alignLen+1)*sizeof(char));
  60.     strncpy(dest,src,slen);
  61.     for(i=0;i<alignLen;i++)
  62.     dest[slen+i]='$';
  63.     dest[slen+alignLen]='\0';
  64.     return dest;
  65. }

  67. int unAlignStr(char *string, int slen)
  68. {

  70.     int tlen=slen;
  71.     while(1)
  72.     {
  73.     if(string[tlen-1]=='$')
  74.      string[tlen-1]='\0';

  76.     else

  78.      return tlen;
  79.     tlen--;
  80.     }
  81. }

  83. int enCryptStamp(char* string,int slen,const char* key,int flag)
  84. {
  85.     char* ptr,*buffer,bytekey[64];
  86.     int i,buflen;
  87.     strToByte(key,8,bytekey);
  88.     setkey(bytekey);
  89.     buflen=slen*8;
  90.     buffer=(char*)malloc(buflen*sizeof(char));
  91.     if(NULL == buffer)
  92.     {
  93.      return FAILED;
  94.     }
  95.     strToByte(string,slen,buffer);
  96.     for(i=0;i<buflen;i+=64)
  97.     {
  98.     ptr=&buffer[i];
  99.     encrypt(ptr,flag);
  100.     }
  101.     byteTostr(buffer,buflen,string);
  102.     free(buffer);
  103.     buffer = NULL;
  104.     return SUCCESS;
  105. }
  106. int isValidStamp(string &stamp)
  107. {
  108.     for(unsigned int i=0; i<stamp.size(); i++)
  109.     {
  110.     if(!isdigit(stamp[i]))
  111.      return FAILED;
  112.     }
  113.     return SUCCESS;
  114. }
  115. int writeToStampConf(const char *key)
  116. {
  117.     fstream file;
  118.     file.open(stampFile.c_str(), ios::out);
  119.     if(!file)
  120.     {
  121.         return FAILED;
  122.     }

  124.     file << key;

  126.     file.close();
  127.     return SUCCESS;

  129. }
  130. int main()
  131. {
  132.     string stamp("36");
  133.     char *key = NULL;
  134.     int iRet;
  135.     key = alignStr(stamp.c_str(), stamp.size());
  136.     iRet = enCryptStamp(key, strlen(key), stampKey, 0);
  137.     if(iRet)
  138.     {
  139.      return FAILED;
  140.     }
  141.     iRet = writeToStampConf(key);
  142.     if(iRet)
  143.      return FAILED;

  145.     free(key);
  146.     key = NULL;
  147.     return SUCCESS;
  148. }

如解密程序注释部分，之前对file.eof的理解有误区，导致解密程序对len计算有问题，导致解密失败。
其实只要将memset那句注释打开，有些问题也就不存在了，因为str[100]可能有非0初值，因此当len在判断eof时多加一，碰巧那一位有值，导致解密失败。
如果在其他环境下，应该对eof进行合理的判断。

此外，encrypt函数在调用过程中需要将字符串转换为“01串”！
阅读(1660) | 评论(0) | 转发(0) |
0

上一篇：SIGABRT信号和glibc detected 的问题

下一篇：解决yum 段错误问题

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6