精华内容
下载资源
问答
  • 密文反馈模式 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];
    	}
    }

    展开全文
  • 1. CFB (Cipher FeedBack)模式定义 前一个密文分组会被送回到密码算法的输人端 1.1. 与CBC模式比较 1.2. 密码算法的输出相当于一次性密码本中的随机比特序列。 CFB模式中由密码算法所生成的比特序列称为密钥流( ...

    1. CFB (Cipher FeedBack)模式定义

    前一个密文分组会被送回到密码算法的输人端
    在这里插入图片描述

    1.1. 与CBC模式比较
    在这里插入图片描述

    1.2. 密码算法的输出相当于一次性密码本中的随机比特序列。

    CFB模式中由密码算法所生成的比特序列称为密钥流( key stream )。 密码算法就相当于用来生成密钥流的伪随机数生成器,而初始化向量就相当于伪随机数生成器的“种子”。

    在CFB模式中,明文数据可以被逐比特加密,因此我们可以将CFB模式看作是一种使用分组密码来实现流密码的方式。

    2. 重放攻击replay attack

    Mallory用昨天保存下来的3个密文分组将今天发送的后3个密文分组进行了替换。Mallory没有破解密码,就成功地将以前的电文混入了新电文中。

    当Bob解密时,4个分组中就只有第1个可以解密成正确的明文分组,第2个会出错,而第3个和第4个则变成了被Mallory替换的内容(也就是昨天发送的明文内容)。

    eg. 第2个分组出错到底是通信错误呢,还是被人攻击所造成的呢?(需要使用消息认证码)
    在这里插入图片描述

    展开全文
  • 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;
    		}
    	}
    }

    实验截图:

     

     

    展开全文
  • ofb模式This is an output feedback (OFB) mode is similar in structure to that of CFB in Cryptography. It is the output of the encryption function that is fed back to the shift register in OFB in the ...
  • 密文反馈 输出反馈 计数器 电码本模式  用相同的密钥分别对明文分组进行加密.  对电码本模式的评价: 相同的明文分组,如果出现多次,会产生多个相同的明文. 对于长消息,电码本模式是无法防止篡改攻击的. 无错误传
  • 电码本模式(ECB) 分组后逐个加密 加密:Ci = Ek(Mi) 解密:Mi = Dk-1(Ci) 特点(缺点): 要求数据的长度是密码分组长度的整数倍 容易暴露明文的数据模式 重复的明文产生相同的密码分组 以DES为例,明文...
  • 高级加密标准(Advanced Encryption Standard: AES)是美国国家标准与技术研究院(NIST)在2001年建立了电子数据的加密规范。其是对称加解密算法的最经典算法之一,它...这里只介绍ECB、CBC、CFB和OFB四种加密模式 ...
  • 密码学基础系列课程第七弹:分组加密工作模式
  • 并生成128比特的密文模式 分组密码算法只能加密固定长度的分组,但是我们需要加密的明文长度可能会超过分组密码的分组长度,这时就需要对分组密码算法进行迭代,以便将一段很长的明文全部加密。 而迭代的方法就...
  • 分组密码工作模式

    2021-05-19 14:14:19
    分组密码工作模式 电子密码本(ECB, Electronic codebook)方式 密码分组链接(CBC, Cipher block chaining)方式...密文反馈(CFB, Cipher-feedback)方式 输出反馈(OFB, output-feedback)方式 计数器模式(CTR,Counter)。
  • 电码本模式 一次处理一组明文分块,每次使用相同的密钥加密,如图所示。 明文若长于b位,则可以简单的将其分为b位一组的块,如果有必要则对最后一块进行填充。解密也是一次执行一块,使用相同的密钥。 ECB模式...
  • 分组密码及五种工作模式、DES和AES

    千次阅读 2020-10-24 20:45:08
    IV必须为收发双方共享,但第三方不能预测,IV不能不经授权而修改 需要填充 应用:面向分组的通用传输、认证 (三)密文反馈模式(CFB) CFB、OFB、CTR均可将分组密码当流密码使用。流密码不需要将明文填充到长度是...
  • 比较典型的加密方法是密文分组链接模式(CBC模式)、输出反馈模式(OFB模式)、密码反馈模式(CFB模式)、计数器模式(CTR模式)。我们今天要攻击的就是CBC模式。 CBC模式是用于一般 数据加密 的一个普通的分组...
  • 加密一般分为对称加密(Symmetric Key Encryption)和非对称加密(Asymmetric Key ...是将明文按一定的位长分组,明文组经过加密运算得到密文组,密文组经过解密运算(加密运算的逆运算),还原成明文组。...
  • 密钥生成 如何安全地生成密钥。即如何生成可信任的密钥,保证用户得到的密钥是安全的, 生成密钥的机器或程序是可信的。 如何生成安全的密钥。... 序列加密模式又称为流加密方式,是对要处理的数据按位 (或字
  • 分组密码的模式分组密码和流密码二级目录三级目录 分组密码和流密码 分组密码是每次只能处理特定长度的...一个分组的比特数就称为分组长度。 ... ...迭代的方法就被称为分组密码的模式。 分组密码的模式主要有以下5种。 ECB
  • CFB模式:Cipher FeedBack mode(密文反馈模式) OFB模式:Output FeedBack mode(输出反馈模式) CTR模式:CounTeR mode (计数器模式) ECB模式(电子密码本模式) ECB模式比较简单,这种模式就是把一段...
  • Q:为什么需要分组模式? A:明文的长度不固定,而分组密码只能处理特定长度的一块数据,这就需要对分组密码的算法进行迭代,...特点: 简单, 效率高, 密文有规律, 容易被破解 最后一个明文分组必须要填充 des/3des -...
  • 分组加密模式 ECB、CBC、PCBC、CFB、OFB、CTR

    千次阅读 多人点赞 2019-02-13 16:38:52
    在分组加密算法中,有几种不同的工作模式,分别是ECB(Electronic CodeBook,电子密码本模式)、CBC(Cipher-block chaining,密码块连接模式)、PCB...密文反馈模式)、OFB(Output feedback,输出反馈模式)、CTR...
  • CBC密码分组链接模式

    2020-04-25 21:57:23
    在学习过ECB(电码本)模式后,可以很容易分析出其优劣势。优势在于简便易操作,密文分组之间相互独立,错误不会扩散。但缺点较多:1.同一明文分组会对应相同密文;2.容易暴露明文组数据格式,若每次发送的明文都以...
  • 分组密码与模式

    万次阅读 2019-09-25 07:54:10
    文章目录什么是分组密码和模式ECB模式CBC模式CFB模式OFB模式CTR模式 什么是分组密码和模式 ... ...而分组密码的迭代方法就称为分组密码的模式。 本文我们会讲如下几种模式: ECB模式:电子密码本模式 ...CFB模式密文...
  • 二 分组密码模式

    2020-01-17 13:56:30
    分组密码的模式 简介 前面介绍的DES和AES都属于分组密码,它们只能加密固定长度的明文,如果需要加密任意长度的明文,就需要对分组密码进行迭代,而分组密码进行迭代,而分组密码的迭代方法就被称为分组密码的“模式...
  • 密码算法特性

    2020-07-06 18:45:44
    当CBC的密文分组中有一些比特缺失了,导致密码分组的长度发生变化,此分组发生错位,在缺失比特位置之后的密文分组也就无法全部解密了 3)CFB模式(密文反馈模式 CFB模式是将前一个分组的密文加密后和当前分组的明文...
  • 文章目录1、分组密码和流密码的...密码块连接模式)2.3、CFB(Cipher feedback,密文反馈模式)2.4、OFB(Output feedback,输出反馈模式)2.5、CTR(Counter mode,计数器模式) 1、分组密码和流密码的概念及区别 1.
  • AES加密的几种工作模式

    千次阅读 2019-03-08 10:52:40
    高级加密标准(Advanced Encryption Standard: AES)是美国国家标准与技术研究院(NIST)在2001年建立了电子...这里只介绍ECB、CBC、CFB和OFB四种加密模式。 其实现的数据加密算法有字节代替(SubBytes)、行移位...
  • 密码学之分组密码操作模式

    千次阅读 2020-02-17 11:58:18
    通常,分组密码算法(如典型的DES)是提供...常见的分组密码操作模式有:电子密码本模式(ECB)、密码分组链接模式(CBC)、计数器模式(CTR)、输出反馈模式(OFB)、密码反馈模式(CFB)。下面我将对这几种模式分...
  • 分组密码——DES与工作模式

    千次阅读 2016-12-04 19:48:27
    n-bit明文被加密成n-bit密文 乘积密码 两个密码的复合 现代分组密码,简单密码重复多次以确保安全 – 代替*代替 = 代替 – 置换*置换 = 置换 现代分组密码 • 代替(Substitution) – 支持混淆 • 置换(Permutation) ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,570
精华内容 1,028
关键字:

密文反馈模式