3XXTEA加密算法的各种程序实现整理

三种加密算法.txt第一次笑是因为遇见你，第一次哭是因为你不在，第一次笑着流泪是因为不能拥有你。

//DES加密 void DES_Password( { //这里我用UTF7Encoding.UTF7是因为我是中国人,我要加密中国字,所以用这个.没问题的. byte[] buffer =System.Text.UTF7Encoding.UTF7.GetBytes(textBox1.Text; //定义一个DES相关类的一个对象 TripleDESCryptoServiceProvider des=new TripleDESCryptoServiceProvider(; //获得密钥及加解密所必需的随机变量 //大量参数确定了密文的结果。

为了解密密文，必须使用相同的算法和相同的参数。

//因该每次有意识的改变两个参数是密钥和向量（IV），密钥是机密部分， //这是确保数据完整性的重要条件：IV则确保密文快的随机性和独特性。

//如果每次都是使用相同的密钥加密数据，将总是得到相同的密文。

//des.GenerateKey(;//能随机产生强密钥 //des.GenerateIV(;//能随机产生向量 //-------------------------------加密 //将明文字节流的形式数据利用des对象关联的密钥进行加密，并返回暗文放至en中 byte[]en=des.CreateEncryptor(.TransformFinalBlock(buffer,0,buffer.Length; //将字节流的暗文转换为字符流的形式放至字符串enstr中 string enstr=Convert.ToBase64String(en; textBox2.Text=enstr; //-------------------------------解密 //将暗文字符串转换为字节流放入缓冲区中 buffer = Convert.FromBase64String(enstr; //将暗文字节流与des对象关联进行解密，将解密后的明文放入ds缓冲区中 byte[]de=des.CreateDecryptor(.TransformFinalBlock(buffer,0,buffer.Length; //将明文字节流转换为字符串的形式 string destr=System.Text.UTF7Encoding.UTF7.GetString(de; textBox3.Text=destr; } //Rijndael加密算法 void RijndaelPassword( { byte[] buffer=ASCIIEncoding.ASCII.GetBytes(textBox1.Text; RijndaelManaged des=new RijndaelManaged(; des.GenerateKey(; des.GenerateIV(; byte[]en=des.CreateEncryptor(.TransformFinalBlock(buffer,0,buffer.Length; stringenstr=Convert.ToBase64String(en; textBox2.Text=enstr; buffer =Convert.FromBase64String(enstr; byte[]ds=des.CreateDecryptor(.TransformFinalBlock(buffer,0,buffer.Length; stringdsstr=ASCIIEncoding.ASCII.GetString(ds; textBox3.Text=dsstr; } //RC2加密算法 void RC2_Password( { byte[] buffer =ASCIIEncoding.ASCII.GetBytes(textBox1.Text;RC2CryptoServiceProvider des=new RC2CryptoServiceProvider (; des.GenerateKey(; des.GenerateIV(; byte[]en=des.CreateEncryptor(.TransformFinalBlock(buffer,0,buffer.Length; stringenstr=Convert.ToBase64String(en; textBox2.Text=enstr; buffer =Convert.FromBase64String(enstr; byte[]ds=des.CreateDecryptor(.TransformFinalBlock(buffer,0,buffer.Length; string dsstr=ASCIIEncoding.ASCII.GetString(ds; textBox3.Text=dsstr; } //Hash void Hash_Password( { MD5 md5 = new MD5CryptoServiceProvider(; byte[] result = puteHash(System.Text.ASCIIEncoding.ASCII.GetBytes(this.textBox1.Text; StringBuilder Msg=new StringBuilder(; foreach (byte b in resultMsg.AppendFormat("{0:x}",b;MessageBox.Show("AppendFormat\t\t"+Msg.ToString(+"\n\nConvert.ToBase64String\t\ t"+Convert.ToBase64String(result+"\n\nASCII.GetString\t\t"+System.Text.ASCIIEncodi ng.ASCII.GetString(result; } private void button1_Click(object sender,System.EventArgs e { this.DES_Password(; } }。

引用XXTEA文章说明资料：“... XXTEA 算法很安全，而且非常快速，非常适合应用于 Web 开发中。

但目前似乎很少有人将该算法用于实际开发中。

甚至国内尚无介绍该算法的文章（至少在 Google 上搜索不到这方面的中文文章，关于密码学算法的书中也未见提及）。

我在 Google 上搜索到了几个国外的 XXTEA 算法的实现（见参考文献）...”。

