对称式加密算法有哪些应用

Ⅰ 对称加密算法的应用模式

加密模式(英文名称及简写) 中文名称 Electronic Code Book(ECB) 电子密码本模式 Cipher Block Chaining(CBC) 密码分组链接模式 Cipher Feedback Mode(CFB) 加密反馈模式 Output Feedback Mode(OFB) 输出反馈模式 ECB：最基本的加密模式，也就是通常理解的加密，相同的明文将永远加密成相同的密文，无初始向量，容易受到密码本重放攻击，一般情况下很少用。
CBC：明文被加密前要与前面的密文进行异或运算后再加密，因此只要选择不同的初始向量，相同的密文加密后会形成不同的喊空密文，这是目前应用最广泛的模式。CBC加密后的密文是上下文相关的，但明文的错误不会传递到后续分组，但如果一个分组丢失，后面的分组将全部作废(同步错误)。
CFB：类似于自同步序列密码，分组加密后，按8位分组将密文和明文进行移位异或后得到输出同时反馈回移位寄存器，优点最小可以按字节进行加解纳洞密，也可以是n位的，CFB也是上下文相关的，CFB模式下，明文的一个郑茄瞎错误会影响后面的密文(错误扩散)。
OFB：将分组密码作为同步序列密码运行，和CFB相似，不过OFB用的是前一个n位密文输出分组反馈回移位寄存器，OFB没有错误扩散问题。

Ⅱ 对称加密算法与非对称加密算法的特点及用途

对称加密算法
对称加密算法是应用较早的加密算法，技术成熟。在对称加密算法中，数据发信方将明文（原始数据）和加密密钥一起经过特殊加密算法处理后，使其变成复杂的加密密文发送出去。收信方收到密文后，若想解读原文，则需要使用加密用过的密钥及相同算法的逆算法对密文进行解密，才能使其恢复成可读明文。在对称加密算法中，使用的密钥只有一个，发收信双方都使用这个密钥对数据进行加密和解密，这就要求解密方事先必须知道加密密钥。
对称加密算法的特点是算法公开、计算量小、加密速度快、加密效率高。不足之处是，交易双方都使用同样钥匙，安全性得不到保证。此外，每对用户每次使用对称加密算法时，都需要使用其他人不知道的惟一钥匙，这会使得发收信双方所拥有的钥匙数量成几何级数增长，密钥管理成为用户的负担。对称加密算法在分布式网络系统上使用较为困难，主要是因为密钥管理困难，使用成本较高。在计算机专网系统中广泛使用的对称加密算法有des、idea和aes。
不对称加密算法
不对称加密算法使用两把完全不同但又是完全匹配的一对钥匙—公钥和私钥。在使用不对称加密算法加密文件时，只有使用匹配的一对公钥和私钥，才能完成对明文的加密和解密过程。加密明文时采用公钥加密，解密密文时使用私钥才能完成，而且发信方（加密者）知道收信方的公钥，只有收信方（解密者）才是唯一知道自己私钥的人。不对称加密算法的基本原理是，如果发信方想发送只有收信方才能解读的加密信息，发信方必须首先知道收信方的公钥，然后利用收信方的公钥来加密原文；收信方收到加密密文后，使用自己的私钥才能解密密文。显然，采用不对称加密算法，收发信双方在通信之前，收信方必须将自己早已随机生成的公钥送给发信方，而自己保留私钥。由于不对称算法拥有两个密钥，因而特别适用于分布式系统中的数据加密。广泛应用的不对称加密算法有rsa算法和美国国家标准局提出的dsa。以不对称加密算法为基础的加密技术应用非常广泛。

Ⅲ 对称加密算法以及使用方法

加密的原因：保证数据安全

加密必备要素：1、明文/密文    2、秘钥    3、算法

秘钥：在密码学中是一个定长的字符串、需要根据加密算法确定其长度

加密算法解密算法一般互逆、也可能相同

常用的两种加密方式：

对称加密：秘钥：加密解密使用同一个密钥、数据的机密性双向保证、加密效率高、适合加密于大数据大文件、加密强度不高(相对于非对称加密)

非对称加密：秘钥：加密解密使用的不同秘钥、有两个密钥、需要使用密钥生成算法生成两个秘钥、数据的机密性只能单向加密、如果想解决这个问题、双向都需要各自有一对秘钥、加密效率低、加密强度高

                    公钥：可以公开出来的密钥、公钥加密私钥解密

                    私钥：需要自己妥善保管、不能公开、私钥加密公钥解密

