RC4加密

最新推荐文章于 2022-04-17 19:48:41 发布
最新推荐文章于 2022-04-17 19:48:41 发布
阅读量1.3k 收藏
点赞数
分类专栏： 重构C/C++


1.

RC4加密算法在C++中的实现

在一些场合，常需要用到一些简单的加密算法，这里的RC4就可以说是最简单的一种。只要设置一个足够强的密码，就可以适用于一些非常简单的场合了。我是用来加密HTTP传送的数据的。

RC4函数（加密/解密）    其实，RC4只有加密，将密文再加密一次，就是解密了。

GetKey函数   随机字符串产生器，呵呵，为了方便，大多数加密算法都有一个随机密码产生器，我也就附带一个了。

ByteToHex函数   把字节码转为十六进制码，一个字节两个十六进制。研究发现，十六进制字符串非常适合在HTTP中传输，Base64中的某些字符会造成转义，挺麻烦的。

HexToByte函数   把十六进制字符串，转为字节码。服务器也按照十六进制字符串的形式把数据传回来，这里就可以解码啦。同时，使用十六进制字符串传输，避开了传输过程中多国语言的问题。

Encrypt函数    把字符串经RC4加密后，再把密文转为十六进制字符串返回，可直接用于传输。

Decrypt函数    直接密码十六进制字符串密文，再解密，返回字符串明文。

 

源码如下：

Encrypt.h文件：

 #ifndef _ENCRYPT_RC4_
#define _ENCRYPT_RC4_

#include <string.h>

#define BOX_LEN 256

int GetKey(const unsigned char* pass, int pass_len, unsigned char *out);
int RC4(const unsigned char* data, int data_len, const unsigned char* key, int key_len, unsigned char* out, int* out_len); 
static void swap_byte(unsigned char* a, unsigned char* b);

char* Encrypt(const char* szSource, const char* szPassWord); // 加密，返回加密结果
char* Decrypt(const char* szSource, const char* szPassWord); // 解密，返回解密结果

char* ByteToHex(const unsigned char* vByte, const int vLen); // 把字节码pbBuffer转为十六进制字符串，方便传输
unsigned char* HexToByte(const char* szHex); // 把十六进制字符串转为字节码pbBuffer，解码

#endif // #ifndef _ENCRYPT_RC4_

Encrypt.cpp文件：

#include "Encrypt.h"

char* Encrypt(const char* szSource, const char* szPassWord) // 加密，返回加密结果
{
 if(szSource == NULL || szPassWord == NULL) return NULL;

 unsigned char* ret = new unsigned char[strlen(szSource)];

 int ret_len = 0;

 if(RC4((unsigned char*)szSource, 
   strlen(szSource), 
   (unsigned char*)szPassWord, 
   strlen(szPassWord), 
   ret, 
   &ret_len) == NULL) 
  return NULL;

 char* ret2 = ByteToHex(ret, ret_len);

 delete[] ret;
 return ret2;
}

char* Decrypt(const char* szSource, const char* szPassWord) // 解密，返回解密结果
{
 if(szSource == NULL || (strlen(szSource)%2 != 0) || szPassWord == NULL) 
  return NULL;

 unsigned char* src = HexToByte(szSource);

 unsigned char* ret = new unsigned char[strlen(szSource) / 2 + 1];

 int ret_len = 0;

 memset(ret, strlen(szSource) / 2 + 1,0);

 if(RC4(src, strlen(szSource) / 2, (unsigned char*)szPassWord, strlen(szPassWord), ret, &ret_len) == NULL) 
  return NULL;

 ret[ret_len] = '/0';

 return (char*)ret;
}

int RC4(const unsigned char* data, int data_len, const unsigned char* key, int key_len, unsigned char* out, int* out_len)
{
 if (data == NULL || key == NULL || out == NULL) 
  return NULL;

 unsigned char* mBox = new unsigned char[BOX_LEN];

 if(GetKey(key, key_len, mBox) == NULL) 
  return NULL;

 int i=0;
 int x=0;
 int y=0;
 
 for(int k = 0; k < data_len; k++)
 {
  x = (x + 1) % BOX_LEN;
  y = (mBox[x] + y) % BOX_LEN;
  swap_byte(&mBox[x], &mBox[y]);
  out[k] = data[k] ^ mBox[(mBox[x] + mBox[y]) % BOX_LEN];
 }

 *out_len = data_len;
 delete[] mBox;
 return -1;
}