JavaScript实现（下载文件）//=================================;/* xxtea.js** Author: Ma Bingyao <andot@>* Copyright: * Version: 1.2* LastModified: 2006-05-02* This library is free. You can redistribute it and/or modify it.* /?p=128*/function long2str(v, w) {var vl = v.length;var sl = v[vl - 1] & 0xffffffff;for (var i = 0; i < vl; i++){v[i] = String.fromCharCode(v[i] & 0xff,v[i] >>> 8 & 0xff,v[i] >>> 16 & 0xff,v[i] >>> 24 & 0xff);}if (w) {return v.join('').substring(0, sl);}else {return v.join('');}}function str2long(s, w) {var len = s.length;var v = [];for (var i = 0; i < len; i += 4){v[i >> 2] = s.charCodeAt(i)| s.charCodeAt(i + 1) << 8| s.charCodeAt(i + 2) << 16| s.charCodeAt(i + 3) << 24;}if (w) {v[v.length] = len;}return v;}function xxtea_encrypt(str, key) {if (str == "") {return "";}var v = str2long(str, true);var k = str2long(key, false);var n = v.length - 1;var z = v[n], y = v[0], delta = 0x9E3779B9;var mx, e, q = Math.floor(6 + 52 / (n + 1)), sum = 0;while (q-- > 0) {sum = sum + delta & 0xffffffff;e = sum >>> 2 & 3;for (var p = 0; p < n; p++) {y = v[p + 1];mx = (z >>> 5 ^ y << 2) + (y >>> 3 ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z); z = v[p] = v[p] + mx & 0xffffffff;}y = v[0];mx = (z >>> 5 ^ y << 2) + (y >>> 3 ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z); z = v[n] = v[n] + mx & 0xffffffff;}return long2str(v, false);}function xxtea_decrypt(str, key) {if (str == "") {return "";}var v = str2long(str, false);var k = str2long(key, false);var n = v.length - 1;var z = v[n - 1], y = v[0], delta = 0x9E3779B9;var mx, e, q = Math.floor(6 + 52 / (n + 1)), sum = q * delta & 0xffffffff; while (sum != 0) {e = sum >>> 2 & 3;for (var p = n; p > 0; p--) {z = v[p - 1];mx = (z >>> 5 ^ y << 2) + (y >>> 3 ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z);y = v[p] = v[p] - mx & 0xffffffff;}z = v[n];mx = (z >>> 5 ^ y << 2) + (y >>> 3 ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z);y = v[0] = v[0] - mx & 0xffffffff;sum = sum - delta & 0xffffffff;}return long2str(v, true);}Java实现（下载文件）//=================================;/* xxtea.java** Author: Ma Bingyao < andot@ >* Copyright: * Version: 1.0* LastModified: 2006-05-11* This library is free. You can redistribute it and/or modify it.* /?p=169*/public class xxtea {/*** Encrypt data with key.** @param data* @param key* @return*/public static byte [] encrypt ( byte [] data , byte [] key ) {if ( data . length == 0 ) {return data ;}return toByteArray ( encrypt ( toIntArray ( data , true ) , toIntArray ( key , false )) , false ) ;}/*** Decrypt data with key.** @param data* @param key* @return*/public static byte [] decrypt ( byte [] data , byte [] key ) {if ( data . length == 0 ) {return data ;}return toByteArray ( decrypt ( toIntArray ( data , false ) , toIntArray ( key , false )) , true ) ;}/*** Encrypt data with key.** @param v* @param k* @return*/public static int [] encrypt ( int [] v , int [] k ) {int n = v . length - 1 ;if ( n < 1 ) {return v ;}if ( k . length < 4 ) {int [] key = new int [ 4 ] ;System . arraycopy ( k , 0 , key , 0 , k . length ) ;k = key ;}int z = v [ n ] , y = v [ 0 ] , delta = 0x9E3779B9 , sum = 0 , e ;int p , q = 6 + 52 / ( n + 1 ) ;while ( q -- > 0 ) {sum = sum + delta ;e = sum >>> 2 & 3 ;for ( p = 0 ; p < n ; p ++ ) {y = v [ p + 1 ] ;z = v [ p ] += ( z >>> 5 ^ y << 2 ) + ( y >>> 3 ^ z << 4 ) ^ ( sum ^ y ) + ( k [ p & 3 ^ e ] ^ z ) ;}y = v [ 0 ] ;z = v [ n ] += ( z >>> 5 ^ y << 2 ) + ( y >>> 3 ^ z << 4 ) ^ ( sum ^ y ) + ( k [ p & 3 ^ e ] ^ z ) ;}return v ;}/*** Decrypt data with key.** @param v* @param k* @return*/public static int [] decrypt ( int [] v , int [] k ) {int n = v . length - 1 ;if ( n < 1 ) {return v ;}if ( k . length < 4 ) {int [] key = new int [ 4 ] ;System . arraycopy ( k , 0 , key , 0 , k . length ) ;k = key ;}int z = v [ n ] , y = v [ 0 ] , delta = 0x9E3779B9 , sum , e ;int p , q = 6 + 52 / ( n + 1 ) ;sum = q * delta ;while ( sum != 0 ) {e = sum >>> 2 & 3 ;for ( p = n ; p > 0 ; p -- ) {z = v [ p - 1 ] ;y = v [ p ] -= ( z >>> 5 ^ y << 2 ) + ( y >>> 3 ^ z << 4 ) ^ ( sum ^ y ) + ( k [ p & 3 ^ e ] ^ z ) ;}z = v [ n ] ;y = v [ 0 ] -= ( z >>> 5 ^ y << 2 ) + ( y >>> 3 ^ z << 4 ) ^ ( sum ^ y ) + ( k [ p & 3 ^ e ] ^ z ) ;sum = sum - delta ;}return v ;}/*** Convert byte array to int array.** @param data* @param includeLength* @return*/private static int [] toIntArray ( byte [] data , boolean includeLength ) { int n = ((( data . length & 3 ) == 0 ) ? ( data . length >>> 2 ): (( data . length >>> 2 ) + 1 )) ;int [] result ;if ( includeLength ) {result = new int [ n + 1 ] ;result [ n ] = data . length ;} else {result = new int [ n ] ;}n = data . length ;for ( int i = 0 ; i < n ; i ++ ) {result [ i >>> 2 ] |= ( 0x000000ff & data [ i ]) << (( i & 3 ) << 3 ) ; }return result ;}/*** Convert int array to byte array.** @param data* @param includeLength* @return*/private static byte [] toByteArray ( int [] data , boolean includeLength ) { int n ;if ( includeLength ) {n = data [ data . length - 1 ] ;} else {n = data . length << 2 ;}byte [] result = new byte [ n ] ;for ( int i = 0 ; i < n ; i ++ ) {result [ i ] = ( byte ) ( data [ i >>> 2 ] >>> (( i & 3 ) << 3 )) ; }return result ;}}//=================================;C#实现（下载文件）//=================================;/* xxtea.cs** Author: Ma Bingyao < andot@ >* Copyright: * Version: 1.1* LastModified: 2006-05-05* This library is free. You can redistribute it and/or modify it.* /?p=163*/using System ;class XXTEA{public static Byte [] Encrypt ( Byte [] Data , Byte [] Key ){if ( Data . Length == 0 ){return Data ;}return ToByteArray ( Encrypt ( ToUInt32Array ( Data , true ) , ToUInt32Array ( Key , false )) , false ) ;}public static Byte [] Decrypt ( Byte [] Data , Byte [] Key ){if ( Data . Length == 0 ){return Data ;}return ToByteArray ( Decrypt ( ToUInt32Array ( Data , false ) , ToUInt32Array ( Key , false )) , true ) ;}public static UInt32 [] Encrypt ( UInt32 [] v , UInt32 [] k ){Int32 n = v . Length - 1 ;if ( n < 1 ){return v ;}if ( k . Length < 4 ){UInt32 [] Key = new UInt32 [ 4 ] ;k . CopyTo ( Key , 0 ) ;k = Key ;}UInt32 z = v [ n ] , y = v [ 0 ] , delta = 0x9E3779B9 , sum = 0 , e ;Int32 p , q = 6 + 52 / ( n + 1 ) ;while ( q -- > 0 ){sum = unchecked ( sum + delta ) ;e = sum >> 2 & 3 ;for ( p = 0 ; p < n ; p ++ ){y = v [ p + 1 ] ;z = unchecked ( v [ p ] += ( z >> 5 ^ y << 2 ) + ( y >> 3 ^ z << 4 ) ^ ( sum ^ y ) + ( k [ p & 3 ^ e ] ^ z )) ;}y = v [ 0 ] ;z = unchecked ( v [ n ] += ( z >> 5 ^ y << 2 ) + ( y >> 3 ^ z << 4 ) ^ ( sum ^ y ) + ( k [ p & 3 ^ e ] ^ z )) ;}return v ;}public static UInt32 [] Decrypt ( UInt32 [] v , UInt32 [] k ){Int32 n = v . Length - 1 ;if ( n < 1 ){return v ;}if ( k . Length < 4 ){UInt32 [] Key = new UInt32 [ 4 ] ;k . CopyTo ( Key , 0 ) ;k = Key ;}UInt32 z = v [ n ] , y = v [ 0 ] , delta = 0x9E3779B9 , sum , e ;Int32 p , q = 6 + 52 / ( n + 1 ) ;sum = unchecked (( UInt32 )( q * delta )) ;while ( sum != 0 ){e = sum >> 2 & 3 ;for ( p = n ; p > 0 ; p -- ){z = v [ p - 1 ] ;y = unchecked ( v [ p ] -= ( z >> 5 ^ y << 2 ) + ( y >> 3 ^ z << 4 ) ^ ( sum ^ y ) + ( k [ p & 3 ^ e ] ^ z )) ;}z = v [ n ] ;y = unchecked ( v [ 0 ] -= ( z >> 5 ^ y << 2 ) + ( y >> 3 ^ z << 4 ) ^ ( sum ^ y ) + ( k [ p & 3 ^ e ] ^ z )) ;sum = unchecked ( sum - delta ) ;}return v ;}private static UInt32 [] ToUInt32Array ( Byte [] Data , Boolean IncludeLength ){Int32 n = ((( Data . Length & 3 ) == 0 ) ? ( Data . Length >> 2 ) : (( Data . Length >> 2 ) + 1 )) ;UInt32 [] Result ;if ( IncludeLength ){Result = new UInt32 [ n + 1 ] ;Result [ n ] = ( UInt32 ) Data . Length ;}else{Result = new UInt32 [ n ] ;}n = Data . Length ;for ( Int32 i = 0 ; i < n ; i ++ ){Result [ i >> 2 ] |= ( UInt32 ) Data [ i ] << (( i & 3 ) << 3 ) ;}return Result ;}private static Byte [] ToByteArray ( UInt32 [] Data , Boolean IncludeLength ){Int32 n ;if ( IncludeLength ){n = ( Int32 ) Data [ Data . Length - 1 ] ;}else{n = Data . Length << 2 ;}Byte [] Result = new Byte [ n ] ;for ( Int32 i = 0 ; i < n ; i ++ ){Result [ i ] = ( Byte )( Data [ i >> 2 ] >> (( i & 3 ) << 3 )) ;}return Result ;}}注意：如果需要在JavaScript 中加密解密带有汉字的信息，在加密时，需要先将带加密信息用utf16to8 进行转换，解密时，需要将解密后的内容再用utf8to16 还原。

加密解密程序设计加密解密程序设计通常用于保护敏感信息的传输和存储，确保只有授权的用户才能访问和理解这些信息。

本文将讨论一个基本的加密解密程序设计，其中包含了常用的加密算法和解密算法，以及一些常见的加密解密技巧和策略。

一、加密算法设计1. 替换加密算法（Substitution Cipher）：将原始消息中的字符替换为其他字符，通常使用一个固定的字母表和一个加密密钥。

例如，可以通过移位加密算法将字母A替换为字母D，将字母B替换为字母E，以此类推。

解密时，将密文中的字符替换回原始字符即可。

2. 移位加密算法（Caesar Cipher）：也称为凯撒密码，是一种简单的替换密码。

将原始消息中的每个字母按照固定的位移量向后移动，例如，位移量为3时，字母A将被替换为字母D，字母B将被替换为字母E，以此类推。

解密时，将密文中的字母按照相同的位移量向前移动即可恢复原始消息。

3. 对称加密算法（Symmetric Cryptography）：使用同一个密钥进行加密和解密，常用的对称加密算法包括DES、AES和RC4等。

加密时，将原始消息和密钥作为输入，通过特定的算法生成密文。

解密时，将密文和相同的密钥作为输入，通过逆算法恢复原始消息。

4. 非对称加密算法（Asymmetric Cryptography）：使用两个不同的密钥进行加密和解密，分别为公钥和私钥。

常用的非对称加密算法包括RSA、DSA和ECC等。

加密时，将原始消息和公钥作为输入，通过特定的算法生成密文。

解密时，将密文和私钥作为输入，通过逆算法恢复原始消息。

