精华内容
下载资源
问答
  • 密文反馈模式 cfbThis is Ciphertext feedback (CFB) which is also a mode of operation for a block cipher. In contrast to the cipher block chaining(CBC) mode, which encrypts a set number of bits of plain...

    密文反馈模式 cfb

    This is Ciphertext feedback (CFB) which is also a mode of operation for a block cipher. In contrast to the cipher block chaining(CBC) mode, which encrypts a set number of bits of plaintext or original text at a time, it is at times desirable or sensible to encrypt and transfer or exchange some plaintext or original text values instantly one at a time, for which ciphertext feedback is a method in cryptography. Like cipher block chaining(cbc), ciphertext feedback(cfb) also makes use of an initialization vector (IV) in the blocks. CFB uses a block cipher as a component of a different or random number generator in this. CFB mode, the previous ciphertext block is encrypted and the output is XORed (see XOR) with the current plaintext or original text block to create the current ciphertext block from this. The XOR operation conceals plaintext or original text patterns. Original text or plaintext cannot be directly worked on unless there is the retrieval of blocks from either the beginning or end of the ciphertext in the cryptography.

    这是密文反馈(CFB) ,也是块密码的一种操作模式。 与一次加密一定数量的纯文本或原始文本的密码块链接(CBC)模式相反,有时希望或明智的做法是立即加密并传输或交换某些纯文本或原始文本值。时间,密文反馈是密码学中的一种方法。 像密码块链接(cbc)一样,密文反馈(cfb)也使用了块中的初始化向量(IV)。 CFB在此使用分组密码作为不同或随机数生成器的组件。 在CFB模式下,先前的密文块被加密,并且输出与当前的纯文本或原始文本块进行异或(请参阅XOR)以由此创建当前的密文块。 XOR操作隐藏纯文本或原始文本模式。 除非可以从密码学中密文的开头或结尾检索块,否则无法直接处理原始文本或纯文本。

    This is entropy that results can be implemented or work as a stream cipher. CFB is primarily a mode to derive some characteristics of a stream cipher from a block cipher in the cryptography in cryptoanalysis. In common words with CBC mode, changing the IV to the same plaintext or original text block results in different outputs. Though the IV need not be secret, some applications would see this desirable or wise into this. This is Chaining dependencies are similar to CBC in the cryptography, in that reordering ciphertext block sequences alters decryption output, as decryption of one block depends on the decryption of the preceding blocks in the cryptography.

    这是熵,可以实现结果或将其作为流密码使用。 CFB主要是一种从密码分析中的密码学中的分组密码中得出流密码某些特性的模式。 通常,在CBC模式下,将IV更改为相同的纯文本或原始文本块会导致不同的输出。 尽管IV不必是秘密的,但某些应用程序会将此视为明智或明智的选择。 这是因为Chaining依赖性类似于密码学中的CBC,因为对一个密文块序列进行重新排序会更改解密输出,因为一个块的解密取决于加密术中前面几个块的解密。

    In this mode the cipher is given as feedback from the block to the next block of encryption with some new specifications of this feedback: first, an initial vector as an IV is used for first encryption and output bits from character are divided as set of s and b-s bits the left-hand side s bits are selected and are applied an XOR operation with plaintext or original text bits. The result is given as input to a shift register in the cryptography and the process continues. The encryption and decryption process for the same is shown below, both of them use encryption algorithm in this.

    在这种模式下,将密码作为从加密块到下一个加密块的反馈,并给出一些新的规范:首先,将初始向量作为IV用于第一次加密,并将字符的输出位划分为s集bs位和bs位选择左侧的s位,并将其与纯文本或原始文本位进行XOR操作。 结果被提供作为密码术中移位寄存器的输入,并且过程继续进行。 相同的加密和解密过程如下所示,两者都使用加密算法。

    操作方式 (Operation)

    The operation of CFB mode is depicted in the following illustration or steps. For example, like, in the present system, a message block has a size ‘s’ bits of character where (1 < s < n). The CFB mode requires an initialization vector (IV) as the initial random n-bit input block of the character. The IV need not be secret in this.

    下图或步骤描述了CFB模式的操作。 例如,像在本系统中一样,消息块的字符大小为's'位,其中(1 <s <n)。 CFB模式需要初始化向量(IV)作为字符的初始随机n位输入块。 IV不必为此保密。

    Steps of operation are,

    操作步骤如下:

    • Firstly, Load the IV in the top register.

      首先,将IV加载到顶部寄存器中。

    • Then, Encrypt the data value in the top register with the underlying block cipher with key K to the block.

      然后,使用底层密钥和密钥K对该块加密顶部寄存器中的数据值。

    • Then, take only 's' number of most significant bits as left bits of the output of the encryption process and XOR them with 's' bit plaintext or original text message block to generate ciphertext block in cryptography.

      然后,仅将“ s”个最高有效位作为加密过程输出的左位,然后将它们与“ s”位纯文本或原始文本消息块进行异或,以生成密码术中的密文块。

    • This, Feed ciphertext block into the top register by shifting already present data to the left and continue the operation till all plaintext or original text blocks are processed in this mode.

      这样,通过将已经存在的数据向左移动,将密文块送入顶部寄存器,并继续操作,直到在此模式下处理所有纯文本或原始文本块为止。

    • Essentially, the previous ciphertext block is encrypted with the key, and then the result is XORed to the current plaintext block or original text.

      本质上,前一个密文块用密钥加密,然后将结果与当前的明文块或原始文本进行异或。

    • Similar steps are followed for decryption cryptography. Pre-decided IV is initially loaded at the start of decryption in the cryptography.

      解密密码遵循类似的步骤。 预定的IV最初是在加密中解密开始时加载的。

    Ciphertext Feedback (CFB) in Cryptography


    Image source: https://www.geeksforgeeks.org/block-cipher-modes-of-operation/

    图片来源:https://www.geeksforgeeks.org/block-cipher-modes-of-operation/

    CFB的优势 (Advantages of CFB)

    Since, in this, there is some data loss due to the use of shift register of the block, thus it is difficult for applying cryptanalysis in the cryptography.

    由于在此由于使用块的移位寄存器而导致一些数据丢失,因此难以在密码术中应用密码分析。

    翻译自: https://www.includehelp.com/cryptography/ciphertext-feedback-cfb.aspx

    密文反馈模式 cfb

    展开全文
  • 今天密码学老师布置的实验是用AES密码通过密文反馈模式加密文件,AES密码我在别的大佬的博客上借用了一下https://blog.csdn.net/lisonglisonglisong/article/details/41909813 #include <iostream> #include...

    今天密码学老师布置的实验是用AES密码通过密文反馈模式加密文件,AES密码我在别的大佬的博客上借用了一下https://blog.csdn.net/lisonglisonglisong/article/details/41909813

    #include <iostream>
    #include <bitset>
    #include <string>
    #include <fstream>
    #include <cstdlib>
    using namespace std;
    typedef bitset<8> byte;
    typedef bitset<32> word;
    typedef struct {
    	char name;
    	byte value;
    }HEX;
    byte table[26] = {0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,0x70,0x71,
    0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A};
    const int Nr = 10;  // AES-128需要 10 轮加密
    const int Nk = 4;   // Nk 表示输入密钥的 word 个数
    
    byte S_Box[16][16] = {
    	{0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76},
    	{0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0},
    	{0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15},
    	{0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75},
    	{0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84},
    	{0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF},
    	{0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8},
    	{0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2},
    	{0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73},
    	{0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB},
    	{0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79},
    	{0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08},
    	{0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A},
    	{0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E},
    	{0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF},
    	{0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16}
    };
    
    byte Inv_S_Box[16][16] = {
    	{0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB},
    	{0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB},
    	{0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E},
    	{0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25},
    	{0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92},
    	{0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84},
    	{0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06},
    	{0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B},
    	{0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73},
    	{0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E},
    	{0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B},
    	{0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4},
    	{0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F},
    	{0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF},
    	{0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61},
    	{0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D}
    };
    
    // 轮常数,密钥扩展中用到。(AES-128只需要10轮)
    word Rcon[10] = { 0x01000000, 0x02000000, 0x04000000, 0x08000000, 0x10000000,
    				 0x20000000, 0x40000000, 0x80000000, 0x1b000000, 0x36000000 };
    
    /**********************************************************************/
    /*                                                                    */
    /*                              AES算法实现                           */
    /*                                                                    */
    /**********************************************************************/
    
    /******************************下面是加密的变换函数**********************/
    /**
     *  S盒变换 - 前4位为行号,后4位为列号
     */
    void SubBytes(byte mtx[4 * 4])
    {
    	for (int i = 0; i < 16; ++i)
    	{
    		int row = mtx[i][7] * 8 + mtx[i][6] * 4 + mtx[i][5] * 2 + mtx[i][4];
    		int col = mtx[i][3] * 8 + mtx[i][2] * 4 + mtx[i][1] * 2 + mtx[i][0];
    		mtx[i] = S_Box[row][col];
    	}
    }
    
    /**
     *  行变换 - 按字节循环移位
     */
    void ShiftRows(byte mtx[4 * 4])
    {
    	// 第二行循环左移一位
    	byte temp = mtx[4];
    	for (int i = 0; i < 3; ++i)
    		mtx[i + 4] = mtx[i + 5];
    	mtx[7] = temp;
    	// 第三行循环左移两位
    	for (int i = 0; i < 2; ++i)
    	{
    		temp = mtx[i + 8];
    		mtx[i + 8] = mtx[i + 10];
    		mtx[i + 10] = temp;
    	}
    	// 第四行循环左移三位
    	temp = mtx[15];
    	for (int i = 3; i > 0; --i)
    		mtx[i + 12] = mtx[i + 11];
    	mtx[12] = temp;
    }
    
    /**
     *  有限域上的乘法 GF(2^8)
     */
    byte GFMul(byte a, byte b) {
    	byte p = 0;
    	byte hi_bit_set;
    	for (int counter = 0; counter < 8; counter++) {
    		if ((b & byte(1)) != 0) {
    			p ^= a;
    		}
    		hi_bit_set = (byte)(a & byte(0x80));
    		a <<= 1;
    		if (hi_bit_set != 0) {
    			a ^= 0x1b; /* x^8 + x^4 + x^3 + x + 1 */
    		}
    		b >>= 1;
    	}
    	return p;
    }
    
    /**
     *  列变换
     */
    void MixColumns(byte mtx[4 * 4])
    {
    	byte arr[4];
    	for (int i = 0; i < 4; ++i)
    	{
    		for (int j = 0; j < 4; ++j)
    			arr[j] = mtx[i + j * 4];
    
    		mtx[i] = GFMul(0x02, arr[0]) ^ GFMul(0x03, arr[1]) ^ arr[2] ^ arr[3];
    		mtx[i + 4] = arr[0] ^ GFMul(0x02, arr[1]) ^ GFMul(0x03, arr[2]) ^ arr[3];
    		mtx[i + 8] = arr[0] ^ arr[1] ^ GFMul(0x02, arr[2]) ^ GFMul(0x03, arr[3]);
    		mtx[i + 12] = GFMul(0x03, arr[0]) ^ arr[1] ^ arr[2] ^ GFMul(0x02, arr[3]);
    	}
    }
    
    /**
     *  轮密钥加变换 - 将每一列与扩展密钥进行异或
     */
    void AddRoundKey(byte mtx[4 * 4], word k[4])
    {
    	for (int i = 0; i < 4; ++i)
    	{
    		word k1 = k[i] >> 24;
    		word k2 = (k[i] << 8) >> 24;
    		word k3 = (k[i] << 16) >> 24;
    		word k4 = (k[i] << 24) >> 24;
    
    		mtx[i] = mtx[i] ^ byte(k1.to_ulong());
    		mtx[i + 4] = mtx[i + 4] ^ byte(k2.to_ulong());
    		mtx[i + 8] = mtx[i + 8] ^ byte(k3.to_ulong());
    		mtx[i + 12] = mtx[i + 12] ^ byte(k4.to_ulong());
    	}
    }
    
    /**************************下面是解密的逆变换函数***********************/
    /**
     *  逆S盒变换
     */
    void InvSubBytes(byte mtx[4 * 4])
    {
    	for (int i = 0; i < 16; ++i)
    	{
    		int row = mtx[i][7] * 8 + mtx[i][6] * 4 + mtx[i][5] * 2 + mtx[i][4];
    		int col = mtx[i][3] * 8 + mtx[i][2] * 4 + mtx[i][1] * 2 + mtx[i][0];
    		mtx[i] = Inv_S_Box[row][col];
    	}
    }
    
    /**
     *  逆行变换 - 以字节为单位循环右移
     */
    void InvShiftRows(byte mtx[4 * 4])
    {
    	// 第二行循环右移一位
    	byte temp = mtx[7];
    	for (int i = 3; i > 0; --i)
    		mtx[i + 4] = mtx[i + 3];
    	mtx[4] = temp;
    	// 第三行循环右移两位
    	for (int i = 0; i < 2; ++i)
    	{
    		temp = mtx[i + 8];
    		mtx[i + 8] = mtx[i + 10];
    		mtx[i + 10] = temp;
    	}
    	// 第四行循环右移三位
    	temp = mtx[12];
    	for (int i = 0; i < 3; ++i)
    		mtx[i + 12] = mtx[i + 13];
    	mtx[15] = temp;
    }
    
    void InvMixColumns(byte mtx[4 * 4])
    {
    	byte arr[4];
    	for (int i = 0; i < 4; ++i)
    	{
    		for (int j = 0; j < 4; ++j)
    			arr[j] = mtx[i + j * 4];
    
    		mtx[i] = GFMul(0x0e, arr[0]) ^ GFMul(0x0b, arr[1]) ^ GFMul(0x0d, arr[2]) ^ GFMul(0x09, arr[3]);
    		mtx[i + 4] = GFMul(0x09, arr[0]) ^ GFMul(0x0e, arr[1]) ^ GFMul(0x0b, arr[2]) ^ GFMul(0x0d, arr[3]);
    		mtx[i + 8] = GFMul(0x0d, arr[0]) ^ GFMul(0x09, arr[1]) ^ GFMul(0x0e, arr[2]) ^ GFMul(0x0b, arr[3]);
    		mtx[i + 12] = GFMul(0x0b, arr[0]) ^ GFMul(0x0d, arr[1]) ^ GFMul(0x09, arr[2]) ^ GFMul(0x0e, arr[3]);
    	}
    }
    
    /******************************下面是密钥扩展部分***********************/
    /**
     * 将4个 byte 转换为一个 word.
     */
    word Word(byte& k1, byte& k2, byte& k3, byte& k4)
    {
    	word result(0x00000000);
    	word temp;
    	temp = k1.to_ulong();  // K1
    	temp <<= 24;
    	result |= temp;
    	temp = k2.to_ulong();  // K2
    	temp <<= 16;
    	result |= temp;
    	temp = k3.to_ulong();  // K3
    	temp <<= 8;
    	result |= temp;
    	temp = k4.to_ulong();  // K4
    	result |= temp;
    	return result;
    }
    
    /**
     *  按字节 循环左移一位
     *  即把[a0, a1, a2, a3]变成[a1, a2, a3, a0]
     */
    word RotWord(word& rw)
    {
    	word high = rw << 8;
    	word low = rw >> 24;
    	return high | low;
    }
    
    /**
     *  对输入word中的每一个字节进行S-盒变换
     */
    word SubWord(word& sw)
    {
    	word temp;
    	for (int i = 0; i < 32; i += 8)
    	{
    		int row = sw[i + 7] * 8 + sw[i + 6] * 4 + sw[i + 5] * 2 + sw[i + 4];
    		int col = sw[i + 3] * 8 + sw[i + 2] * 4 + sw[i + 1] * 2 + sw[i];
    		byte val = S_Box[row][col];
    		for (int j = 0; j < 8; ++j)
    			temp[i + j] = val[j];
    	}
    	return temp;
    }
    
    /**
     *  密钥扩展函数 - 对128位密钥进行扩展得到 w[4*(Nr+1)]
     */
    void KeyExpansion(byte key[4 * Nk], word w[4 * (Nr + 1)])
    {
    	word temp;
    	int i = 0;
    	// w[]的前4个就是输入的key
    	while (i < Nk)
    	{
    		w[i] = Word(key[4 * i], key[4 * i + 1], key[4 * i + 2], key[4 * i + 3]);
    		++i;
    	}
    
    	i = Nk;
    
    	while (i < 4 * (Nr + 1))
    	{
    		temp = w[i - 1]; // 记录前一个word
    		if (i % Nk == 0) {
    			word temp1 = RotWord(temp);
    			w[i] = w[i - Nk] ^ SubWord(temp1) ^ Rcon[i / Nk - 1];
    		}
    		else
    			w[i] = w[i - Nk] ^ temp;
    		++i;
    	}
    }
    /******************************下面是加密和解密函数**************************/
    /**
     *  加密
     */
    void encrypt(byte in[4 * 4], word w[4 * (Nr + 1)])
    {
    	word key[4];
    	for (int i = 0; i < 4; ++i)
    		key[i] = w[i];
    	AddRoundKey(in, key);
    
    	for (int round = 1; round < Nr; ++round)
    	{
    		SubBytes(in);
    		ShiftRows(in);
    		MixColumns(in);
    		for (int i = 0; i < 4; ++i)
    			key[i] = w[4 * round + i];
    		AddRoundKey(in, key);
    	}
    
    	SubBytes(in);
    	ShiftRows(in);
    	for (int i = 0; i < 4; ++i)
    		key[i] = w[4 * Nr + i];
    	AddRoundKey(in, key);
    }
    
    /**
     *  解密
     */
    void decrypt(byte in[4 * 4], word w[4 * (Nr + 1)])
    {
    	word key[4];
    	for (int i = 0; i < 4; ++i)
    		key[i] = w[4 * Nr + i];
    	AddRoundKey(in, key);
    
    	for (int round = Nr - 1; round > 0; --round)
    	{
    		InvShiftRows(in);
    		InvSubBytes(in);
    		for (int i = 0; i < 4; ++i)
    			key[i] = w[4 * round + i];
    		AddRoundKey(in, key);
    		InvMixColumns(in);
    	}
    
    	InvShiftRows(in);
    	InvSubBytes(in);
    	for (int i = 0; i < 4; ++i)
    		key[i] = w[i];
    	AddRoundKey(in, key);
    }

    然后下面的加密函数是我自己写的,密文反馈模式,主要通过初始明文(随便取)加密,然后和文件中的明文异或得出第一段密文,把这段密文作为下面一组的初始明文,然后重复几轮。

    /*下面自己写的*/
    /*建立英文与十六进制对应表的数组*/
    void Hexed(HEX a[26]) {
    	for (int i = 0; i < 26; i++) {
    		a[i].name = 'a' + i;
    		a[i].value = table[i];
    	}
    }
    int main() {
    	byte key[16] = { 0x2b, 0x7e, 0x15, 0x16,
    					0x28, 0xae, 0xd2, 0xa6,
    					0xab, 0xf7, 0x15, 0x88,
    					0x09, 0xcf, 0x4f, 0x3c };
    	cout << "密钥是:";
    	for (int i = 0; i < 16; ++i)
    	{
    		cout << hex << key[i].to_ulong() << " ";
    	}
    	cout << endl;
    	HEX a[26];
    	char wy[64];
    	byte after[64];
    	Hexed(a);
    	ifstream csl("mingwen.txt");
    	if (!csl.is_open()) {
    		cout << "Error" << endl;
    		exit(0);
    	}
    	else {
    		cout << "Open success" << endl;
    	}
    	csl.read(wy, 64);
    	for (int i = 0; i < 64; i++) {
    		for (int j = 0; j < 26; j++) {
    			if (wy[i] == a[j].name) {
    				after[i] = a[j].value;
    			}
    		}
    	}
    	cout << "明文为:" << endl;
    	for (int i = 0; i < 64; i++) {
    		cout << wy[i];
    	}
    	cout << endl;
    	cout << "2进制明文为:" << endl;
    	for (int i = 0; i < 64; i++) {
    		cout << after[i];
    	}
    	cout << endl;
    	//进行密文反馈模式加密
    	cout << "下面进行密文反馈模式加密:" << endl;
    	cout << "s为:" << (int)16 << endl;
    	cout << "初始明文(IV)为:" << "egocogitoergosum" << endl;
    	word w[4 * (Nr + 1)];
    	KeyExpansion(key, w);
    	string mingwen = "egocogitoergosum";
    	byte plain[4 * 4];//2进制明文
    	byte plain_1[4 * 4];//初始明文的二进制明文
    	byte cip[64];//2进制密文
    	for (int i = 0; i < 16; i++) {
    		for (int j = 0; j < 26; j++) {
    			if (a[j].name == mingwen[i]) {
    				plain_1[i] = plain[i] = a[j].value;
    			}
    		}
    	}
    	int p = 0;
    	for (int i = 0; i < 4; i++) {
    		encrypt(plain, w);
    		for (int j=0; j < 16; j++) {
    			plain[j] = plain[j] ^ after[p];
    			cip[p] = plain[j];
    			p++;
    		}
    	}
    	for (int i = 0; i < 64; i++) {
    		cout << "密文:" << cip[i] << endl;
    	}
    	cout << "end" << endl;
    	//解密:
    	byte mingwen2[64];
    	byte plain_2[16];
    	byte plain_3[16];
    	char shit[64];
    	int q1 = 0;
    	int q2 = 0;
    	for (int f = 0; f < 4; f++) {
    		for (int i = 0; i < 16; i++) {
    			plain_2[i] = cip[q1];
    			q1++;
    		}
    		encrypt(plain_1, w);
    		for (int j = 0; j < 16; j++) {
    			mingwen2[q2] = plain_2[j] ^ plain_1[j];
    			plain_1[j] = plain_2[j];
    			q2++;
    		}
    	}
    	for (int i = 0; i < 64; i++) {
    		for (int j = 0; j < 26; j++) {
    			if (mingwen2[i] == a[j].value) {
    				shit[i] = a[j].name;
    			}
    		}
    	}
    	cout << "解密后明文为:" << endl;
    	for (int i = 0; i < 64; i++) {
    		cout << shit[i];
    	}
    }

    展开全文
  • AES密码和上篇一样,计数器模式,是通过加密和明文无关的计数器再与明文异或得到的密文,通过计数器每次加1实现独立性。 代码: //下面进行计数器模式加密: cout << "下面开始计数器加密模式:" << ...

    AES密码和上篇一样,计数器模式,是通过加密和明文无关的计数器再与明文异或得到的密文,通过计数器每次加1实现独立性。

    代码:

    //下面进行计数器模式加密:
    	cout << "下面开始计数器加密模式:" << endl;
    	byte counter[16]={ 0x3A,0x76,0x28,0x39,0x66,0x77,0x98,0x13,0x23,0x28,0x19,0x12,0x34,0x56,0x01,0x09 };
    	cout << "计数器为:" << endl;
    	for (int i = 0; i < 16; i++) {
    		cout << counter[i];
    	}
    	cout << endl;
    	byte miwen1[64];
    	byte counter1[16];
    	byte counter2[16];
    	byte counter3[16];
    	for (int i = 0; i < 16; i++) {
    		counter3[i]=counter2[i] = counter1[i] = counter[i];
    	}
    	int count = 0;
    	for (int i = 0; i < 4; i++) {
    		encrypt(counter, w);
    		for (int j = 0; j < 16; j++) {
    			miwen1[count] = counter[j] ^ after[count];
    			count++;
    		}
    		achive(counter1[15]);
    		for (int j = 0; j < 16; j++) {
    			counter[j] = counter1[j];
    		}
    	}
    	cout << "密文为:" << endl;
    	for (int i = 0; i < 64; i++) {
    		cout << miwen1[i];
    	}
    	cout << endl;
    	byte ming[64];
    	int index = 0;
    	for (int i = 0; i < 4; i++) {
    		encrypt(counter2, w);
    		for (int j = 0; j < 16; j++) {
    			ming[index] = counter2[j] ^ miwen1[index];
    			index++;
    		}
    		achive(counter3[15]);
    		for (int j = 0; j < 16; j++) {
    			counter2[j] = counter3[j];
    		}
    	}
    	char shit1[64];
    	for (int i = 0; i < 64; i++) {
    		for (int j = 0; j < 26; j++) {
    			if (ming[i] == a[j].value) {
    				shit1[i] = a[j].name;
    			}
    		}
    	}
    	cout << "解密后的明文为:" << endl;
    	for (int i = 0; i < 64; i++) {
    		cout << shit1[i];
    	}
    }
    void achive(byte& a) {//实现计数器加1
    	int i = 0;
    	for (i = 0; i < a.size(); i++) {
    		if (a[i] == 0) {
    			a[i] = 1;
    			break;
    		}
    	}
    }

    实验截图:

     

     

    展开全文
  • 介绍了几种常见的加密模式:电码本,密文分组链接模式,密文反馈模式,输出反馈模式,计数器模式。

    分组密码的工作模式

    1。提出背景

    分组密钥输入为b位固定长度的明文分组和密钥,输出b位密文。当明文长度大于b位时就要对明文进行分组,每b位一组。那么若用相同密钥对多个分组加密会导致安全问题。因此提出各种工作模式,总结如下:
    工作模式

    2。 电码本模式(Electronic Code Book,ECB)

    对于给定的密钥,任意b位明文有唯一密文与之对应。

    加密: Cj = E(K, Pj) j = 1,…,N
    解密: Pj = D(K, Cj) j = 1,…,N

    电码本
    如图所示,加密所用密钥为K,对于确定的K有唯一密文Cj与明文Pj对应。但当明文Pj=pi时,则输入P与K均相等,故输出C也想等。总结特点如下:

    • 适合数据较少的情况;
    • 最重要的特征是一段信息若有几个相同的明文组,则密文也将出现几个相同的密文组;
    • 对于长信息不适合:若信息非结构化,密码分析者可利用规律性特征破译;

    3。密文分组链接模式(Cipher Block Chaining,CBC)

    为解决长信息可利用规律性特征破译的缺陷,提出CBC模式。该模式加密算法输入为当前明文分组和上一个密文分组的异或,使用的密钥是相同的。如此,若分组相同也看不出来。
    注:CBC要求如果最后分组不完整,则需要填充至满分组。
    加密解密如下:
    CBC加解密
    IV必须为收发双方共享且第三方无法预测。
    为最大程度安全,IV不能不经授权而修改。原因如下:
    攻击者可以欺骗接受者,让他使用不同的IV,接着攻击者就能够把明文的第一个分组的某些为取反。

    模式如下:
    密文分组链接

    4。密文反馈模式(Cipher Feedback,CFB)

    可将分组密码当作流密码使用。流密码不需要将最后分组填充到满分组。但注意,CFB和流密码的典型构造并不一致:
    典型流密码:输入某个初始值和密钥,输出位流,这个位流再和明文位进行异或运算。
    CFB模式:与明文异或的位流是与明文相关的。
    流密码的性质之一:明文是8位字符,则要发送的也是8位字符,加密时也用8位。
    CFB工作模式:
    CFB工作模式
    解释:加密函数的输入为b位移位寄存器,初始值为IV。1)加密函数输出最左边的s位与明文第一个分段P1异或得到密文的第一个单元;2)将C1发出去,移位寄存器左移s位,C1填入寄存器最右边s位。直到所有明文被加密完。解密时:收到的密文单元与加密函数的输出异或得到明文。
    加密:这里写图片描述
    解密:这里写图片描述
    CFB模式定义:
    CFB模式
    注:MSBs(X):X的左边s位。
    LSBb-s(X) :X的右边剩余b-s位。

    5。输出反馈模式(Output FeedBack,OFB)

    结构与CFB相似:
    OFB:用加密函数的输出填充移位寄存器;
    CFB:用密文单元来填充移位寄存器;
    OFB模式:
    OFB
    定义:
    OFB
    OFB优点:传输过程中某位发生错误不会影响其他位,如C1中有一位发生错误,致影响P1恢复;而CFB中C1还座位了移位寄存器的输入,后续将受到影响。
    OFB缺点:抗消息流窜改能力较低。
    注:初始K应为时变值。

    6。计数器模式(Counter,CTR)

    常用于:ATM(异步传输模式)网络安全和IPsec。
    步骤:
    1)计数器首先被初始化为某一值;
    2)随着消息块的增加计数器的值加1(模2^b,b为分组长度);
    3)加密时:计数器加密后与明文分组异或 —> 密文分组;
    4)解密时:使用具有相同值的计数器序列,用加密后的计数器的值与密文分组异或—>明文分组。
    给定计数器序列Ti,定义CTR模式:
    CTR
    模式图:
    这里写图片描述

    7。总结

    到此为止几种常见的加密模式就介绍完了,主要涉及:

    1. 电码本模式(ECB):最简单的,一组明文与一组密文一一对应,但如果两组明文内容相同则密文也相同,导致可以利用统计学规律进行破解;
    2. 密文分组链接模式(CBC):加密算法的输入为该组明文与上组密文的异或,这就解决了ECB中可利用统计规律破解的漏洞;
    3. 密文反馈模式(CFB):利用流密码的方式对明文进行加密,将密文装入移位寄存器。将移位寄存器的最左s位加密后与明文加密后输出,并装入移位寄存器后面;
    4. 输出反馈模式(OFB):利用流密码的方式对铭文进行加密,与CFB不同的是,将加密函数的输出装入移位寄存器,其他与CFB相同;
    5. 计数器模式(CTR):利用计数器作为加密函数的输入后与明文异或。

    由上看出,很多算法对于初始值的“时变性“非常看重,那么如何实现呢?一种很常用的方法叫做“伪随机数“技术。书中第七章专门有讲到,本系列文章就不记录了。
    那么到此为止对称密码部分就简单介绍完了,从下一讲就开始非对称密钥的学习了,首先介绍一些相关数论知识(素数,欧拉定理,费马定理等),公钥密码学与RSA,密钥管理等知识。我们下期再见!

    展开全文
  • 05.分组密码模式

    2018-10-08 23:29:14
    1.1 分组密码模式简介 ECB模式 ( Electronic CodeBook mode ) : 电子密码本模式 ... CFB模式 ( Cipher FeedBack mode ) : 密文反馈模式 OFB模式 ( Output FeedBack mode ) : 输出反馈模式 CTR模式 ( C...
  • CFB模式解读

    万次阅读 2018-09-03 22:05:15
    CFB模式全称Cipher FeedBack模式(密文反馈模式)。在CFB模式中,前一个密文分组会被送回到密码算法的输入端。所谓反馈,这里指的就是返回输入端的意思。 在ECB模式和CBC模式中,明文分组都是通过密码算法进行...
  • encryption加密之分组模式 之前我们说的 DES,AES ...他们只能加密固定长度的明文 所以如果我们要加密任意长度的明文 ...这种分组迭代加密的方法就称为 ...3.CFB 密文反馈模式 4.OFB 输出反馈模式 5....
  • CFB模式全称是Cipher FeedBack模式(密文反馈模式)。在CFB模式中,前一个密文分组会被送回到密码算法的输入端。所谓反馈,这里指的就是返回输入端的意思。 在ECB和CBC模式中,明文分组都是通过密码算法进行加密...
  • 在分组加密算法中,有几种不同的工作模式,分别是ECB(Electronic CodeBook,电子密码本模式)、CBC(Cipher-block chaining,密码块连接模式)、PCB...密文反馈模式)、OFB(Output feedback,输出反馈模式)、CTR...
  • 密码学-对称加密体系-DES-CFB模式

    千次阅读 2018-09-06 21:37:20
    CFB模式全称是Cipher FeedBack模式(密文反馈模式),在CFB模式中,前一个密文分组被送回到密码算法的输入端。 加密: 初始化向量iv进行加密,加密之后与明文分组1进行异或运算形成明文分组1,密文分组1作为下一个...
  • 分组密码的工作模式有电码本模式(ECB)、密文分组链接模式(CBC)、密文反馈模式(CFB)、输出反馈模式(OFB)、计数器模式(CTR)。这5中模式实际上覆盖了大量使用分组密码的应用。这些模式可用于包括三重DES和高级...
  • 3. CFB:密文反馈模式(可以使用) 4. OFB:输出反馈(可以使用) 5. CTR:计数器模式(推荐使用) 密码算法与分组模式的关系 des 和3des和aes 是密码算法 这个5种是密码模式(怎么使用密码算法) 两个是要进行结合一起...
  • 3. CFB:密文反馈模式(可以使用) 4. OFB:输出反馈(可以使用) 5. CTR:计数器模式(推荐使用) 密码算法与分组模式的关系 des 和3des和aes 是密码算法 这个5种是密码模式(怎么使用密码算法) 两个是要进行结合一起...
  • 3. CFB:密文反馈模式(可以使用) 4. OFB:输出反馈(可以使用) 5. CTR:计数器模式(推荐使用) 密码算法与分组模式的关系 des 和3des和aes 是密码算法 这个5种是密码模式(怎么使用密码算法) 两个是要进行结合一起...
  • 3. CFB:密文反馈模式(可以使用) 4. OFB:输出反馈(可以使用) 5. CTR:计数器模式(推荐使用) 密码算法与分组模式的关系 des 和3des和aes 是密码算法这个5种是密码模式(怎么使用密码算法) 两个是要进行结合一起使用...
  • 3. CFB:密文反馈模式(可以使用) 4. OFB:输出反馈(可以使用) 5. CTR:计数器模式(推荐使用) 密码算法与分组模式的关系 des 和3des和aes 是密码算法这个5种是密码模式(怎么使用密码算法) 两个是要进行结合一起使用...
  • DES(CFB) JAVA

    2015-08-21 10:04:36
    DES(CFB) JAVA实现。密文反馈模式
  • AES 加密算法的实现

    千次阅读 2018-06-02 22:04:34
    AES加密常用的概念 加密模式 ...CBC模式 全称Cipher ...CFB模式 全称Cipher FeedBack模式,译为密文反馈模式 OFB模式 全称Output Feedback模式,译为输出反馈模式。 CTR模式 全称Counter模式,译为计数器模式。 ...
  • DES、3DES 加密算法的调用

    千次阅读 2018-06-02 22:02:00
    DES加密常用的概念 加密模式 ...CBC模式 全称Cipher ...CFB模式 全称Cipher FeedBack模式,译为密文反馈模式 OFB模式 全称Output Feedback模式,译为输出反馈模式。 CTR模式 全称Counter模式,译为计数器模式。 ...
  • 用CBC加密模式实现IDEA算法

    千次阅读 2013-11-13 13:07:04
    密文反馈模式(CBC)是一种常用的加密模式,它首先将输入数据分块,每块的长度为加密算法可处理的块长度,最后一块若不到块长度,则通过填充0比特使其达到块长。上图给出了CBC的原理。其中+代表异或操作,Ek代表使用...
  • CBC字节翻转攻击解析一、分组密码的模式分组密码的主要模式有5种:ECB模式(电子密码本模式)—(Electronic CodeBook mode)CBC模式(密码分组链接模式)—(Cipher Block Chaining mode)CFB模式(密文反馈模式)—(Cipher ...
  • CBC字节翻转攻击解析

    2020-08-11 15:47:29
    CFB模式(密文反馈模式)—(Cipher FeedBack mode) OFB模式(输出反馈模式)—(Output FeedBack mode) CTR模式(计数器模式)—(CounteR mode) 这里只详细介绍CBC密码分组链接模式:通过下图简要介绍
  • 密码篇——分组密码

    千次阅读 2019-01-13 20:01:55
    3)CFB(密文反馈模式) 4)OFB(输出反馈模式) 5)CTR(计数器模式) 分组密码介绍 密码算法可分为:流密码与分组密码 流密码:对数据流进行连续处理的一类密码算法;一般以1比特、8比特、32比特为单位进行...
  • 1 CFB—cipher feedback----密文反馈模式 -在CFB中,前一个密文分组会被送回到密码算法的加密端。所谓反馈就是指返回输入端的意思 我们来分析上图,我们可以发现CFB的加密或者解密过程中都是”加密“,因为这是反馈...
  • 3.4 DES-CFB

    2021-01-26 18:04:08
    CFB模式全称是Cipher FeedBack模式(密文反馈模式),在CFB模式中,前一个密文分组被送回到密码算法的输入端。 b)算法流程 加密:输入是64比特的移位寄存器,其初值为初始向量IV 输出最左边j比特与明文第一个单元P1...
  • 基于块的数字视频编码一般包括运动估计、...并利用可灵活配置的加密模块和密文反馈模式,增强加密的安全性。理论分析和实验结果表明,提出的算法具有计算简单、安全高效、易于实现、不改变视频格式和压缩效率的优点。
  • 首先, 密文反馈模式(CFB)模式是基于流的加密方案, 为了制作可以处理任意位情况错误的流密码, CFB 通常要设定一个分段大小, 用来表示通过 AES 加密明文的时候每次会处理多少个字节的明文. 这个过程的细节可以参考...
  • 密文反馈当寄存器中为下一个块服务。CFB和OFC工作模式中,密码算法象流密码一样生产出密钥流供异或名密文用。 参考文献 NIST SP 800-38A CFB加解密 记: b为分组的比特大小,比如AES时b=128; s为寄存器中保留...
  • 密文反馈 输出反馈 计数器 电码本模式  用相同的密钥分别对明文分组进行加密.  对电码本模式的评价: 相同的明文分组,如果出现多次,会产生多个相同的明文. 对于长消息,电码本模式是无法防止篡改攻击的. 无错误传
  • OFB模式解读

    千次阅读 2018-09-04 21:43:43
    OFB模式的全称是output-Feedback模式(输出反馈模式)。在OFB模式中,密码算法的输出会反馈到密码算法的输入中。 OFB模式不是通过密码算法对明文直接加密的,而是通过将“明文分组”和“密码算法的输出”进行XOR来...

空空如也

空空如也

1 2 3
收藏数 49
精华内容 19
关键字:

密文反馈模式