安全程度高：多次加密

按位异或运算

凯撒密码：加密方式    通过将铭文所使用的字母表按照一定的字数平移来进行加密

mod：取余

加密三要素：明文/密文(字母)、秘钥(3)、算法(向右平移3/-3)

安全常识：不要使用自己研发的算法、不要钻牛角尖、没必要研究底层实现、了解怎么应用；低强度的密码比不进行任何加密更危险；任何密码都会被破解；密码只是信息安全的一部分

保证数据的机密性、完整性、认证、不可否认性

计算机操作对象不是文字、而是由0或1排列而成的比特序列、程序存储在磁盘是二进制的字符串、为比特序列、将现实的东西映射为比特序列的操作称为编码、加密又称之为编码、解密称之为解码、根据ASCII对照表找到对应的数字、转换成二进制

三种对称加密算法：DES\3DES\ AES  

DES：已经被破解、除了用它来解密以前的明文、不再使用

密钥长度为56bit/8、为7byte、每隔7个bit会设置一个用于错误检查的比特、因此实际上是64bit

分组密码(以组为单位进行处理)：加密时是按照一个单位进行加密(8个字节/64bit为一组)、每一组结合秘钥通过加密算法得到密文、加密后的长度不变

3DES:三重DES为了增加DES的强度、将DES重复三次所得到的一种加密算法   密钥长度24byte、分成三份  加密--解密--加密 目的：为了兼容DES、秘钥1秘钥2相同==三个秘钥相同  ---加密一次        密钥1秘钥3相同--加密三次    三个密钥不相同最好、此时解密相当于加密、中间的一次解密是为了有三个密钥相同的情况

此时的解密操作与加密操作互逆，安全、效率低

数据先解密后加密可以么？可以、解密相当于加密、加密解密说的是算法

AES：(首选推荐)底层算法为Rijndael   分组长度为128bit、密钥长度为128bit到256bit范围内就可以   但是在AES中、密钥长度只有128bit\192bit\256bit     在go提供的接口中、只能是16字节(128bit)、其他语言中秘钥可以选择

目前为止最安全的、效率高

底层算法

分组密码的模式：

按位异或、对数据进行位运算、先将数据转换成二进制、按位异或操作符^、相同为真、不同为假、非0为假    按位异或一次为加密操作、按位异或两次为解密操作：a和b按位异或一次、结果再和b按位异或

ECB : 如果明文有规律、加密后的密文有规律不安全、go里不提供该接口、明文分组分成固定大小的块、如果最后一个分组不满足分组长度、则需要补位

CBC：密码链

问题：如何对字符串进行按位异或？解决了ECB的规律可查缺点、但是他不能并行处理、最后一个明文分组也需要填充 、初始化向量长度与分组长度相同

CFB:密文反馈模式

不需要填充最后一个分组、对密文进行加密

OFB：

不需要对最后一组进行填充

CTR计数器:

不需要对最后一组进行填充、不需要初始化向量     

Go中的实现

官方文档中：

在创建aes或者是des接口时都是调用如下的方法、返回的block为一个接口

func NewCipher(key [] byte ) ( cipher . Block , error )

type Block interface {

    // 返回加密字节块的大小

    BlockSize() int

    // 加密src的第一块数据并写入dst，src和dst可指向同一内存地址

    Encrypt(dst, src []byte)

    // 解密src的第一块数据并写入dst，src和dst可指向同一内存地址

    Decrypt(dst, src []byte)

}

Block接口代表一个使用特定密钥的底层块加/解密器。它提供了加密和解密独立数据块的能力。

Block的Encrypt/Decrypt也能进行加密、但是只能加密第一组、因为aes的密钥长度为16、所以进行操作的第一组数据长度也是16

如果分组模式选择的是cbc

func NewCBCEncrypter(b Block, iv []byte) BlockMode    加密

func NewCBCDecrypter(b Block, iv []byte) BlockMode    解密

加密解密都调用同一个方法CryptBlocks()

并且cbc分组模式都会遇到明文最后一个分组的补充、所以会用到加密字节的大小

返回一个密码分组链接模式的、底层用b加密的BlockMode接口，初始向量iv的长度必须等于b的块尺寸。iv自己定义

返回的BlockMode同样也是一个接口类型