5. 哈希函数（Hash Function）：将任意长度的输入数据映射到固定长度的输出数据。

常用的哈希函数有MD5和SHA1等。

哈希函数通常用于生成消息的摘要，以验证消息的完整性和防止数据篡改。

二、加密解密程序设计示例以下是一个基本的加密解密程序设计示例，使用移位加密算法和对称加密算法进行加密和解密。

1.移位加密算法：```pythondef shift_cipher_encrypt(message, shift):encrypted_message = ""for character in message:if character.isalpha(:encrypted_character = chr((ord(character) - ord('A') + shift) % 26 + ord('A'))else:encrypted_character = characterencrypted_message += encrypted_characterreturn encrypted_messagedef shift_cipher_decrypt(encrypted_message, shift):decrypted_message = ""for character in encrypted_message:if character.isalpha(:decrypted_character = chr((ord(character) - ord('A') - shift) % 26 + ord('A'))else:decrypted_character = characterdecrypted_message += decrypted_characterreturn decrypted_message```2. 对称加密算法（使用Python的PyCrypto库进行AES加密）：```pythonfrom Crypto.Cipher import AESdef symmetric_encrypt(message, key):cipher = AES.new(key, AES.MODE_ECB)encrypted_message = cipher.encrypt(message)return encrypted_messagedef symmetric_decrypt(encrypted_message, key):cipher = AES.new(key, AES.MODE_ECB)decrypted_message = cipher.decrypt(encrypted_message)return decrypted_message```三、加密解密技巧和策略1.密钥管理：确保只有授权的用户才能获得密钥。

Python3对称加密算法AES、DES3实例详解本⽂实例讲述了Python3对称加密算法AES、DES3。

分享给⼤家供⼤家参考，具体如下：python3.6此库安装⽅式，需要pip3 install pycryptodome。

如有site-packages中存在crypto、pycrypto，在pip之前，需要pip3 uninstall crypto、pip3 uninstall pycrypto，否则⽆法安装成功。

这⾥顺带说⼀下pycrypto，这个库已经有很久没有⼈维护了，如果需要安装此库，需要先安装 VC++ build tools然后将 ~\BuildTools\VC\Tools\MSVC\14.15.26726\include ⽬录下的 stdint.h 拷贝到 C:\Program Files (x86)\Windows Kits\10\Include\10.0.17134.0\ucrt 下。

（Win10 需管理员权限）接着将同⽬录下的 inttypes.h 中的#include <stdint.h>（第⼗四⾏），改成#include "stdint.h"。

然后使⽤pip3 install pycrypto，就能直接安装了。

注：如果不是业务需要，请尽可能使⽤ pycryptodome。

AES：import Crypto.Cipher.AESimport Crypto.Randomimport base64import binasciidef auto_fill(x):if len(x) <= 32:while len(x) not in [16, 24, 32]:x += " "return x.encode()else:raise "密钥长度不能⼤于32位！"key = "asd"content = "abcdefg1234567"x = Crypto.Cipher.AES.new(auto_fill(key), Crypto.Cipher.AES.MODE_ECB)a = base64.encodebytes(x.encrypt(auto_fill(content)))b = x.decrypt(base64.decodebytes(a))print(a)print(b)a = binascii.b2a_base64(x.encrypt(auto_fill(content)))b = x.decrypt(binascii.a2b_base64(a))print(a)print(b)key = "dsa"iv = Crypto.Random.new().read(16) # 向量，必须为16字节content = "1234567abcdefg"y = Crypto.Cipher.AES.new(auto_fill(key), Crypto.Cipher.AES.MODE_CBC, iv)c = binascii.b2a_base64(y.encrypt(auto_fill(content)))z = Crypto.Cipher.AES.new(auto_fill(key), Crypto.Cipher.AES.MODE_CBC, iv)d = z.decrypt(binascii.a2b_base64(c))print(c)print(d)运⾏结果：b'jr/EIUp32kLHc3ypZZ1cyg==\n'b'abcdefg1234567 'b'jr/EIUp32kLHc3ypZZ1cyg==\n'b'abcdefg1234567 'b'j+Ul9KQd0HnuiHW3z9tD7A==\n'b'1234567abcdefg 'DES3：import Crypto.Cipher.DES3import base64import binasciidef auto_fill(x):if len(x) > 24:raise "密钥长度不能⼤于等于24位！"else:while len(x) < 16:x += " "return x.encode()key = "asd"content = "abcdefg1234567"x = Crypto.Cipher.DES3.new(auto_fill(key), Crypto.Cipher.DES3.MODE_ECB)a = base64.encodebytes(x.encrypt(auto_fill(content)))print(a)b = x.decrypt(base64.decodebytes(a))print(b)a = binascii.b2a_base64(x.encrypt(auto_fill(content)))b = x.decrypt(binascii.a2b_base64(a))print(a)print(b)运⾏结果：b'/ee3NFKeNqEk/qMNd1mjog==\n'b'abcdefg1234567 'b'/ee3NFKeNqEk/qMNd1mjog==\n'b'abcdefg1234567 '附：AES的⼯⼚模式封装Cipher_AES.py（封装Crypto.Cipher.AES）'''Created on 2018年7⽉7⽇@author: ray'''import Crypto.Cipher.AESimport Crypto.Randomimport base64import binasciiclass Cipher_AES:pad_default = lambda x, y: x + (y - len(x) % y) * " ".encode("utf-8")unpad_default = lambda x: x.rstrip()pad_user_defined = lambda x, y, z: x + (y - len(x) % y) * z.encode("utf-8")unpad_user_defined = lambda x, z: x.rstrip(z)pad_pkcs5 = lambda x, y: x + (y - len(x) % y) * chr(y - len(x) % y).encode("utf-8")unpad_pkcs5 = lambda x: x[:-ord(x[-1])]def __init__(self, key="abcdefgh12345678", iv=Crypto.Random.new().read(Crypto.Cipher.AES.block_size)):self.__key = keyself.__iv = ivdef set_key(self, key):self.__key = keydef get_key(self):return self.__keydef set_iv(self, iv):self.__iv = ivdef get_iv(self):return self.__ivdef Cipher_MODE_ECB(self):self.__x = Crypto.Cipher.AES.new(self.__key.encode("utf-8"), Crypto.Cipher.AES.MODE_ECB)def Cipher_MODE_CBC(self):self.__x = Crypto.Cipher.AES.new(self.__key.encode("utf-8"), Crypto.Cipher.AES.MODE_CBC, self.__iv.encode("utf-8")) def encrypt(self, text, cipher_method, pad_method="", code_method=""):if cipher_method.upper() == "MODE_ECB":self.Cipher_MODE_ECB()elif cipher_method.upper() == "MODE_CBC":self.Cipher_MODE_CBC()cipher_text = b"".join([self.__x.encrypt(i) for i in self.text_verify(text.encode("utf-8"), pad_method)])if code_method.lower() == "base64":return base64.encodebytes(cipher_text).decode("utf-8").rstrip()elif code_method.lower() == "hex":return binascii.b2a_hex(cipher_text).decode("utf-8").rstrip()else:return cipher_text.decode("utf-8").rstrip()def decrypt(self, cipher_text, cipher_method, pad_method="", code_method=""):if cipher_method.upper() == "MODE_ECB":self.Cipher_MODE_ECB()elif cipher_method.upper() == "MODE_CBC":self.Cipher_MODE_CBC()if code_method.lower() == "base64":cipher_text = base64.decodebytes(cipher_text.encode("utf-8"))elif code_method.lower() == "hex":cipher_text = binascii.a2b_hex(cipher_text.encode("utf-8"))else:cipher_text = cipher_text.encode("utf-8")return self.unpad_method(self.__x.decrypt(cipher_text).decode("utf-8"), pad_method)def text_verify(self, text, method):while len(text) > len(self.__key):text_slice = text[:len(self.__key)]text = text[len(self.__key):]yield text_sliceelse:if len(text) == len(self.__key):yield textelse:yield self.pad_method(text, method)def pad_method(self, text, method):if method == "":return Cipher_AES.pad_default(text, len(self.__key))elif method == "PKCS5Padding":return Cipher_AES.pad_pkcs5(text, len(self.__key))else:return Cipher_AES.pad_user_defined(text, len(self.__key), method)def unpad_method(self, text, method):if method == "":return Cipher_AES.unpad_default(text)elif method == "PKCS5Padding":return Cipher_AES.unpad_pkcs5(text)else:return Cipher_AES.unpad_user_defined(text, method)使⽤⽅法：加密：Cipher_AES(key [, iv]).encrypt(text, cipher_method [, pad_method [, code_method]])解密：Cipher_AES(key [, iv]).decrypt(cipher_text, cipher_method [, pad_method [, code_method]])key：密钥（长度必须为16、24、32）iv：向量（长度与密钥⼀致，ECB模式不需要）text：明⽂（需要加密的内容）cipher_text：密⽂（需要解密的内容）cipher_method：加密⽅法，⽬前只有"MODE_ECB"、"MODE_CBC"两种pad_method：填充⽅式，解决 Java 问题选⽤"PKCS5Padding"code_method：编码⽅式，⽬前只有"base64"、"hex"两种来段调⽤封装类 Cipher_AES 的 demo_Cipher_AES.py，⽅便⼤家理解：import Cipher_AESkey = "qwedsazxc123321a"iv = key[::-1]text = "我爱⼩姐姐，可⼩姐姐不爱我 - -"cipher_method = "MODE_CBC"pad_method = "PKCS5Padding"code_method = "base64"cipher_text = Cipher_AES(key, iv).encrypt(text, cipher_method, pad_method, code_method)print(cipher_text)text = Cipher_AES(key, iv).decrypt(cipher_text, cipher_method, pad_method, code_method)print(text)'''运⾏结果：uxhf+MoSko4xa+jGOyzJvYH9n5NvrCwEHbwm/A977CmGqzg+fYE0GeL5/M5v9O1o我爱⼩姐姐，可⼩姐姐不爱我 - -'''PS：关于加密解密感兴趣的朋友还可以参考本站在线⼯具：更多关于Python相关内容感兴趣的读者可查看本站专题：《》、《》、《》、《》、《》、《》及《》希望本⽂所述对⼤家Python程序设计有所帮助。

