数据加密（2）

最新推荐文章于 2024-09-06 16:15:59 发布
最新推荐文章于 2024-09-06 16:15:59 发布
阅读量333 收藏
点赞数
分类专栏： 网络安全技术入门 文章标签： 信息安全 网络安全 加密 DES 密码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ney77/article/details/77802081
版权

总有一天 你坚持的东西 会反过来拥抱你。

--------------------------------------------------------------------------------

对称密码技术

        对称密码技术的基本特征是加密密钥与解密密钥相同，或者两者之间互相容易推导出来。

        典型的对称密码技术主要包括DES、AES、IDEA、Blowfish、RC系列、CAST等。

        对称分组密码的安全性主要取决于以下参数：

                * 分组长度   * 密钥长度  * 迭代轮数  * 密钥扩展算法  * 轮函数 

                  （ 参数越复杂，密文破译难度越高）

一、DES

                  DES加密 / 解密过程中，将置换与代换等经典操作相结合。

                  密钥通常表示为64位的数，但每个第8位均用作奇偶校验，可以忽略，故密钥长度为56位。

                  密钥可以是任意的56为的数，且可在任意时候改变。

        加密过程：

                 1. 总过程：

                                    a. 对明文分组进行一次初始置换。

                                    b. 对所得结果进行16轮加密操作。

                                    c. 对所得结果进行逆初始置换，获得密文分组。

                 2. 每轮加密操作：

                                    a. 将64位的数据分为各32位两部分。

                                    b. 将其中一部分与该轮子密钥作为一个复杂函数的输入。

                                    c. 将所得结果与另一部分执行异或操作。

                 3. 子密钥生成过程：

                                    a. 对初始密钥进行一次置换。

                                    b. 对所得结果进行密钥扩展（循环左移和二次置换）。

                                    c. 生成每轮使用的48位子密钥。

                 4. 每轮操作的复杂函数：包括8个预先确定的非线性代换（称为 S 盒子），通过它将6位的输入代换为4位的输出。DES的安全性主要依赖于S盒子。


        DES的解密过程与加密过程基本相同，不同之处在于使用密钥的次序为逆序。

        DES算法最初是针对硬件实现而设计的，没有高效的软件实现造成其运算速度较慢。随着技术进步带来的计算能力的显著提高，DES及后继算法的安全性受到了严峻的挑战。2001年以后，AES开始在美国政府的信息保护中得到广泛应用，并逐步取代DES作为首选的加密算法。至今，AES已成为流行的对称加密算法之一。


附：算法原理不难，实现起来挺复杂，先马克别人的代码，好好研究下。

#include "pch.h"
#include "misc.h"
#include "des.h"

NAMESPACE_BEGIN(CryptoPP)

/* Tables defined in the Data Encryption Standard documents
 * Three of these tables, the initial permutation, the final
 * permutation and the expansion operator, are regular enough that
 * for speed, we hard-code them. They're here for reference only.
 * Also, the S and P boxes are used by a separate program, gensp.c,
 * to build the combined SP box, Spbox[]. They're also here just
 * for reference.
 */
#ifdef notdef
/* initial permutation IP */
static byte ip[] = {
 58, 50, 42, 34, 26, 18, 10, 2,
 60, 52, 44, 36, 28, 20, 12, 4,
 62, 54, 46, 38, 30, 22, 14, 6,
 64, 56, 48, 40, 32, 24, 16, 8,
 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
};