type BlockMode interface {

    // 返回加密字节块的大小

    BlockSize() int

    // 加密或解密连续的数据块，src的尺寸必须是块大小的整数倍，src和dst可指向同一内存地址

    CryptBlocks(dst, src []byte)

}

BlockMode接口代表一个工作在块模式（如CBC、ECB等）的加/解密器

返回的BlockMode其实是一个cbc的指针类型中的b和iv

# 加密流程: 

1. 创建一个底层使用des/3des/aes的密码接口 "crypto/des" func NewCipher(key []byte) (cipher.Block, error) # -- des func NewTripleDESCipher(key []byte) (cipher.Block, error) # -- 3des "crypto/aes" func NewCipher(key []byte) (cipher.Block, error) # == aes 

2. 如果使用的是cbc/ecb分组模式需要对明文分组进行填充

3. 创建一个密码分组模式的接口对象 - cbc func NewCBCEncrypter(b Block, iv []byte) BlockMode # 加密 - cfb func NewCFBEncrypter(block Block, iv []byte) Stream # 加密 - ofb - ctr

 4. 加密, 得到密文

流程：

填充明文：

先求出最后一组中的字节数、创建新切片、长度为新切片、值也为切片的长度、然后利用bytes.Reapet将长度换成字节切片、追加到原明文中

//明文补充

func padPlaintText(plaintText []byte,blockSize int)[]byte{

    //1、求出需要填充的个数

    padNum := blockSize-len(plaintText) % blockSize

    //2、对填充的个数进行操作、与原明文进行合并

    newPadding := []byte{byte(padNum)}

    newPlain := bytes.Repeat(newPadding,padNum)

    plaintText = append(plaintText,newPlain...)

    return plaintText

}

去掉填充数据：

拿去切片中的最后一个字节、得到尾部填充的字节个数、截取返回

//解密后的明文曲调补充的地方

func createPlaintText(plaintText []byte,blockSize int)[]byte{

    //1、得到最后一个字节、并将字节转换成数字、去掉明文中此数字大小的字节

    padNum := int(plaintText[len(plaintText)-1])

    newPadding := plaintText[:len(plaintText)-padNum]

    return newPadding

}

des加密：

1、创建一个底层使用des的密码接口、参数为秘钥、返回一个接口

2、对明文进行填充

3、创建一个cbc模式的接口、需要创建iv初始化向量、返回一个blockmode对象

4、加密、调用blockmode中的cryptBlock函数进行加密、参数为目标参数和源参数

//des利用分组模式cbc进行加密

func EncryptoText(plaintText []byte,key []byte)[]byte{

    //1、创建des对象

    cipherBlock,err := des.NewCipher(key)

    if err != nil {

        panic(err)

    }

    //2、对明文进行填充

    newText := padPlaintText(plaintText,cipherBlock.BlockSize())

    //3、选择分组模式、其中向量的长度必须与分组长度相同

    iv := make([]byte,cipherBlock.BlockSize())

    blockMode := cipher.NewCBCEncrypter(cipherBlock,iv)

    //4、加密

    blockMode.CryptBlocks(newText,newText)

    return newText

}

des解密：

1、创建一个底层使用des的密码接口、参数为秘钥、返回一个接口

2、创建一个cbc模式的接口、需要创建iv初始化向量，返回一个blockmode对象

3、加密、调用blockmode中的cryptBlock函数进行解密、参数为目标参数和源参数

4、调用去掉填充数据的方法

//des利用分组模式cbc进行解密

func DecryptoText(cipherText []byte, key []byte)[]byte{

    //1、创建des对象

    cipherBlock,err := des.NewCipher(key)

    if err != nil {

        panic(err)

    }

    //2、创建cbc分组模式接口

    iv := []byte("12345678")

    blockMode := cipher.NewCBCDecrypter(cipherBlock,iv)

    //3、解密

    blockMode.CryptBlocks(cipherText,cipherText)

    //4、将解密后的数据进行去除填充的数据

    newText := clearPlaintText(cipherText,cipherBlock.BlockSize())

    return newText

}

Main函数调用

func main(){

    //需要进行加密的明文

    plaintText := []byte("CBC--密文没有规律、经常使用的加密方式，最后一个分组需要填充，需要初始化向量" +

        "(一个数组、数组的长度与明文分组相等、数据来源:负责加密的人提供，加解密使用的初始化向量必须相同)")

    //密钥Key的长度需要与分组长度相同、且加密解密的密钥相同

    key := []byte("1234abcd")

    //调用加密函数

    cipherText := EncryptoText(plaintText,key)

    newPlaintText := DecryptoText(cipherText,key)

    fmt.Println(string(newPlaintText))

}