C语言密码学与加密算法密码学是研究加密和解密技术的学科，它在现代信息安全中扮演着非常重要的角色。

C语言作为一种高效且广泛应用的编程语言，可以用来实现各种密码学算法。

本文将介绍C语言中的一些常用密码学算法及其实现。

一、凯撒密码（Caesar Cipher）凯撒密码是一种简单的替换密码，它通过将字母按照固定的位移量进行替换来进行加密和解密操作。

C语言中可以使用字符数组和循环来实现凯撒密码的加密和解密功能。

以下是一个示例代码：```c#include <stdio.h>#define SHIFT 3void encrypt(char* message) {int i = 0;while (message[i] != '\0') {if (message[i] >= 'a' && message[i] <= 'z') {message[i] = (message[i] - 'a' + SHIFT) % 26 + 'a';}else if (message[i] >= 'A' && message[i] <= 'Z') {message[i] = (message[i] - 'A' + SHIFT) % 26 + 'A';}i++;}}void decrypt(char* message) {int i = 0;while (message[i] != '\0') {if (message[i] >= 'a' && message[i] <= 'z') {message[i] = (message[i] - 'a' - SHIFT + 26) % 26 + 'a'; }else if (message[i] >= 'A' && message[i] <= 'Z') {message[i] = (message[i] - 'A' - SHIFT + 26) % 26 + 'A'; }i++;}}int main() {char message[] = "Hello, World!";encrypt(message);printf("Encrypted message: %s\n", message);decrypt(message);printf("Decrypted message: %s\n", message);return 0;}```二、AES算法（Advanced Encryption Standard）AES算法是目前应用最广泛的对称加密算法之一。

三种加密算法范文加密算法是数据安全领域的重要组成部分，用于对敏感数据进行转换，使其难以被未经授权的人解读。

以下是三种常见的加密算法：对称加密算法、非对称加密算法和哈希函数。

1.对称加密算法：对称加密算法是一种使用相同的密钥来加密和解密数据的加密算法。

最常见的对称加密算法包括DES（Data Encryption Standard）、3DES （Triple Data Encryption Algorithm）和AES（Advanced Encryption Standard）。

对称加密算法的优点是加密和解密速度快，适用于对大量数据进行加密。

然而，由于密钥的共享，对称加密算法容易受到密钥泄露和中间人攻击的威胁。

2.非对称加密算法：非对称加密算法使用了一对密钥，公钥用于加密数据，而私钥用于解密数据。

其中最常见的非对称加密算法是RSA（Rivest-Shamir-Adleman）和椭圆曲线加密算法（ECDSA）。

非对称加密算法的优点是安全性较高，由于私钥是保密的，即使公钥泄露，攻击者也无法得到私钥从而解密数据。

然而，由于非对称加密算法运算复杂，加密和解密速度较慢。

3.哈希函数：哈希函数是一种将任意长度的数据转换为固定长度的数据的算法。

最常用的哈希函数包括MD5（Message Digest Algorithm 5）、SHA-1（Secure Hash Algorithm 1）和SHA-256等。

哈希函数的特点是不可逆和唯一性。

不可逆性指的是无法通过哈希值反向推导出原始数据，唯一性指的是不同的输入会产生不同的哈希值。

哈希函数常用于数据完整性校验和密码存储。

总结：三种加密算法各有优劣。

对称加密算法速度快，但密钥共享容易受到攻击；非对称加密算法安全性较高，但运算复杂；哈希函数可以用于数据完整性校验，但无法逆向计算原始数据。

在实际应用中，通常会结合使用这些算法，以达到更好的数据安全性。

例如，在传输敏感数据时，可以使用非对称加密算法加密对称加密算法的密钥，再用对称加密算法对数据进行加密，同时使用哈希函数对整个数据进行完整性验证。

介绍XXTEA加密算法及其C实现“微型加密算法（TEA）及其相关变种（XTEA，Block TEA，XXTEA）都是分组加密算法，它们很容易被描述，实现也很简单（典型的⼏⾏代码）。

TEA 算法最初是由剑桥计算机实验室的 David Wheeler 和 Roger Needham 在 1994 年设计的。

该算法使⽤ 128 位的密钥为 64 位的信息块进⾏加密，它需要进⾏ 64 轮迭代。

该算法使⽤了⼀个神秘常数δ作为倍数，它来源于黄⾦⽐率，以保证每⼀轮加密都不相同。

但δ的精确值似乎并不重要，这⾥ TEA 把它定义为δ=「(√5 - 1)231」（也就是程序中的 0×9E3779B9 ）。

”其实，TEA跟我们的关系⾮常密切，因为QQ就是使⽤16轮迭代的TEA算法。

XXTEA是其最新的变种，于1998年提出。

⽬前还没有⼈找到对其进⾏攻击的⽅法，是对前⾯⼀些变种的改进。

XXTEA 算法很安全，⽽且⾮常快速，⾮常适合应⽤于 Web 开发中。

下⾯是作者给出的该算法的C实现：#define MX (z>>5^y<<2) + (y>>3^z<<4)^(sum^y) + (k[p&3^e]^z);long btea(long* v, long n, long* k) {unsigned long z=v[n-1], y=v[0], sum=0, e, DELTA=0x9e3779b9;long p, q ;if (n > 1) {q = 6 + 52/n;while (q-- > 0) {sum += DELTA;e = (sum >> 2) & 3;for (p=0; p<n-1; p++) y = v[p+1], z = v[p] += MX;y = v[0];z = v[n-1] += MX;}return 0 ;} else if (n < -1) {n = -n;q = 6 + 52/n;sum = q*DELTA ;while (sum != 0) {e = (sum >> 2) & 3;for (p=n-1; p>0; p--) z = v[p-1], y = v[p] -= MX;z = v[n-1];y = v[0] -= MX;sum -= DELTA;}return 0;}return 1;}teab will encode or decode n words as a single block where n > 1v is the n word data vectork is the 4 word keyn is negative for decodingif n is zero result is 1 and no coding or decoding takes place, otherwise the result is zeroassumes 32 bit ‘long’ and same endian coding and decoding这是wikipedia⾥的说明，讲得⽐较明⽩了。