/* final permutation IP^-1 */
static byte fp[] = {
 40, 8, 48, 16, 56, 24, 64, 32,
 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
};
/* expansion operation matrix */
static byte ei[] = {
 32, 1, 2, 3, 4, 5,
 4, 5, 6, 7, 8, 9,
 8, 9, 10, 11, 12, 13,
 12, 13, 14, 15, 16, 17,
 16, 17, 18, 19, 20, 21,
 20, 21, 22, 23, 24, 25,
 24, 25, 26, 27, 28, 29,
 28, 29, 30, 31, 32, 1
};
/* The (in)famous S-boxes */
static byte sbox[8][64] = {
 /* 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
};

/* 32-bit permutation function P used on the output of the S-boxes */
static byte p32i[] = {
 16, 7, 20, 21,
 29, 12, 28, 17,
 1, 15, 23, 26,
 5, 18, 31, 10,
 2, 8, 24, 14,
 32, 27, 3, 9,
 19, 13, 30, 6,
 22, 11, 4, 25
};
#endif

/* permuted choice table (key) */
static const byte pc1[] = {
 57, 49, 41, 33, 25, 17, 9,
 1, 58, 50, 42, 34, 26, 18,
 10, 2, 59, 51, 43, 35, 27,
 19, 11, 3, 60, 52, 44, 36,

 63, 55, 47, 39, 31, 23, 15,
 7, 62, 54, 46, 38, 30, 22,
 14, 6, 61, 53, 45, 37, 29,
 21, 13, 5, 28, 20, 12, 4
};

/* number left rotations of pc1 */
static const byte totrot[] = {
 1,2,4,6,8,10,12,14,15,17,19,21,23,25,27,28
};

/* permuted choice key (table) */
static const byte pc2[] = {
 14, 17, 11, 24, 1, 5,
 3, 28, 15, 6, 21, 10,
 23, 19, 12, 4, 26, 8,
 16, 7, 27, 20, 13, 2,
 41, 52, 31, 37, 47, 55,
 30, 40, 51, 45, 33, 48,
 44, 49, 39, 56, 34, 53,
 46, 42, 50, 36, 29, 32
};

/* End of DES-defined tables */

/* bit 0 is left-most in byte */
static const int bytebit[] = {
 0200,0100,040,020,010,04,02,01
};

/* Set key (initialize key schedule array) */
DES::DES(const byte *key, CipherDir dir)
 : k(32)
{
 SecByteBlock buffer(56+56+8);
 byte *const pc1m=buffer; /* place to modify pc1 into */
 byte *const pcr=pc1m+56; /* place to rotate pc1 into */
 byte *const ks=pcr+56;
 register int i,j,l;
 int m;

 for (j=0; j<56; j++) { /* convert pc1 to bits of key */
 l=pc1[j]-1; /* integer bit location */
 m = l & 07; /* find bit */
 pc1m[j]=(key[l>>3] & /* find which key byte l is in */
 bytebit[m]) /* and which bit of that byte */
 ? 1 : 0; /* and store 1-bit result */
 }
 for (i=0; i<16; i++) { /* key chunk for each iteration */
 memset(ks,0,8); /* Clear key schedule */
 for (j=0; j<56; j++) /* rotate pc1 the right amount */
 pcr[j] = pc1m[(l=j+totrot[i])<(j<28? 28 : 56) ? l: l-28];
 /* rotate left and right halves independently */
 for (j=0; j<48; j++){ /* select bits individually */
 /* check bit that goes to ks[j] */
 if (pcr[pc2[j]-1]){
 /* mask it in if it's there */
 l= j % 6;
 ks[j/6] |= bytebit[l] >> 2;
 }
 }
 /* Now convert to odd/even interleaved form for use in F */
 k[2*i] = ((word32)ks[0] << 24)
 | ((word32)ks[2] << 16)
 | ((word32)ks[4] << 8)
 | ((word32)ks[6]);
 k[2*i+1] = ((word32)ks[1] << 24)
 | ((word32)ks[3] << 16)
 | ((word32)ks[5] << 8)
 | ((word32)ks[7]);
 }

 if (dir==DECRYPTION) // reverse key schedule order
 for (i=0; i<16; i+=2)
 {
 std::swap(k[i], k[32-2-i]);
 std::swap(k[i+1], k[32-1-i]);
 }
}
/* End of C code common to both versions */

/* C code only in portable version */

// Richard Outerbridge's initial permutation algorithm
/*
inline void IPERM(word32 &left, word32 &right)
{
 word32 work;

 work = ((left >> 4) ^ right) & 0x0f0f0f0f;
 right ^= work;
 left ^= work << 4;
 work = ((left >> 16) ^ right) & 0xffff;
 right ^= work;
 left ^= work << 16;
 work = ((right >> 2) ^ left) & 0x33333333;
 left ^= work;
 right ^= (work << 2);
 work = ((right >> 8) ^ left) & 0xff00ff;
 left ^= work;
 right ^= (work << 8);
 right = rotl(right, 1);
 work = (left ^ right) & 0xaaaaaaaa;
 left ^= work;
 right ^= work;
 left = rotl(left, 1);
}
inline void FPERM(word32 &left, word32 &right)
{
 word32 work;

 right = rotr(right, 1);
 work = (left ^ right) & 0xaaaaaaaa;
 left ^= work;
 right ^= work;
 left = rotr(left, 1);
 work = ((left >> 8) ^ right) & 0xff00ff;
 right ^= work;
 left ^= work << 8;
 work = ((left >> 2) ^ right) & 0x33333333;
 right ^= work;
 left ^= work << 2;
 work = ((right >> 16) ^ left) & 0xffff;
 left ^= work;
 right ^= work << 16;
 work = ((right >> 4) ^ left) & 0x0f0f0f0f;
 left ^= work;
 right ^= work << 4;
}
*/

// Wei Dai's modification to Richard Outerbridge's initial permutation 
// algorithm, this one is faster if you have access to rotate instructions 
// (like in MSVC)
inline void IPERM(word32 &left, word32 &right)
{
 word32 work;

 right = rotl(right, 4U);
 work = (left ^ right) & 0xf0f0f0f0;
 left ^= work;
 right = rotr(right^work, 20U);
 work = (left ^ right) & 0xffff0000;
 left ^= work;
 right = rotr(right^work, 18U);
 work = (left ^ right) & 0x33333333;
 left ^= work;
 right = rotr(right^work, 6U);
 work = (left ^ right) & 0x00ff00ff;
 left ^= work;
 right = rotl(right^work, 9U);
 work = (left ^ right) & 0xaaaaaaaa;
 left = rotl(left^work, 1U);
 right ^= work;
}

inline void FPERM(word32 &left, word32 &right)
{
 word32 work;

 right = rotr(right, 1U);
 work = (left ^ right) & 0xaaaaaaaa;
 right ^= work;
 left = rotr(left^work, 9U);
 work = (left ^ right) & 0x00ff00ff;
 right ^= work;
 left = rotl(left^work, 6U);
 work = (left ^ right) & 0x33333333;
 right ^= work;
 left = rotl(left^work, 18U);
 work = (left ^ right) & 0xffff0000;
 right ^= work;
 left = rotl(left^work, 20U);
 work = (left ^ right) & 0xf0f0f0f0;
 right ^= work;
 left = rotr(left^work, 4U);
}

// Encrypt or decrypt a block of data in ECB mode
void DES::ProcessBlock(const byte *inBlock, byte * outBlock) const
{
 word32 l,r,work;

#ifdef IS_LITTLE_ENDIAN
 l = byteReverse(*(word32 *)inBlock);
 r = byteReverse(*(word32 *)(inBlock+4));
#else
 l = *(word32 *)inBlock;
 r = *(word32 *)(inBlock+4);
#endif

 IPERM(l,r);

 const word32 *kptr=k;

 for (unsigned i=0; i<8; i++)
 {
 work = rotr(r, 4U) ^ kptr[4*i+0];
 l ^= Spbox[6][(work) & 0x3f]
 ^ Spbox[4][(work >> 8) & 0x3f]
 ^ Spbox[2][(work >> 16) & 0x3f]
 ^ Spbox[0][(work >> 24) & 0x3f];
 work = r ^ kptr[4*i+1];
 l ^= Spbox[7][(work) & 0x3f]
 ^ Spbox[5][(work >> 8) & 0x3f]
 ^ Spbox[3][(work >> 16) & 0x3f]
 ^ Spbox[1][(work >> 24) & 0x3f];

 work = rotr(l, 4U) ^ kptr[4*i+2];
 r ^= Spbox[6][(work) & 0x3f]
 ^ Spbox[4][(work >> 8) & 0x3f]
 ^ Spbox[2][(work >> 16) & 0x3f]
 ^ Spbox[0][(work >> 24) & 0x3f];
 work = l ^ kptr[4*i+3];
 r ^= Spbox[7][(work) & 0x3f]
 ^ Spbox[5][(work >> 8) & 0x3f]
 ^ Spbox[3][(work >> 16) & 0x3f]
 ^ Spbox[1][(work >> 24) & 0x3f];
 }

 FPERM(l,r);

#ifdef IS_LITTLE_ENDIAN
 *(word32 *)outBlock = byteReverse(r);
 *(word32 *)(outBlock+4) = byteReverse(l);
#else
 *(word32 *)outBlock = r;
 *(word32 *)(outBlock+4) = l;
#endif
}

void DES_EDE_Encryption::ProcessBlock(byte *inoutBlock) const
{
 e.ProcessBlock(inoutBlock);
 d.ProcessBlock(inoutBlock);
 e.ProcessBlock(inoutBlock);
}

void DES_EDE_Encryption::ProcessBlock(const byte *inBlock, byte *outBlock) const
{
 e.ProcessBlock(inBlock, outBlock);
 d.ProcessBlock(outBlock);
 e.ProcessBlock(outBlock);
}

void DES_EDE_Decryption::ProcessBlock(byte *inoutBlock) const
{
 d.ProcessBlock(inoutBlock);
 e.ProcessBlock(inoutBlock);
 d.ProcessBlock(inoutBlock);
}

void DES_EDE_Decryption::ProcessBlock(const byte *inBlock, byte *outBlock) const
{
 d.ProcessBlock(inBlock, outBlock);
 e.ProcessBlock(outBlock);
 d.ProcessBlock(outBlock);
}

void TripleDES_Encryption::ProcessBlock(byte *inoutBlock) const
{
 e1.ProcessBlock(inoutBlock);
 d.ProcessBlock(inoutBlock);
 e2.ProcessBlock(inoutBlock);
}

void TripleDES_Encryption::ProcessBlock(const byte *inBlock, byte *outBlock) const
{
 e1.ProcessBlock(inBlock, outBlock);
 d.ProcessBlock(outBlock);
 e2.ProcessBlock(outBlock);
}

void TripleDES_Decryption::ProcessBlock(byte *inoutBlock) const
{
 d1.ProcessBlock(inoutBlock);
 e.ProcessBlock(inoutBlock);
 d2.ProcessBlock(inoutBlock);
}

void TripleDES_Decryption::ProcessBlock(const byte *inBlock, byte *outBlock) const
{
 d1.ProcessBlock(inBlock, outBlock);
 e.ProcessBlock(outBlock);
 d2.ProcessBlock(outBlock);
}

-----------------------------------------

代码源于网络
-----------------------------------------

                                    

ney77
关注
专栏目录
MD5_64位加密
weixin_30672019的博客
06-13 4230
一、在做项目的时候，经常会遇到上传的文件和保存的数据需要加密，我们最经常用到的就是MD5加密。 二、MD5加密代码展示 1 public class EncryptMD5 2 { 3 /// <summary> 4 /// 加密 5 /// </summary> 6 ...
DES加密算法原理
小王的博客
05-20 7808
DES的每个分组是64位，既明文和密钥都是64位（密钥实际用56位，每字节第8位为校验）。这个算法的核心是Feistel密码，由于其设计的巧妙，加密解密都用一个函数，具体原理请查阅其他资料。DES的流程基本是执行16轮下面的运算： 1 初始变换Initial Permutation 2 右边32位f函数 2.1 E置换 2.2 与轮密钥XOR 2.3 S盒替换 2.4 P置换 2.5
密码学入门：几种简单的密码
热门推荐
听雪楼主
02-12 4万+
密码学入门：几种简单的密码一.维吉尼亚密码      维吉尼亚密码引入了“密钥”的概念，即根据密钥来决定用哪一行的密表来进行替换，以此来对抗字频统计。假如以上面第一行代表明文字母，左面第一列代表密钥字母，对如下明文加密：TO BE OR NOT TO BE THAT IS THE QUESTION      当选定RELATIONS作为密钥时，加密过程是：明文一个字母为T，第一个密钥字母为R，因此...
常见的加密算法总结
weixin_43402687的博客
08-23 2692
常见的加密算法总结 前段时间对常见加密算法进行了整理，分享给大家。 对称加密 对称加密用同一个密钥对明文进行加解密，常见的有DES，3DES，AES等 一.DES算法 数据分组（64位）用秘钥（64位，其中56位有效，8位校验）行加密； 1，根据用户输入取得一个64位秘钥，然后进行等分、移位、选取和迭代形成一套16个加密秘钥，分别提供每轮运算使用； 2，对64位明文分组M进行操作，M经过初期置换IP，置换为m0，将m0分为左右各32位长，并进行16轮相同的运算（迭代），每轮运算都和相应的秘钥结合； 3
加密算法-BASE64
MonKee的博客
02-28 1408
基本的单向加密算法： 1.BASE64 ——严格地说，属于编码格式，而非加密算法 2.MD5——Message Digest algorithm 5，信息摘要算法 3.SHA——Secure Hash Algorithm，安全散列算法 4.HMAC——Hash Message Authentication Code，散列消息鉴别码         MD5、SHA、H
64位DES算法及其测速与原理验证
qq_45832614的博客
04-27 1065
64位DES算法及其测速与原理验证 此为博主在学习密码学课程时编写的作业，有关DES算法及其效果验证。 64位DES算法 基本原理 1 输入输出参数 key: 64bit的密钥 message：64bit的需要加密的信息，即明文 cipher：64bit的已经被加密过的信息，即密文 2 流程 2.1 子密钥产生 ​ DES算法由64位密钥产生16轮的48位子密钥。在每一轮的迭代过程中，使用不同的子密钥。 a、把密钥的奇偶校验位忽略不参与计算，即每个字节的第8位，将64位密钥降至56位，然后根据选择置.
Beyond Compare4.2.4 64位OS最新密钥
最新发布
u013758456的专栏
09-06 647
##@@@版权声明：本文为博主原创文章，转载请附上原文出处链接和本声明。
用于商用微处理器的快速位收集、位分散和位置换指令（一）
Arist.
04-07 867
文章目录Fast Bit Gather, Bit Scatter and Bit Permutation Instructions for Commodity MicroprocessorsY edidya Hilewitz & Ruby B. LeeAbstractKeywords1. Introduction2. Advanced Bit Manipulation Operations2.1 Bit Gather or Parallel Extract: pex2.2 Bit Scatter o
Android数据加密之Des加密
01-20
 •Android数据加密之Rsa加密  •Android数据加密之Aes加密  •Android数据加密之Des加密  •Android数据加密之MD5加密  •Android数据加密之Base64编码算法  •Android数据加密之SHA安全散列算法  DES加密...
MySQL数据库对敏感数据加密及解密的实现方式
09-08
在大数据时代，数据是企业宝贵的资产，而数据加密能有效防止数据泄露。本文主要探讨了两种在MySQL数据库中实现敏感数据加密的方法：MySQL内置的加密函数和Python的base64加密。 首先，准备工作涉及创建三个数据表：...
国产加密SM3算法java实现长度64位
09-02
按照国密文档通过Java实现SM2密码算法加密、签名验签，SM3密码杂凑算法 经过详尽的测试过后没有发现问题，但建议大家在使用时仍进行验证。
64位加密狗驱动
10-09
完全满足64位驱动要求经过测试可以正常运行
64位加密方法
01-15
这是个解决方案，可以运行的， 支持64位加密， 也可以解密 经过后期的优化中文特殊字符都可以加密 亚马逊的上网站也我用此套方法，不过在项目中的密钥不同，可以安装一定是算法生存错，希望对大家有帮助。此方法在项目中已经使用。
64位小规模RSA加密算法
05-27
鉴于公钥产生的随机性，通常情况下，对于小于9999999的数都能进行正确的加密解密，对于大于的部分可能会加密失败。原因在于只支持小规模的加密，超过一些范围时就会产生数据溢出。此算法仅供学习参考，谢绝其它用途。
SQL Server数据加密功能解析
12-14
数据加密是数据库被破解、物理介质被盗、备份被窃取的后一道防线，数据加密，一方面解决数据被窃取安全问题，另一方面有关法律要求强制加密数据。SQL Server 的数据加密相较于其他数据库，功能相对完善，加密方法较...
数据加密模块代码和类图.zip
06-05
某软件公司要开发一个数据加密模块，可以对字符串进行加密。最简单的加密算法通过对字母进行移位来实现，同时提供了稍复杂的逆向输出加密，还提供了更加高级的求模加密。用户先使用简单的加密算法对字符串进行加密，...
Android数据加密之Rsa加密
01-05
 •Android数据加密之Rsa加密  •Android数据加密之Aes加密  •Android数据加密之Des加密  •Android数据加密之MD5加密  •Android数据加密之Base64编码算法  •Android数据加密之SHA安全散列算法  什么是Rsa...
几种常用加密手段的加密与解密
qq_36571506的博客
07-05 2万+
网络中传输敏感信息的时候通常会对字符串做加密解密处理1.Base64位加密（可加密解密）    最简单的加密方式，没有密钥，这种方式只要让别人拿到你的密文，就可以直接解密，只能用来迷惑，一般情况下不单独使用，因为真的并没有什么卵用~可以和其他加密方式混合起来，作为一层外部包装。import base64data = "abc"#加密m = Base64.encodestring(data)prin...
AES算法：高级数据加密标准详解
"AES算法-数据加密技术" 在信息技术领域，数据加密技术是保障信息安全的重要手段，而AES（Advanced Encryption Standard）算法则是其中的关键部分。AES由美国国家标准技术研究所（NIST）在1997年发起征集，旨在寻找...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值