AES加密解密相同、所以只需要调用一次方法就可以加密、调用两次则解密

推荐是用分组模式：cbc、ctr

aes利用分组模式cbc进行加密

//对明文进行补充

func paddingPlaintText(plaintText []byte , blockSize int ) []byte {

    //1、求出分组余数

    padNum := blockSize - len(plaintText) % blockSize

    //2、将余数转换为字节切片、然后利用bytes.Repeat得出有该余数的大小的字节切片

    padByte := bytes.Repeat([]byte{byte(padNum)},padNum)

    //3、将补充的字节切片添加到原明文中

    plaintText = append(plaintText,padByte...)

    return plaintText

}

//aes加密

func encryptionText(plaintText []byte, key []byte) []byte {

    //1、创建aes对象

    block,err := aes.NewCipher(key)

    if err != nil {

        panic(err)

    }

    //2、明文补充

    newText := paddingPlaintText(plaintText,block.BlockSize())

    //3、创建cbc对象

    iv := []byte("12345678abcdefgh")

    blockMode := cipher.NewCBCEncrypter(block,iv)

    //4、加密

    blockMode.CryptBlocks(newText,newText)

    return newText

}

//解密后的去尾

func clearplaintText(plaintText []byte, blockSize int) []byte {

    //1、得到最后一个字节、并转换成整型数据

    padNum := int(plaintText[len(plaintText)-1])

    //2、截取明文字节中去掉得到的整型数据之前的数据、此处出错、没有用len-padNum

    newText := plaintText[:len(plaintText)-padNum]

    return newText

}

//aes解密

func deCryptionText(crypherText []byte, key []byte ) []byte {

    //1、创建aes对象

    block, err := aes.NewCipher(key)

    if err != nil {

        panic(err)

    }

    //2、创建cbc对象

    iv := []byte("12345678abcdefgh")

    blockMode := cipher.NewCBCDecrypter(block,iv)

    //3、解密

    blockMode.CryptBlocks(crypherText,crypherText)

    //4、去尾

    newText := clearplaintText(crypherText,block.BlockSize())

    return newText

}

func main(){

    //需要进行加密的明文

    plaintText := []byte("CBC--密文没有规律、经常使用的加密方式，最后一个分组需要填充，需要初始化向量")

    //密钥Key的长度需要与分组长度相同、且加密解密的密钥相同

    key := []byte("12345678abcdefgh")

    //调用加密函数

    cipherText := encryptionText(plaintText,key)

    //调用解密函数

    newPlaintText := deCryptionText(cipherText,key)

    fmt.Println("解密后",string(newPlaintText))

}

//aes--ctr加密

func encryptionCtrText(plaintText []byte, key []byte) []byte {

    //1、创建aes对象

    block,err := aes.NewCipher(key)

    if err != nil {

        panic(err)

    }

    //2、创建ctr对象，虽然ctr模式不需要iv，但是go中使用ctr时还是需要iv

    iv := []byte("12345678abcdefgh")

    stream := cipher.NewCTR(block,iv)

    stream.XORKeyStream(plaintText,plaintText)

    return plaintText

}

func main() {

//aes--ctr加密解密、调用两次即为解密、因为加密解密函数相同stream.XORKeyStream

    ctrcipherText := encryptionCtrText(plaintText, key)

    ctrPlaintText := encryptionCtrText(ctrcipherText,key)

    fmt.Println("aes解密后", string(ctrPlaintText))

}

英文单词：

明文：plaintext     密文：ciphertext   填充：padding/fill    去掉clear  加密Encryption  解密Decryption

Ⅳ 常见的加密算法、原理、优缺点、用途

在安全领域，利用密钥加密算法来对通信的过程进行加密是一种常见的安全手段。利用该手段能够保障数据安全通信的三个目标：

而常见的密钥加密算法类型大体可以分为三类：对称加密、非对称加密、单向加密。下面我们来了解下相关的算法原理及其常见的算法。

在加密传输中最初是采用对称密钥方式，也就是加密和解密都用相同的密钥。

1.对称加密算法采用单密钥加密，在通信过程中，数据发送方将原始数据分割成固定大小的块，经过密钥和加密算法逐个加密后，发送给接收方