TEA加密算法的C/C++实现啥都不说，直接贴代码，这是转发的哦，来源：Linux联盟收集整理首先是C版：1void encrypt(unsigned long *v, unsigned long *k) {2 unsigned long y=v[0], z=v[1], sum=0, i; /* set up */3 unsigned long delta=0x9e3779b9; /* a key sched ule constant */4 unsigned long a=k[0], b=k[1], c=k[2], d=k[3]; /* cache key * /5for (i=0; i < 32; i++) { /* basic cycle start */6 sum += delta;7 y += ((z<<4) + a) ^ (z + sum) ^ ((z>>5) + b);8 z += ((y<<4) + c) ^ (y + sum) ^ ((y>>5) + d);/* end cycle */9 }10 v[0]=y;11 v[1]=z;12}1314void decrypt(unsigned long *v, unsigned long *k) {15 unsigned long y=v[0], z=v[1], sum=0xC6EF3720, i; /* set up */16 unsigned long delta=0x9e3779b9; /* a key sche dule constant */17 unsigned long a=k[0], b=k[1], c=k[2], d=k[3]; /* cache ke y */18for(i=0; i<32; i++) { /* basic cycle start */19 z -= ((y<<4) + c) ^ (y + sum) ^ ((y>>5) + d);20 y -= ((z<<4) + a) ^ (z + sum) ^ ((z>>5) + b);21 sum -= delta; /* end cycle */22 }23 v[0]=y;24 v[1]=z;25}C语言写的用起来当然不方便，没关系，用C++封装以下就OK了：util.h1#ifndef UTIL_H2#define UTIL_H34#include <string>5#include <cmath>6#include <cstdlib>78typedef unsigned char byte;9typedef unsigned long ulong;1011inline double logbase(double base, double x) {12return log(x)/log(base);13}1415/*16*convert int to hex char.17*example:10 -> 'A',15 -> 'F'18*/19char intToHexChar(int x);2021/*22*convert hex char to int.23*example:'A' -> 10,'F' -> 1524*/25int hexCharToInt(char hex);2627using std::string;28/*29*convert a byte array to hex string.30*hex string format example:"AF B0 80 7D"31*/32string bytesToHexString(const byte *in, size_t size); 3334/*35*convert a hex string to a byte array.36*hex string format example:"AF B0 80 7D"37*/38size_t hexStringToBytes(const string &str, byte *out); 3940#endif/*UTIL_H*/util.cpp1#include "util.h"2#include <vector>34using namespace std;56char intToHexChar(int x) {7static const char HEX[16] = {8 '0', '1', '2', '3',9 '4', '5', '6', '7',10 '8', '9', 'A', 'B',11 'C', 'D', 'E', 'F'12 };13return HEX[x];14}1516int hexCharToInt(char hex) {17 hex = toupper(hex);18if (isdigit(hex))19return (hex - '0');20if (isalpha(hex))21return (hex - 'A' + 10);22return 0;23}2425string bytesToHexString(const byte *in, size_t size) {26 string str;27for (size_t i = 0; i < size; ++i) {28int t = in[i];29int a = t / 16;30int b = t % 16;31 str.append(1, intToHexChar(a));32 str.append(1, intToHexChar(b));33if (i != size - 1)34 str.append(1, ' ');35 }36return str;37}3839size_t hexStringToBytes(const string &str, byte *out) {4041 vector<string> vec;42 string::size_type currPos = 0, prevPos = 0;43while ((currPos = str.find(' ', prevPos)) != string::npos) {44 string b(str.substr(prevPos, currPos - prevPos));45 vec.push_back(b);46 prevPos = currPos + 1;47 }48if (prevPos < str.size()) {49 string b(str.substr(prevPos));50 vec.push_back(b);51 }52 typedef vector<string>::size_type sz_type;53 sz_type size = vec.size();54for (sz_type i = 0; i < size; ++i) {55int a = hexCharToInt(vec[i][0]);56int b = hexCharToInt(vec[i][1]);57 out[i] = a * 16 + b;58 }59return size;60}tea.h1#ifndef TEA_H2#define TEA_H34/*5*for htonl,htonl6*do remember link "ws2_32.lib"7*/8#include <winsock2.h>9#include "util.h"1011class TEA {12public:13 TEA(const byte *key, int round = 32, bool isNetByte = false);14 TEA(const TEA &rhs);15 TEA& operator=(const TEA &rhs);16void encrypt(const byte *in, byte *out);17void decrypt(const byte *in, byte *out);18private:19void encrypt(const ulong *in, ulong *out);20void decrypt(const ulong *in, ulong *out);21 ulong ntoh(ulong netlong) { return _isNetByte ? ntohl(netlong) : netlong; }22 ulong hton(ulong hostlong) { return _isNetByte ? htonl(hostlong) : hostlong; }23private:24int _round; //iteration round to encrypt or decrypt25 bool _isNetByte; //whether input bytes come from network26byte _key[16]; //encrypt or decrypt key27};2829#endif/*TEA_H*/tea.cpp1#include "tea.h"2#include <cstring> //for memcpy,memset34using namespace std;56TEA::TEA(const byte *key, int round /*= 32*/, bool isNetByte /*= f alse*/)7:_round(round)8,_isNetByte(isNetByte) {9if (key != 0)10 memcpy(_key, key, 16);11else12 memset(_key, 0, 16);13}1415TEA::TEA(const TEA &rhs)16:_round(rhs._round)17,_isNetByte(rhs._isNetByte) {18 memcpy(_key, rhs._key, 16);19}2021TEA& TEA::operator=(const TEA &rhs) {22if (&rhs != this) {23 _round = rhs._round;24 _isNetByte = rhs._isNetByte;25 memcpy(_key, rhs._key, 16);26 }27return *this;28}2930void TEA::encrypt(const byte *in, byte *out) {31 encrypt((const ulong*)in, (ulong*)out);32}3334void TEA::decrypt(const byte *in, byte *out) {35 decrypt((const ulong*)in, (ulong*)out);36}3738void TEA::encrypt(const ulong *in, ulong *out) {3940 ulong *k = (ulong*)_key;41 register ulong y = ntoh(in[0]);42 register ulong z = ntoh(in[1]);43 register ulong a = ntoh(k[0]);44 register ulong b = ntoh(k[1]);45 register ulong c = ntoh(k[2]);46 register ulong d = ntoh(k[3]);47 register ulong delta = 0x9E3779B9; /* (sqrt(5)-1)/2*2^32 */48 register int round = _round;49 register ulong sum = 0;5051while (round--) { /* basic cycle start */52 sum += delta;53 y += ((z << 4) + a) ^ (z + sum) ^ ((z >> 5) + b);54 z += ((y << 4) + c) ^ (y + sum) ^ ((y >> 5) + d);55 } /* end cycle */56 out[0] = ntoh(y);57 out[1] = ntoh(z);58}5960void TEA::decrypt(const ulong *in, ulong *out) {6162 ulong *k = (ulong*)_key;63 register ulong y = ntoh(in[0]);64 register ulong z = ntoh(in[1]);65 register ulong a = ntoh(k[0]);66 register ulong b = ntoh(k[1]);67 register ulong c = ntoh(k[2]);68 register ulong d = ntoh(k[3]);69 register ulong delta = 0x9E3779B9; /* (sqrt(5)-1)/2*2^32 */70 register int round = _round;71 register ulong sum = 0;7273if (round == 32)74 sum = 0xC6EF3720; /* delta << 5*/75else if (round == 16)76 sum = 0xE3779B90; /* delta << 4*/77else78 sum = delta << static_cast<int>(logbase(2, round));7980while (round--) { /* basic cycle start */81 z -= ((y << 4) + c) ^ (y + sum) ^ ((y >> 5) + d);82 y -= ((z << 4) + a) ^ (z + sum) ^ ((z >> 5) + b);83 sum -= delta;84 } /* end cycle */85 out[0] = ntoh(y);86 out[1] = ntoh(z);87}需要说明的是TEA的构造函数：TEA(const byte *key, int round = 32, bool isNetByte = false);1.key - 加密或解密用的128-bit(16byte)密钥。

XXTEA加密算法的原理及其C语言实现XXTEA加密算法的原理及其C语言实现在数据的加解密领域，算法分为对称密钥与非对称密钥两种。

对称密钥与非对称密钥由于各自的特点，所应用的领域是不尽相同的。

对称密钥加密算法由于其速度快，一般用于整体数据的加密，而非对称密钥加密算法的安全性能佳，在数字签名领域得到广泛的应用。

TEA算法是由剑桥大学计算机实验室的David Wheeler和Roger Needham于1994年发明，TEA是Tiny Encryption Algorithm的缩写，以加密解密速度快，实现简单著称。

TEA算法每一次可以操作64bit(8byte)，采用128bit(16byte)作为key，算法采用迭代的形式，推荐的迭代轮数是64轮，最少32轮。

为解决TEA算法密钥表攻击的问题，TEA算法先后经历了几次改进，从XTEA到BLOCK TEA，直至最新的XXTEA。

XTEA也称做TEAN，它使用与TEA相同的简单运算，但四个子密钥采取不正规的方式进行混合以阻止密钥表攻击。

Block TEA算法可以对32位的任意整数倍长度的变量块进行加解密的操作，该算法将XTEA轮循函数依次应用于块中的每个字，并且将它附加于被应用字的邻字。

XXTEA使用跟Block TEA 相似的结构，但在处理块中每个字时利用了相邻字，且用拥有两个输入量的MX函数代替了XTEA轮循函数。

本文所描述的安全机制采用的加密算法就是TEA算法中安全性能最佳的改进版本－XXTEA算法。

XTEA算法的一轮加密过程如图1所示：XXTEA算法的结构非常简单，只需要执行加法、异或和寄存的硬件即可，且软件实现的代码非常短小，具有可移植性，非常适合嵌入式系统应用。