int GetKey(const unsigned char* pass, int pass_len, unsigned char* out)
{
 if(pass == NULL || out == NULL) 
  return NULL;

 int i;

 for(i = 0; i < BOX_LEN; i++)
  out[i] = i;

 int j = 0;
 for(i = 0; i < BOX_LEN; i++)
 {
  j = (pass[i % pass_len] + out[i] + j) % BOX_LEN;
  swap_byte(&out[i], &out[j]); 
 }

 return -1;
}

static void swap_byte(unsigned char* a, unsigned char* b)
{
 unsigned char swapByte; 
 
 swapByte = *a;

 *a = *b;

 *b = swapByte;
}

// 把字节码转为十六进制码，一个字节两个十六进制，内部为字符串分配空间
char* ByteToHex(const unsigned char* vByte, const int vLen)
{
 if(!vByte) 
  return NULL;

 char* tmp = new char[vLen * 2 + 1]; // 一个字节两个十六进制码，最后要多一个'/0'

 int tmp2;
 for (int i=0;i<vLen;i++)
 {
  tmp2 = (int)(vByte[i])/16;
  tmp[i*2] = (char)(tmp2+((tmp2>9)?'A'-10:'0'));
  tmp2 = (int)(vByte[i])%16;
  tmp[i*2+1] = (char)(tmp2+((tmp2>9)?'A'-10:'0'));
 }

 tmp[vLen * 2] = '/0';
 return tmp;
}

// 把十六进制字符串，转为字节码，每两个十六进制字符作为一个字节
unsigned char* HexToByte(const char* szHex)
{
 if(!szHex) 
  return NULL;

 int iLen = strlen(szHex);

 if (iLen<=0 || 0!=iLen%2) 
  return NULL;

 unsigned char* pbBuf = new unsigned char[iLen/2];  // 数据缓冲区

 int tmp1, tmp2;
 for (int i=0;i<iLen/2;i++)
 {
  tmp1 = (int)szHex[i*2] - (((int)szHex[i*2]>='A')?'A'-10:'0');

  if(tmp1>=16) 
   return NULL;

  tmp2 = (int)szHex[i*2+1] - (((int)szHex[i*2+1]>='A')?'A'-10:'0');

  if(tmp2>=16)
   return NULL;

  pbBuf[i] = (tmp1*16+tmp2);
 }

 return pbBuf;
}

main.cpp文件

#include <iostream>
#include <string>
#include <stdio.h>

#include "Encrypt.h"

int main(int argc,char *argv[]) 
{
 int size = 0;

 char source[] = "chenli";
 char pass[] = "123456";
 char *result1 = NULL;
 char *result2 = NULL;
 
 result1 = Encrypt(source, pass);

 printf("result1=%s/n", result1);

 result2 = Decrypt(result1, pass);

 printf("result2=%s/n", result2);

 delete []result1;
 delete []result2;

 return 0; 
}


2. ulib