2.接收方收到加密后的报文后，结合解密算法使用相同密钥解密组合后得出原始数据。

图示：

非对称加密算法采用公钥和私钥两种不同的密码来进行加解密。公钥和私钥是成对存在，公钥是从私钥中提取产生公开给所有人的，如果使用公钥对数据进行加密，那么只有对应的私钥（不能公开）才能解密，反之亦然。N 个用户通信，需要2N个密钥。

非对称密钥加密适合对密钥或身份信息等敏感信息加密，从而在安全性上满足用户的需求。

1.甲使用乙的公钥并结合相应的非对称算法将明文加密后发送给乙，并将密文发送给乙。
2.乙收到密文后，结合自己的私钥和非对称算法解密得到明文，得到最初的明文。

图示：

单向加密算法只能用于对数据的加密，无法被解密，其特点为定长输出、雪崩效应（少量消息位的变化会引起信息摘要的许多位变化）。

单向加密算法常用于提取数据指纹，验证数据的完整性、数字摘要、数字签名等等。

1.发送者将明文通过单向加密算法加密生成定长的密文串，然后传递给接收方。

2.接收方将用于比对验证的明文使用相同的单向加密算法进行加密，得出加密后的密文串。

3.将之与发送者发送过来的密文串进行对比，若发送前和发送后的密文串相一致，则说明传输过程中数据没有损坏；若不一致，说明传输过程中数据丢失了。

图示：

MD5、sha1、sha224等等

密钥交换IKE（Internet Key Exchange）通常是指双方通过交换密钥来实现数据加密和解密

常见的密钥交换方式有下面两种：

将公钥加密后通过网络传输到对方进行解密，这种方式缺点在于具有很大的可能性被拦截破解，因此不常用

DH算法是一种密钥交换算法，其既不用于加密，也不产生数字签名。

DH算法通过双方共有的参数、私有参数和算法信息来进行加密，然后双方将计算后的结果进行交换，交换完成后再和属于自己私有的参数进行特殊算法，经过双方计算后的结果是相同的，此结果即为密钥。

如：

安全性

在整个过程中，第三方人员只能获取p、g两个值，AB双方交换的是计算后的结果，因此这种方式是很安全的。

答案：使用公钥证书

公钥基础设施是一个包括硬件、软件、人员、策略和规程的集合

用于实现基于公钥密码机制的密钥和证书的生成、管理、存储、分发和撤销的功能

签证机构CA、注册机构RA、证书吊销列表CRL和证书存取库CB。

公钥证书是以数字签名的方式声明，它将公钥的值绑定到持有对应私钥的个人、设备或服务身份。公钥证书的生成遵循X.509协议的规定，其内容包括：证书名称、证书版本、序列号、算法标识、颁发者、有效期、有效起始日期、有效终止日期、公钥 、证书签名等等的内容。

1.客户A准备好要传送的数字信息（明文）。（准备明文）

2.客户A对数字信息进行哈希（hash）运算，得到一个信息摘要。（准备摘要）

3.客户A用CA的私钥（SK）对信息摘要进行加密得到客户A的数字签名，并将其附在数字信息上。（用私钥对数字信息进行数字签名）

4.客户A随机产生一个加密密钥（DES密钥），并用此密钥对要发送的信息进行加密，形成密文。 （生成密文）

5.客户A用双方共有的公钥（PK）对刚才随机产生的加密密钥进行加密，将加密后的DES密钥连同密文一起传送给乙。（非对称加密，用公钥对DES密钥进行加密）

6.银行B收到客户A传送过来的密文和加过密的DES密钥，先用自己的私钥（SK）对加密的DES密钥进行解密，得到DES密钥。（用私钥对DES密钥解密）

7.银行B然后用DES密钥对收到的密文进行解密，得到明文的数字信息，然后将DES密钥抛弃（即DES密钥作废）。（解密文）

8.银行B用双方共有的公钥（PK）对客户A的数字签名进行解密，得到信息摘要。银行B用相同的hash算法对收到的明文再进行一次hash运算，得到一个新的信息摘要。（用公钥解密数字签名）

9.银行B将收到的信息摘要和新产生的信息摘要进行比较，如果一致，说明收到的信息没有被修改过。（对比信息摘要和信息）

答案是没法保证CA的公钥没有被篡改。通常操作系统和浏览器会预制一些CA证书在本地。所以发送方应该去那些通过认证的CA处申请数字证书。这样是有保障的。