由于XXTEA算法的以上优点，可以很好地应用于嵌入式RFID系统当中。

XXTEA算法的C语言表达：#define MX (z>>5^y<<2) + (y>>3^z<<4)^(sum^y) + (k[p&3^e]^z);long btea(long* v, long n, long* k){unsigned long z=v[n-1], y=v[0], sum=0, e, DELTA=0x9e3779b9; long p, q ;if (n > 1) { /* 加密过程*/q = 6 + 52/n;while (q-- > 0){sum += DELTA; e = (sum >> 2) & 3;for (p=0; py = v[0]; z = v[n-1] += MX;}return 0 ;} else if (n < -1) { /* 解密过程*/n = -n; q = 6 + 52/n; sum = q*DELTA ;while (sum != 0) { e = (sum >> 2) & 3;for (p=n-1; p>0; p--) z = v[p-1], y = v[p] -= MX;z = v[n-1]; y = v[0] -= MX; sum -= DELTA; }return 0; } return 1; }上述算法描述中，v表示为运算的长整型数据的首地址，k为长整型的密钥的首地址，n表示要要运算的组元个数，正表示加密，负表示解密。

c++代码实现tea加密算法的实例详解通过c++来实现tea加密算法，最终编译成so⽂件，以JNI的⽅式提供给客户端调⽤，主要需要解决以下三个问题：实现tea算法，这都有开源的代码可以实现；解决padding问题；密钥做⼀个混淆，防⽌编译⽣成的库⽂件⽅便的被逆向拿到；对于tea的加密算法，有成熟的各语⾔代码可以借鉴，下⾯是C++的实现：static void tea_encrypt(uint32_t *v, uint32_t *k) {uint32_t v0 = v[0], v1 = v[1], sum = 0, i;uint32_t delta = 0x9e3779b9;uint32_t k0 = k[0], k1 = k[1], k2 = k[2], k3 = k[3];for (i = 0; i < tea_round; i++) {sum += delta;v0 += ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1);v1 += ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3);}v[0] = v0;v[1] = v1;}static void tea_decrypt(uint32_t *v, uint32_t *k) {uint32_t v0 = v[0], v1 = v[1], sum, i;sum = (tea_round == 16) ? 0xE3779B90 : 0xC6EF3720;uint32_t delta = 0x9e3779b9;uint32_t k0 = k[0], k1 = k[1], k2 = k[2], k3 = k[3];for (i = 0; i < tea_round; i++) {v1 -= ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3);v0 -= ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1);sum -= delta;}v[0] = v0;v[1] = v1;}⽣成密钥，并对密钥做⼀定的混淆static uint32_t tea_key[4] = {0x34561234, 0x111f3423, 0x34d57910, 0x00989034};static uint32_t salt = 0x12031243;static int tea_round = 16;//做简单的混淆static void confuse_key(uint32_t *key) {for (int i = 4; i > 0; i--) {key[4 - i] = tea_key[i - 1] ^ salt;}}最后要实现加密算法的padding，⾸先思考⼀个问题，为什么要padding呢？因为Tea是块加密算法，8个字节为⼀个块。

加密算法程序代码下面是一个简单的加密算法程序代码示例，实现了基本的加密和解密功能，供参考：```pythondef encrypt(text, key):"""加密函数:param text: 原始文本:param key: 密钥:return: 加密后的文本"""encrypted_text = ""for char in text:#使用密钥进行简单的位移操作encrypted_char = chr((ord(char) + key) % 256)encrypted_text += encrypted_charreturn encrypted_textdef decrypt(encrypted_text, key):"""解密函数:param encrypted_text: 加密后的文本:param key: 密钥:return: 解密后的文本"""decrypted_text = ""for char in encrypted_text:#使用密钥进行简单的位移反操作decrypted_char = chr((ord(char) - key) % 256) decrypted_text += decrypted_charreturn decrypted_text#测试加密解密函数text = "Hello, World!"key = 5encrypted_text = encrypt(text, key)decrypted_text = decrypt(encrypted_text, key) print("加密后的文本:", encrypted_text)print("解密后的文本:", decrypted_text)```输出结果：```解密后的文本: Hello, World!```这个示例中的加密算法采用了简单的位移操作，即将每个字符的ASCII码值加上密钥，然后取余256、解密操作则是将加密后的字符的ASCII码值减去密钥，再取余256、这个算法非常简单且不安全，仅仅是为了演示目的。