https://code.google.com/p/ulib/


  • Core Items
    1. bfilter.{h,c}: the Bloom filter
    2. bitmap.{h,c}: generic bitmap
    3. crypt_aes.{h,c}: the AES crypt
    4. crypt_md5.{h,c}: the MD5 algorithm
    5. crypt_rc4.{h,c}: the RC4 crypt
    6. crypt_sha1.{h,c}: the SHA1 algorithm
    7. crypt_sha256.{h,c}: the SHA256 algorithm
    8. hash_open.h: C++ containers for the open addressing hashmap and hashset
    9. hash_open_prot.h: prototypes for the open addressing hashmap and hashset
    10. hash_chain.h: C++ container for the chain hashmap
    11. hash_chain_prot.h: prototype for the chain hashmap
    12. hash_func.{h,c}: hash functions
    13. heap_prot.h: generic heap prototype
    14. list.h: doubly linked list, can be used to implement queue and stack
    15. math_bit.h: bit operations
    16. math_bn.{h,c}: big number arithmetics
    17. math_comb.{h,c}: combinatorics enumerator
    18. math_factorial.{h,c}: factorial approximations
    19. math_gcd.{h,c}: Euclidean and the Extended Euclidean GCD algorithms
    20. math_lcm.{h,c}: the least common multiple
    21. math_rand_prot.h: pseudo-random number generators, mix functions, and etc
    22. math_rng_gamma.{h,c}: gamma distribution RNG
    23. math_rng_normal.{h,c}: normal distribution RNG
    24. math_rng_zipf.{h,c}: Zipf distribution RNG
    25. search_line.{h,c}: binary search for the text lines
    26. sort_heap_prot.h: prototype for the heapsort
    27. sort_list.{h,c}: list sort
    28. sort_median_prot.h: prototype for the median algorithm
    29. str_util.{h,c}: parallel/supplementary string utilities
    30. tree.{h,c}: various binary search trees
    31. tree_util.{h,c}: tree utilities
    32. ulib_ver.{h,c}: ulib version
    33. util_algo.h: basic algorithms
    34. util_console.{h,c}: command-line parser
    35. util_hexdump: the hexdump utilities
    36. util_log.h: logging utilities
    37. util_timer.h: high-precision timer
  • Parallel Items
    1. hash_chain_r.h: concurrent chain hashmap
    2. hash_multi_r.h: concurrent multiple hashmap
    3. mr_dataset.{h,cpp}: the MapReduce data abstraction
    4. mr_engine.h: the MapReduce engine
    5. mr_interm.h: the MapReduce intermediate storage abstraction
    6. os_atomic_intel64.h: atomic operations for the x86_64
    7. os_rdtsc.h: the Intel rdtsc instruction
    8. os_regionlock.h: region locks
    9. os_spinlock.h: various spinlocks for the x86_64
    10. os_thread.{h,cpp}: thread wrapper class
    11. os_typelock.h: typed locks for C++