但是如果系统中被插入了恶意的CA证书，依然可以通过假冒的数字证书发送假冒的发送方公钥来验证假冒的正文信息。所以安全的前提是系统中不能被人插入非法的CA证书。

END

Ⅳ 什么是对称加密算法请举例

对称加密算法简介：
对称加密算法 对称加密算法是应用较早的加密算法，技术成熟。在对称加密算法中，数据发信方将明文（原始数据）和加密密钥一起经过特殊加密算法处理后，使其变成复杂的加密密文发送出去。收信方收到密文后，若想解读原文，则需要使用加密用过的密钥及相同算法的逆算法对密文进行解密，才能使其恢复成可读明文。在对称加密算法中，使用的密钥只有一个，发收信双方都使用这个密钥对数据进行加密和解密，这就要求解密方事先必须知道加密密钥。
特点：
对称加密算法的特点是算法公开、计算量小、加密速度快、加密效率高。
不足之处是，交易双方都使用同样钥匙，安全性得不到保证。此外，每对用户每次使用对称加密算法时，都需要使用其他人不知道的惟一钥匙，这会使得发收信双方所拥有的钥匙数量成几何级数增长，密钥管理成为用户的负担。对称加密算法在分布式网络系统上使用较为困难，主要是因为密钥管理困难，使用成本较高。而与公开密钥加密算法比起来，对称加密算法能够提供加密和认证却缺乏了签名功能，使得使用范围有所缩小。在计算机专网系统中广泛使用的对称加密算法有DES和IDEA等。美国国家标准局倡导的AES即将作为新标准取代DES。
具体算法：
3DES算法，Blowfish算法，RC5算法。 对称加密算法-原理及应用对称加密算法的优点在于加解密的高速度和使用长密钥时的难破解性。假设两个用户需要使用对称加密方法加密然后交换数据，则用户最少需要2个密钥并交换使用，如果企业内用户有n个，则整个企业共需要n×(n-1) 个密钥，密钥的生成和分发将成为企业信息部门的恶梦。对称加密算法的安全性取决于加密密钥的保存情况，但要求企业中每一个持有密钥的人都保守秘密是不可能的，他们通常会有意无意的把密钥泄漏出去——如果一个用户使用的密钥被入侵者所获得，入侵者便可以读取该用户密钥加密的所有文档，如果整个企业共用一个加密密钥，那整个企业文档的保密性便无从谈起。DESCryptoServiceProvider
RC2CryptoServiceProvider
RijndaelManaged