三类加密算法的实现研究SSO的副产品,在寻找好的加密算法在中常用的有:不可逆的HASH算法,如MD5,SHA1,对称可逆的DES,不对称可逆的RSA等.我最终选择的是对称可拟的AES算法的衍生算法:Rijndael,因为它加密后的长度比较小,适合在URL中携带,而原本考虑的RSA算法生成128位长度的字串,显得未免太长了,呼呼以下代码综合了网上各类文章并做了部分整合修改.需要的人可以使用.至于MD5,SHA1,BASE64之类的在.NET里一条语句就搞定.呼呼------------------Rijndael算法:密钥KEY和起始量IV都通过专门的函数生成.如果是要做成可调用的函数，可修改EncryptString128Bit,DecryptString128Bit Imports System.Security.CryptographyImports System.IOImports System.TextPublic Class Form1Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.LoadEnd SubPrivate Function CreateKey(ByVal strPassword As String) As Byte()Dim chrData() As Char = strPassword.ToCharArrayDim intLength As Integer = chrData.GetUpperBound(0) Dim bytDataT oHash(intLength) As ByteFor i As Integer = 0 To chrData.GetUpperBound(0)bytDataToHash(i) = CByte(Asc(chrData(i)))NextDim SHA512 As NewSystem.Security.Cryptography.SHA512Managed Dim bytResult As Byte() = puteHash(bytDataToHash)Dim bytKey(31) As ByteFor i As Integer = 0 To 31bytKey(i) = bytResult(i)NextReturn bytKeyEnd FunctionPrivate Function CreateIV(ByVal strPassword As String) As Byte()Dim chrData() As Char = strPassword.ToCharArrayDim intLength As Integer = chrData.GetUpperBound(0) Dim bytDataT oHash(intLength) As ByteFor i As Integer = 0 To chrData.GetUpperBound(0)bytDataToHash(i) = CByte(Asc(chrData(i)))NextDim SHA512 As New System.Security.Cryptography.SHA512Managed Dim bytResult As Byte() = puteHash(bytDataToHash)Dim bytIV(15) As ByteFor i As Integer = 32 To 47bytIV(i - 32) = bytResult(i)NextReturn bytIVEnd FunctionPublic Function EncryptString128Bit(ByVal vstrTextToBeEncrypted As String, ByVal vstrEncryptionKey AsByte(), ByVal vstrEncryptionVI As Byte()) As StringDim bytValue() As ByteDim bytEncoded() As ByteDim objMemoryStream As New MemoryStream()Dim objCryptoStream As CryptoStreamDim objRijndaelManaged As RijndaelManagedvstrTextToBeEncrypted = StripNullCharacters(vstrTextToBeEncrypted)bytValue = Encoding.ASCII.GetBytes(vstrTextT oBeEncrypted.ToCharArray) objRijndaelManaged = New RijndaelManaged()TryobjCryptoStream = New CryptoStream(objMemoryStream, _ objRijndaelManaged.CreateEncryptor(vstrEncryptionKey, vstrEncryptionVI), CryptoStreamMode.Write)objCryptoStream.Write(bytValue, 0, bytValue.Length)objCryptoStream.FlushFinalBlock()bytEncoded = objMemoryStream.T oArrayobjMemoryStream.Close()objCryptoStream.Close()CatchEnd TryReturn Convert.ToBase64String(bytEncoded)End FunctionPublic Function DecryptString128Bit(ByVal vstrStringToBeDecrypted As String, _ByVal vstrDecryptionKey As Byte(), ByVal vstrDecryptionVI As Byte()) As StringDim bytDataT oBeDecrypted() As ByteDim bytTemp() As ByteDim objRijndaelManaged As New RijndaelManaged()Dim objMemoryStream As MemoryStreamDim objCryptoStream As CryptoStreamDim strReturnString As String = String.EmptybytDataToBeDecrypted = Convert.FromBase64String(vstrStringToBeDecrypted) ReDim bytTemp(bytDataToBeDecrypted.Length)objMemoryStream = New MemoryStream(bytDataToBeDecrypted)TryobjCryptoStream = New CryptoStream(objMemoryStream, _ objRijndaelManaged.CreateDecryptor(vstrDecryptionKey, vstrDecryptionVI), CryptoStreamMode.Read)objCryptoStream.Read(bytTemp, 0, bytTemp.Length)objCryptoStream.FlushFinalBlock()objMemoryStream.Close()objCryptoStream.Close()CatchEnd TryReturnStripNullCharacters(Encoding.ASCII.GetString(bytTemp)) End FunctionPublic Function StripNullCharacters(ByVal vstrStringWithNulls As String) As StringDim intPosition As IntegerDim strStringWithOutNulls As StringintPosition = 1strStringWithOutNulls = vstrStringWithNullsDo While intPosition > 0intPosition = InStr(intPosition, vstrStringWithNulls,vbNullChar)If intPosition > 0 ThenstrStringWithOutNulls = Microsoft.VisualBasic.Left$(strStringWithOutNulls, intPosition - 1) & _Microsoft.VisualBasic.Right$(strStringWithOutNulls,Len(strStringWithOutNulls) - intPosition)End IfIf intPosition > strStringWithOutNulls.Length ThenExit DoEnd IfLoopReturn strStringWithOutNullsEnd FunctionPrivate Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.ClickRESULTTB.Text = EncryptString128Bit(ORGTB.Text, CreateKey(keyTB.T ext), CreateIV(VITB.Text))DesTB.Text = DecryptString128Bit(RESULTTB.Text, CreateKey(keyTB.T ext), CreateIV(VITB.Text))End SubEnd Class----------------RSA算法:Imports System.TextImports System.Security.CryptographyPublic Class Form1Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.LoadDim rsa1 As RSACryptoServiceProvider = NewRSACryptoServiceProviderDim rsa2 As RSACryptoServiceProvider = New RSACryptoServiceProviderDim publickey, privatekey As Stringpublickey = rsa1.ToXmlString(False)privatekey = rsa1.T oXmlString(True)TextBox1.Text = publickeyTextBox2.Text = privatekeyDim plaintext As Stringplaintext = "天幻网" & vbCrLf & "12345678" & vbCrLf & "211.95.72.224"TextBox3.Text &= "原始数据是：" & Microsoft.VisualBasic.Chr(10) & plaintextrsa2.FromXmlString(privatekey)Dim cipherbytes As Byte()cipherbytes = rsa2.Encrypt(Encoding.UTF8.GetBytes(plaintext), False) TextBox3.Text &= "加密后的数据是(" & cipherbytes.Length.ToString & ")："Dim i As Integer = 0While i < cipherbytes.LengthTextBox3.Text &= String.Format("{0:X2} ", cipherbytes(i))System.Math.Min(System.Threading.Interlocked.Increment(i), i - 1)End WhileDim plaintbytes As Byte()plaintbytes = rsa1.Decrypt(cipherbytes, False)TextBox3.Text &= "解密后的数据是："TextBox3.Text &= Encoding.UTF8.GetString(plaintbytes)End SubEnd Class-----------------------DES算法:Imports System.Data.SqlClientImports System.SecurityImports System.Security.CryptographyImports System.TextPublic Class Form1Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.LoadDim key, Str As Stringkey = TextBox1.TextStr = TextBox3.TextTextBox2.Text = Encrypt(Str, key)End Sub'DES加密方法Public Shared Function Encrypt(ByVal pToEncrypt As String, ByVal sKey As String) As StringDim des As New DESCryptoServiceProvider()Dim inputByteArray() As ByteinputByteArray = Encoding.Default.GetBytes(pT oEncrypt)'建立加密对象的密钥和偏移量'原文使用ASCIIEncoding.ASCII方法的GetBytes方法'使得输入密码必须输入英文文本des.Key = ASCIIEncoding.ASCII.GetBytes(sKey)des.IV = ASCIIEncoding.ASCII.GetBytes(sKey)'写二进制数组到加密流'(把内存流中的内容全部写入)Dim ms As New System.IO.MemoryStream()Dim cs As New CryptoStream(ms, des.CreateEncryptor, CryptoStreamMode.Write)'写二进制数组到加密流'(把内存流中的内容全部写入)cs.Write(inputByteArray, 0, inputByteArray.Length)cs.FlushFinalBlock()'建立输出字符串Dim ret As New StringBuilder()Dim b As ByteFor Each b In ms.T oArray()ret.AppendFormat("{0:X2}", b)NextReturn ret.ToString()End Function'DES解密方法Public Shared Function Decrypt(ByVal pToDecrypt As String, ByVal sKey As String) As StringDim des As New DESCryptoServiceProvider()'把字符串放入byte数组Dim len As Integerlen = pT oDecrypt.Length / 2 - 1Dim inputByteArray(len) As ByteDim x, i As IntegerFor x = 0 To leni = Convert.T oInt32(pToDecrypt.Substring(x * 2, 2), 16)inputByteArray(x) = CType(i, Byte)Next'建立加密对象的密钥和偏移量，此值重要，不能修改des.Key = ASCIIEncoding.ASCII.GetBytes(sKey)des.IV = ASCIIEncoding.ASCII.GetBytes(sKey)Dim ms As New System.IO.MemoryStream()Dim cs As New CryptoStream(ms, des.CreateDecryptor, CryptoStreamMode.Write)cs.Write(inputByteArray, 0, inputByteArray.Length)cs.FlushFinalBlock()Return Encoding.Default.GetString(ms.ToArray)End FunctionEnd Class。

浅谈常见的七种加密算法及实现前⾔数字签名、信息加密是前后端开发都经常需要使⽤到的技术，应⽤场景包括了⽤户登⼊、交易、信息通讯、oauth等等，不同的应⽤场景也会需要使⽤到不同的签名加密算法，或者需要搭配不⼀样的签名加密算法来达到业务⽬标。

这⾥简单的给⼤家介绍⼏种常见的签名加密算法和⼀些典型场景下的应⽤。

正⽂1. 数字签名数字签名，简单来说就是通过提供可鉴别的数字信息验证⾃⾝⾝份的⼀种⽅式。

⼀套数字签名通常定义两种互补的运算，⼀个⽤于签名，另⼀个⽤于验证。

分别由发送者持有能够代表⾃⼰⾝份的私钥 (私钥不可泄露),由接受者持有与私钥对应的公钥，能够在接受到来⾃发送者信息时⽤于验证其⾝份。

注意：图中加密过程有别于公钥加密，更多。

签名最根本的⽤途是要能够唯⼀证明发送⽅的⾝份，防⽌中间⼈攻击、CSRF跨域⾝份伪造。

基于这⼀点在诸如设备认证、⽤户认证、第三⽅认证等认证体系中都会使⽤到签名算法 (彼此的实现⽅式可能会有差异)。

2. 加密和解密2.1. 加密数据加密的基本过程，就是对原来为明⽂的⽂件或数据按某种算法进⾏处理，使其成为不可读的⼀段代码，通常称为 “密⽂”。

通过这样的途径，来达到保护数据不被⾮法⼈窃取、阅读的⽬的。

2.2. 解密加密的逆过程为解密，即将该编码信息转化为其原来数据的过程。

3. 对称加密和⾮对称加密加密算法分对称加密和⾮对称加密，其中对称加密算法的加密与解密密钥相同，⾮对称加密算法的加密密钥与解密密钥不同，此外，还有⼀类不需要密钥的散列算法。

常见的对称加密算法主要有DES、3DES、AES等，常见的⾮对称算法主要有RSA、DSA等，散列算法主要有SHA-1、MD5等。

3.1. 对称加密对称加密算法是应⽤较早的加密算法，⼜称为共享密钥加密算法。

在对称加密算法中，使⽤的密钥只有⼀个，发送和接收双⽅都使⽤这个密钥对数据进⾏加密和解密。

这就要求加密和解密⽅事先都必须知道加密的密钥。

1. 数据加密过程：在对称加密算法中，数据发送⽅将明⽂ (原始数据) 和加密密钥⼀起经过特殊加密处理，⽣成复杂的加密密⽂进⾏发送。

TEA加密解密算法在游戏项⽬中，⼀般需要对资源或数据进⾏加密保护，最简单⾼效的加密算法就是采⽤位与或之类的，但是⽐较容易被⼈分析出来。

TEA加密算法不但⽐较简单，⽽且有很强的抗差分分析能⼒，加密速度也⽐较快。

可以根据项⽬需求设置加密轮数来增加加密强度。