三少GG
关注
专栏目录
用C++加密解密（RC4对称密码算法）
wangz76的博客
09-28 2863
/* RC4加密解密 流密码是使用较短的一串数字（密钥）来生成无限长的伪随机密钥流，然后将密钥流和明文异或， 解密就是将密钥流和密文进行异或。 程序摘自《Windows C/C++加密解密实战》，有点点修改。 */ #include <iostream> #include<stdio.h> #define MAX_CHAR_LEN 100000 void producekeystream(int textlength,unsigned char key[],int keyle
RC4加密算法C++实现
04-15
C++实现RC4加密算法，以2进制形式输出密钥流和密文到控制台并将结果记录至.txt文件。 用到KSA PRGA算法，最后用异或进行加密/解密。
RC4加密算法在C++中的实现
热门推荐
小蜜蜂的专栏
02-14 1万+
在一些场合，常需要用到一些简单的加密算法，这里的RC4就可以说是最简单的一种。只要设置一个足够强的密码，就可以适用于一些非常简单的场合了。我是用来加密HTTP传送的数据的。RC4函数（加密/解密）    其实，RC4只有加密，将密文再加密一次，就是解密了。GetKey函数   随机字符串产生器，呵呵，为了方便，大多数加密算法都有一个随机密码产生器，我也就附带一个了。ByteToHex函
RC4文件加密解密的C++实现
03-15
C++源码实现RC4的文件加密、解密功能，本程序可在VC++ 6.0环境下直接编译成功。在窗体中选择需要加密的文件，随便输入你自己想要的加密密钥，点击“文件加密”功能，即可快速实现基于RC4算法的文件加密程序。保存的文件后缀为RC4，如果选择打开的是RC4文件，则程序自动加载解密模块，输入密钥可解密文件。 运行环境：Windows/Visual C/C++
RC4加密算法C语言/C++实现
function_template的博客
04-22 6719
运行环境 VC++ 6.0 #include <iostream> #include <string.h> const int max=256; const int BOX_LEN=256; //把字节码转为十六进制码，一个字节两个十六进制，内部为字符串分配空间 char* ByteToHex(const unsigned char* Byte, const int ...
JS实现的RC4加密算法示例
12-10
本文实例讲述了JS实现的RC4加密算法。分享给大家供大家参考，具体如下： RC4是一种简单的对称加密算法，在文本加密，通信加密等场景应用非常广泛。 在Web中可以用来对本地存储数据进行加密，比如存储cookie中的...
易语言RC4加密解密源码
06-06
RC4是一种广泛使用的流式加密算法，由Ron Rivest在1987年设计，由于其简单高效的特点，被应用于很多软件和网络通信中。在易语言中实现RC4加密解密，可以帮助开发者保护数据安全，防止信息被未经授权的用户访问。 ...
RC4JS:带有js的RC4加密
07-03
RC4JS 是一个基于 JavaScript 实现的 RC4 加密算法库。RC4，全称 Rivest Cipher 4，是由 Ron Rivest 在1987年设计的一种流密码算法，广泛应用于网络通信的安全加密。它的主要特点是算法简单，易于实现，但同时也因为...
php实现的rc4加密解密类定义与用法示例
10-18
RC4是一种流密码算法，广泛用于实现数据加密。...不过，随着加密技术的发展，新的加密算法不断涌现，而RC4由于安全性的不足，其使用场景正在逐渐减少。因此，在实际应用中应当审慎使用RC4，或转向更为安全的算法。
java实现的RC4加密解密算法示例
08-30
"java实现的RC4加密解密算法示例" RC4加密解密算法是Symmetric-key block cipher的一种，使用同一个密钥进行加密和解密。java实现的RC4加密解密算法可以通过以下步骤实现： 1. 初始化数组：创建一个大小为256的...
自己用C++实现的RC4算法
04-08
自己根据密码课本上写的，供大家参考，要是哪里写得不对的话麻烦大家指正，O(∩_∩)O谢谢
RC4加解密代码实现 c++
04-17
rc4是个比较简单而实用的加密算法，其实现思路算然简单，但代码自己写还是有些小长，这里就附上自己的代码。不需要积分，赠人玫瑰，手留余香。
rc4加密解密算法
02-21
rc4的c++算法实现，包含加密解密过程的完整代码，简单的实现了rc4
arc4加密算法c++实现
11-24
arc4加密算法c++，只要设置一个足够强的密码，就可以适用于一些非常简单的场合了。我是用来加密HTTP传送的数据的。 RC4函数（加密/解密） 其实，RC4只有加密，将密文再加密一次，就是解密了。
rc4加密算法实现
05-31
实现RC4算法，实现控制台对所有文件加解密。 附赠文档一份。
C++实现RC4加密算法
Lengxinlin的博客
04-17 3467
主函数 实现RC4的字符串加密与文件加密算法 // streamcipher.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include "RC4.h" #include "LSFR.h" #include <iostream> //cout,cin, endl #include <cstdio> //C 标准库 strlen #include <string> //std::string #include<std
【C++】RC4加密算法
Hemingway_Hoo的博客
10-17 1569
RC4是一种对称加密算法，特点是算法简单，运行速度快，而且密钥长度是可变的，可变范围为1-256字节(8-2048比特)。 本博文中的内容是基于Eric Young提供的公共封装类实现的，与网上能找到的RC4.h类似，如果需要详细了解RC4的，移步-》传送门 namespace { void RC4_Encrypt(const unsigned char* cleartext, int length, const std::string& key, unsigned char* ciphe
RC4加密算法在C++中的实现(转)
redpetallsg的专栏
03-10 7984
在一些场合，常需要用到一些简单的加密算法，这里的RC4就可以说是最简单的一种。只要设置一个足够强的密码，就可以适用于一些非常简单的场合了。我是用来加密HTTP传送的数据的。RC4函数（加密/解密）    其实，RC4只有加密，将密文再加密一次，就是解密了。GetKey函数   随机字符串产生器，呵呵，为了方便，大多数加密算法都有一个随机密码产生器，我也就附带一个了。ByteToHex函
理解RC4加密算法：C语言实现详解
"RC4加密解密算法C语言实现代码示例" RC4加密算法，全称为Ron's Code 4，是由Ron Rivest在1987年设计的一种流密码算法。它是一种广泛应用的轻量级加密算法，常用于网络传输数据的安全保护，如SSL/TLS协议中。RC4...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值