//例加密文本文件(RijndaelManaged )
byte[] key = { 24, 55, 102,24, 98, 26, 67, 29, 84, 19, 37, 118, 104, 85, 121, 27, 93, 86, 24, 55, 102, 24,98, 26, 67, 29, 9, 2, 49, 69, 73, 92 };
byte[] IV ={ 22, 56, 82, 77, 84, 31, 74, 24,55, 102, 24, 98, 26, 67, 29, 99 };
RijndaelManaged myRijndael = new RijndaelManaged();
FileStream fsOut = File.Open(strOutName, FileMode.Create,FileAccess.Write);//strOutName文件名及路径 FileStream fsIn = File.Open(strPath, FileMode.Open,FileAccess.Read);
CryptoStream csDecrypt=new CryptoStream(fsOut,myRijndael.CreateEncryptor(key, IV),CryptoStreamMode.Write);//读加密文本
BinaryReader br = new BinaryReader(fsIn);
csDecrypt.Write(br.ReadBytes((int)fsIn.Length),0, (int)fsIn.Length);
csDecrypt.FlushFinalBlock();
csDecrypt.Close();
fsIn.Close();
fsOut.Close();
//解密文件
byte[] key = { 24, 55, 102, 24, 98, 26, 67, 29, 84, 19, 37, 118,104, 85, 121, 27, 93, 86, 24, 55, 102, 24, 98, 26, 67, 29, 9, 2, 49, 69, 73, 92};
byte[] IV ={ 22, 56, 82, 77, 84, 31, 74, 24, 55, 102, 24, 98, 26,67, 29, 99 };
RijndaelManaged myRijndael = new RijndaelManaged();
FileStream fsOut = File.Open(strPath, FileMode.Open, FileAccess.Read);
CryptoStream csDecrypt = new CryptoStream(fsOut, myRijndael.CreateDecryptor(key,IV), CryptoStreamMode.Read);
StreamReader sr = new StreamReader(csDecrypt);//把文件读出来
StreamWriter sw = new StreamWriter(strInName);//解密后文件写入一个新的文件
sw.Write(sr.ReadToEnd());
sw.Flush();
sw.Close();
sr.Close();f
sOut.Close();
用图片加密(RC2CryptoServiceProvider )
FileStreamfsPic = new FileStream(pictureBox1.ImageLocation,FileMode.Open, FileAccess.Read);
//加密文件流（textBox1.Text是文件名及路径）
FileStream fsText = new FileStream(textBox1.Text, FileMode.Open,FileAccess.Read);
byte[] bykey = new byte[16]; //初始化
Key IVbyte[] byIv = new byte[8];
fsPic.Read(bykey, 0, 16);
fsPic.Read(byIv, 0, 8);
RC2CryptoServiceProvider desc = newRC2CryptoServiceProvider();//desc进行加密
BinaryReader br = new BinaryReader(fsText);//从要加密的文件中读出文件内容
FileStream fsOut = File.Open(strLinPath,FileMode.Create, FileAccess.Write); // strLinPath临时加密文件路径CryptoStream cs = new CryptoStream(fsOut, desc.CreateEncryptor(bykey,byIv), CryptoStreamMode.Write);//写入临时加密文件
cs.Write(br.ReadBytes((int)fsText.Length),0, (int)fsText.Length);//写入加密流
cs.FlushFinalBlock();
cs.Flush();
cs.Close();
fsPic.Close();
fsText.Close();
fsOut.Close();
用图片解密
FileStream fsPic = new FileStream(pictureBox1.ImageLocation, FileMode.Open, FileAccess.Read); //图片流FileStream fsOut = File.Open(textBox1.Text,FileMode.Open, FileAccess.Read);//解密文件流
byte[] bykey = new byte[16]; //初始化
Key IVbyte[] byIv = new byte[8];
fsPic.Read(bykey, 0, 16);
fsPic.Read(byIv, 0, 8);
string strPath = textBox1.Text;//加密文件的路径
int intLent = strPath.LastIndexOf("\\")+ 1;
int intLong = strPath.Length;
string strName = strPath.Substring(intLent, intLong - intLent);//要加密的文件名称
string strLinPath = "C:\\"+ strName;//临时解密文件路径
FileStream fs = new FileStream(strLinPath, FileMode.Create,FileAccess.Write);
RC2CryptoServiceProvider desc = newRC2CryptoServiceProvider();//desc进行解密
CryptoStream csDecrypt = new CryptoStream(fsOut, desc.CreateDecryptor(bykey,byIv), CryptoStreamMode.Read);
//读出加密文件
BinaryReader sr = new BinaryReader(csDecrypt);//从要加密流中读出文件内容
BinaryWriter sw = new BinaryWriter(fs);//写入解密流
sw.Write(sr.ReadBytes(Convert.ToInt32(fsOut.Length)));
//sw.Flush();
sw.Close();
sr.Close();
fs.Close();
fsOut.Close();
fsPic.Close();
csDecrypt.Flush();
File.Delete(textBox1.Text.TrimEnd());//删除原文件
File.Copy(strLinPath, textBox1.Text);//复制加密文件
File.Delete(strLinPath);//删除临时文件

Ⅵ 什么是对称密码和非对密码,分析这两种密码体系的特点和应用领域

一、对称密码

1、定义：采用单钥密码系统的加密方法，同一个密钥可以同时用作信息的加密和解密，这种加密方法称为对称加密，也称为单密钥加密。

2、特点：算法公开、计算量小、加密速度快、加密效率高。

3、应用领域：由于其速度快，对称性加密通常在消息发送方需要加密大量数据时使用。

二、非对密码

1、定义：非对称密码指的是非对称密码体制中使用的密码。

2、特点：

（1）是加密密钥和解密密钥不同 ，并且难以互推 。

（2）是有一个密钥是公开的 ，即公钥 ，而另一个密钥是保密的 ，即私钥。

3、应用领域：很好的解决了密钥的分发和管理的问题 ，并且它还能够实现数字签名。

(6)对称式加密算法有哪些应用扩展阅读

对称加密算法特征

1、加密方和解密方使用同一个密钥；

2、加密解密的速度比较快，适合数据比较长时的使用；

3、密钥传输的过程不安全，且容易被破解，密钥管理也比较麻烦