1.加密核⼼函数1void EncryptTEA(unsigned int *firstChunk, unsigned int *secondChunk, unsigned int* key)2 {3 unsigned int y = *firstChunk;4 unsigned int z = *secondChunk;5 unsigned int sum = 0;67 unsigned int delta = 0x9e3779b9;89for (int i = 0; i < 8; i++)//8轮运算(需要对应下⾯的解密核⼼函数的轮数⼀样)10 {11 sum += delta;12 y += ((z << 4) + key[0]) ^ (z + sum) ^ ((z >> 5) + key[1]);13 z += ((y << 4) + key[2]) ^ (y + sum) ^ ((y >> 5) + key[3]);14 }1516 *firstChunk = y;17 *secondChunk = z;18 }2.解密核⼼函数1void DecryptTEA(unsigned int *firstChunk, unsigned int *secondChunk, unsigned int* key)2 {3 unsigned int sum = 0;4 unsigned int y = *firstChunk;5 unsigned int z = *secondChunk;6 unsigned int delta = 0x9e3779b9;78 sum = delta << 3; //32轮运算，所以是2的5次⽅；16轮运算，所以是2的4次⽅；8轮运算，所以是2的3次⽅910for (int i = 0; i < 8; i++) //8轮运算11 {12 z -= (y << 4) + key[2] ^ y + sum ^ (y >> 5) + key[3];13 y -= (z << 4) + key[0] ^ z + sum ^ (z >> 5) + key[1];14 sum -= delta;15 }1617 *firstChunk = y;18 *secondChunk = z;19 }3.封装对输⼊数据进⾏加密函数1//buffer：输⼊的待加密数据buffer，在函数中直接对元数据buffer进⾏加密；size：buffer长度；key是密钥；2void EncryptBuffer(char* buffer, int size, unsigned int* key)3 {4char *p = buffer;56int leftSize = size;78while (p < buffer + size &&9 leftSize >= sizeof(unsigned int) * 2)10 {11 EncryptTEA((unsigned int *)p, (unsigned int *)(p + sizeof(unsigned int)), key);12 p += sizeof(unsigned int) * 2;1314 leftSize -= sizeof(unsigned int) * 2;15 }16 }4.封装对加密数据进⾏解密函数1//buffer：输⼊的待解密数据buffer，在函数中直接对元数据buffer进⾏解密；size：buffer长度；key是密钥；2void DecryptBuffer(char* buffer, int size, unsigned int* key)3 {4char *p = buffer;56int leftSize = size;78while (p < buffer + size &&9 leftSize >= sizeof(unsigned int) * 2)10 {11 DecryptTEA((unsigned int *)p, (unsigned int *)(p + sizeof(unsigned int)), key);12 p += sizeof(unsigned int) * 2;1314 leftSize -= sizeof(unsigned int) * 2;15 }16 }5.测试加密/解密⽂件例⼦(windows下)1//-----设置密钥，必须需要16个字符或以上（这⾥的长度错误由评论#3楼legion提出修正，表⽰感谢。

数据的加密传输——单⽚机上实现TEA加密解密算法（转）源： 各位⼤侠在做数据传输时，有没有考虑过把数据加密起来进⾏传输，若在串⼝或者⽆线中把所要传的数据加密起来，岂不是增加了通信的安全性。

常⽤的加密解密算法⽐如DES、RSA等，受限于单⽚机的内存和运算速度，实现起来⽐较困难，但⼀种叫TEA的加密算法特别适合单⽚机使⽤。

TEA(Tiny Encryption Algorithm)是⼀种简单⾼效的加密算法，以加密解密速度快，实现简单著称。

算法很简单，TEA算法每⼀次可以操作64-bit(8-byte)，采⽤128-bit(16-byte)作为key，算法采⽤迭代的形式，推荐的迭代轮数是64轮，最少32轮。

⽬前我只知道QQ⼀直⽤的是16轮TEA。

我之前做过⼀个数字的⽆线对讲机，把语⾳数据加密后发送，双⽅事先规定好公共的密钥，就可以进⾏加密和解密了。

⾄于TEA算法速度，在我看来确实很快，我当时⽤的是16位的msp430单⽚机，晶振只有6M，每秒钟⼤概可以进⾏两三百次加密和解密的操作（⼀次加密和解密32字节）。

说到加密，最简单的⽅式就是把要发送的数据和同样长度的密码进⾏异或运算，得到新的数据就是加密后的数据，然后，接收⽅把加密数据和密码进⾏异或就能得到原始数据。

但这种异或的⽅法安全性如何，我也说不清楚。

下⾯上传了c++实现的TEA算法，可以在vc⾥⾯调试看看。

我把它改了改，让它适合单⽚机使⽤，下⾯的TEA.h和TEA.c可以包含在你的⼯程⾥⾯。

使⽤时，根据你所要加密的数据包长度修改宏定义BLOCK_SIZE，密钥的长度是16字节。

数据和密钥都是存放在数组⾥⾯的，⽐如：//TEA密钥unsigned char TEA_key[16]={0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,0x10};//数据缓冲区unsigned char TX_buffer[32];unsigned char RX_buffer[32];加密时使⽤函数：btea_encrypt(TX_buffer,TEA_key); //TEA加密这样，数组TX_buffer⾥⾯的新内容就是加密后的数据。

java加密算法⼊门（四）-加密算法汇总如基本的单向加密算法：BASE64 严格地说，属于编码格式，⽽⾮加密算法MD5(Message Digest algorithm 5，信息摘要算法)SHA(Secure Hash Algorithm，安全散列算法)HMAC(Hash Message Authentication Code，散列消息鉴别码)复杂的对称加密（DES、PBE）、⾮对称加密算法：DES(Data Encryption Standard，数据加密算法)PBE(Password-based encryption，基于密码验证)RSA(算法的名字以发明者的名字命名：Ron Rivest, AdiShamir 和Leonard Adleman)DH(Diffie-Hellman算法，密钥⼀致协议)DSA(Digital Signature Algorithm，数字签名)ECC(Elliptic Curves Cryptography，椭圆曲线密码编码学)本篇内容简要介绍BASE64、MD5、SHA、HMAC⼏种⽅法。

MD5、SHA、HMAC这三种加密算法，可谓是⾮可逆加密，就是不可解密的加密⽅法。

我们通常只把他们作为加密的基础。

单纯的以上三种的加密并不可靠。

BASE64按照RFC2045的定义，Base64被定义为：Base64内容传送编码被设计⽤来把任意序列的8位字节描述为⼀种不易被⼈直接识别的形式。

（The Base64 Content-Transfer-Encoding is designed to represent arbitrary sequences of octets in a form that need not be humanly readable.）常见于邮件、http加密，截取http信息，你就会发现登录操作的⽤户名、密码字段通过BASE64加密的。

通过java代码实现如下：12 3 4 5 6 7 8 9/*** BASE64解密** @param key* @return* @throws Exception*/public static byte[] decryptBASE64(String key) throws Exception { return(new BASE64Decoder()).decodeBuffer(key);9101112131415161718192021return (new BASE64Decoder()).decodeBuffer(key);}/*** BASE64加密 * * @param key * @return* @throws Exception*/ public static String encryptBASE64(byte[] key) throws Exception { return (new BASE64Encoder()).encodeBuffer(key); }主要就是BASE64Encoder 、BASE64Decoder 两个类，我们只需要知道使⽤对应的⽅法即可。

DES加密算法详细过程DES（Data Encryption Standard）是一种对称加密算法，采用了64位加密块和56位密钥。

下面将详细介绍DES加密算法的过程。

1. 初始置换（Initial Permutation IP）：首先，将明文划分为64位的分组，并根据初始置换矩阵IP对分组进行重排。

该矩阵定义了分组中每一位的位置。

2.密钥生成将56位的密钥进行置换选择（Permutation Choice 1，PC-1），根据预定义的置换矩阵将密钥的各个位重新组合，得到56位的置换密钥C0和D0。

接下来，通过循环左移操作（circular left shift）将置换密钥分为两个28位的子密钥C1和D1、左移的位数根据循环左移表格确定。

然后，对C1和D1重复循环左移操作，得到16个子密钥Ci和Di，其中i表示循环次数。

每次循环左移的位数由循环左移表格指定。

最后，通过置换选择2（Permutation Choice 2，PC-2）将Ci和Di 重新置换，得到16个48位的子密钥Ki，即轮密钥。

3.加密过程对明文分组进行初始置换得到L0和R0，分别为32位。

进入16轮加密过程，每轮的操作如下：- 用Ri-1和轮密钥Ki进行扩展置换（Expansion Permutation），将32位扩展为48位。

-将扩展后的结果与轮密钥Ki进行异或操作，得到48位的结果。

-将异或结果分为8个6位的子分组。

- 对每一个子分组进行S盒替代（Substitution Boxes），将6位的输入转换为4位的输出。

-将替代结果连接起来，得到32位的结果。

- 将32位的结果经过P盒置换（Permutation Box）进行重排。

-将P盒置换后的结果与Li-1进行异或操作，得到Ri。

-将Ri和Li-1交换，作为下一轮的输入。

经过16轮的加密过程后，得到R16和L16、将它们连接起来得到64位的分组。

然后，根据初始置换矩阵的逆矩阵IP-1对分组进行逆置换，得到密文。