Like OFB, counter mode turns a block cipher into a stream cipher . It generates the next keystream block by encrypting successive values of a "counter". The counter can be any function which produces a sequence which is guaranteed not to repeat for a long time, although an actual increment-by-one counter is the simplest and most popular. The usage of a simple deterministic input function used to be controversial; critics argued that "deliberately exposing a cryptosystem to a known systematic input represents an unnecessary risk." By now, CTR mode is widely accepted, and problems resulting from the input function are recognized as a weakness of the underlying block cipher instead of the CTR mode. Along with CBC, CTR mode is one of two block cipher modes recommended by Niels Ferguson and Bruce Schneier.

CTR mode has similar characteristics to OFB, but also allows a random access property during decryption. CTR mode is well suited to operate on a multi-processor machine where blocks can be encrypted in parallel. Furthermore, it does not suffer from the short-cycle problem that can affect OFB.

Note that the nonce in this diagram is the same thing as the initialization vector (IV) in the other diagrams. The IV/nonce and the counter can be combined together using any lossless operation (concatenation, addition, or XOR) to produce the actual unique counter block for encryption.

中文：（简单解释一下）

计数模式也被称为整数计数模式以及分段块模式。

计数模式和OFB有点相似，它将分块密文转行为流密码。计数模式通过对连续递增的counter加密产生keystream，counter可以被任意函数产生，但是必须保证它在相当长的一段时间内不重复，通常情况下，使用的是加1的方式（即操作一个block后counter加1）。

下图中的nonce和IV具有相同的语义，即nonce=IV,

计数模式可以用下图描述：

用key将counter加密后得到ecounter，然后counter=counter+1，将明文与ecounter做异或运算.

将递增后的counter作为下一次的counter， 用key将counter加密后得到ecounter，然后counter=counter+1，将明文与ecounter做异或运算.

重复以上操作。

实现code：

AES_encrypt是一次ecb encrypt过程。

#if defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_AMD64) || defined(_M_X64))
# define SWAP(x) (_lrotl(x, 8) & 0x00ff00ff | _lrotr(x, 8) & 0xff00ff00)
# define GETU32(p) SWAP(*((u32 *)(p)))
# define PUTU32(ct, st) { *((u32 *)(ct)) = SWAP((st)); }
#else
# define GETU32(pt) (((u32)(pt)[0] << 24) ^ ((u32)(pt)[1] << 16) ^ ((u32)(pt)[2] <<  8) ^ ((u32)(pt)[3]))
# define PUTU32(ct, st) { (ct)[0] = (u8)((st) >> 24); (ct)[1] = (u8)((st) >> 16); (ct)[2] = (u8)((st) >>  8); (ct)[3] = (u8)(st); }
#endif

/* NOTE: CTR mode is big-endian.  The rest of the AES code
 * is endian-neutral. */
/* increment counter (128-bit int) by 2^64 */
static void AES_ctr128_inc(unsigned char *counter) {
	unsigned long c;
	/* Grab 3rd dword of counter and increment */
#ifdef L_ENDIAN
	c = GETU32(counter + 8);
	PUTU32(counter + 8, c);
#else
	c = GETU32(counter + 4);
	PUTU32(counter + 4, c);
#endif
	/* if no overflow, we're done */
	if (c)
		return;
	/* Grab top dword of counter and increment */
#ifdef L_ENDIAN
	c = GETU32(counter + 12);
	PUTU32(counter + 12, c);
#else
	c = GETU32(counter +  0);
	PUTU32(counter +  0, c);
#endif
/* The input encrypted as though 128bit counter mode is being
 * used.  The extra state information to record how much of the
 * 128bit block we have used is contained in *num, and the
 * encrypted counter is kept in ecount_buf.  Both *num and
 * ecount_buf must be initialised with zeros before the first
 * call to AES_ctr128_encrypt().
void AES_ctr128_encrypt(const unsigned char *in, unsigned char *out,
	const unsigned long length, const AES_KEY *key,
	unsigned char counter[AES_BLOCK_SIZE],
	unsigned char ecount_buf[AES_BLOCK_SIZE],
	unsigned int *num) {
	unsigned int n;
	unsigned long l=length;
	assert(in && out && key && counter && num);
	assert(*num < AES_BLOCK_SIZE);
	n = *num;
	while (l--) {
		if (n == 0) {
			AES_encrypt(counter, ecount_buf, key);
			AES_ctr128_inc(counter);
		*(out++) = *(in++) ^ ecount_buf[n];
		n = (n+1) % AES_BLOCK_SIZE;
	*num=n;
如果你的程序需要支持decypt的第一个block不是从0开始，即void AES_ctr128_encrypt(const unsigned char *in, unsigned char *out,
 const unsigned long length, const AES_KEY *key,
 unsigned char counter[AES_BLOCK_SIZE],
 unsigned char ecount_buf[AES_BLOCK_SIZE],
 unsigned int *num)中的num>0,  num<AES_BLOCK_SIZE,
 
此时就需要对AES_ctr128_encrypt做一次封装
 
void AES_ctr128_encrypt_with_offset(const unsigned char *in, unsigned char *out,
 const unsigned long length, const AES_KEY *key,
 unsigned char iv[AES_BLOCK_SIZE], 
 unsigned int  block_offset)
 
 
       if(block_offset <0 || block_offset >= AES_BLOCK_SIZE)
 
return;
 
       unsigned char ecount_buf[AES_BLOCK_SIZE];
 
      unsigned char counter[AES_BLOCK_SIZE];
 
 
       memset(ecount_buf,0,AES_BLOCK_SIZE);
 
      memcpy(counter,iv,AES_BLOCK_SIZE)
 
        if(block_offset >0 && block_offset < AES_BLOCK_SIZE )
 
AES_encrypt(counter, ecount_buf, key);
 AES_ctr128_inc(counter);
 
 
      int block_offset_cur = block_offset ;
 
     AES_ctr128_encrypt(in,out,length,key,&block_offset );
 
参考文献：http://en.wikipedia.org/wiki/Block_cipher_mode_of_operation
 
http://www.opensource.apple.com/source/OpenSSL/OpenSSL-22/openssl/crypto/aes/aes_ctr.c
 
				
AES-CTR即AES算法的计算器模式（Counter (CTR)），这种计算器模式不常见，在CTR模式中， 有一个自增的算子(IV,后四个字节相当于计数器，每次计算递增)，这个算子用密钥加密之后的输出和明文异或的结果得到密文，相当于一次一密。这种加密方式简单快速，安全可靠，而且可以并行加密，但是在计算器不能维持很长的情况下，密钥只能使用一次。CTR加密过程的示意图如下所示：
##############################################################
参考文章 disadvantages-of-aes-ctr 总结下AES-CTR模式的缺点
AES是一种分组加密模式，其中CTR（计数模式）是其中一种工作模式
加密原理：用密钥对输入的计数器加密，然后同明文异或得到密文。
解密原理：用密钥对输入计数器加密，然后同密文异或得到明文。
CTR不需要Padding，而且采用了流密钥方式加解密.
CTR涉及参量：Nounce随机数、Counter计数器和密钥。
Nounce随机数和Counter




    

				
So, lets look at how CBC works first. The following picture shows the encryption when using CBC (in this case, using AES as the cipher).
Basically, Cipher-Block-Chaining means that previous to putt...
				
学到了AES-CTR加密模式，往后填充哪里确实需要我们记住
如果初始值就是16字节，那Counter value1的值就是初始值，之后的Counter value便是每次在初始值后加1，也就没有所谓的后8字节为分组序号组这一说法，就像上面讲原理是所介绍的那个例子。我理解的大致是这样，因为遇到的题目确实是按这个想法才能解。
学艺不精，还有待提升，继续加油！
				
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
public class AES {
    public static final String KEY_ALGORITHM = "AES";
    publ.
				
选择AES算法进行对称加密，密钥长度为128位及以上位数，分组密码模式使用CTR模式，CTR模式不需要填充，初始化向量在应用内设定。
（1）对称加密主要应用于普通的数据块（如字符串、字节流等）加解密。
（2）CTR模式支持加/解密并行操作;而cBc模式加密不支持并行操作，解密支持并行 
          操作。因而，CTR模式加密速度快于CBC模式。
				
 |版权声明：本文为博主原创文章，未经博主允许不得转载。博客地址：  https://blog.csdn.net/sgsgy5 
具体封装的所有函数的加密包github地址：https://github.com/wumansgy/goEncrypt
CTR 模式
CTR模式的全称是CounTeR模式（计数器模式）。CTR摸式是一种通过将逐次累加的计数器进行加密来生成密钥流的流密码（下图）。
CT...
//aes是对称加密算法的一种，Ctr是分组迭代模式的一种，需要初始向量，使用了流密钥而非分组密钥
func aesEncrypt(plainText, key []byte) ([]byte, error) {
	//1 ...
了解分组密码的结构特点
掌握传统分组密码结构AES，以及AES在两种工作模式CBC和CTR下的实现
通过使用Python（推荐）或者C或者Java，编程分别实现CBC和CTR模式下的AES加密解密
实现两个加密/解密系统，
在密文分组链接模式（CBC）下使用AES
在计数器模式（CTR）中使用AES
完成程序后，使用附件的test.txt中给出的四组密钥和密文（十六进制形式）来验证你的代码
在两种模式下，16字节的加密IV都要求是随机生成的，并被添加到密文前面
对于CBC加密，
				
AES256CTR是一种对称加密算法，它使用256位密钥对数据进行加密。CTR代表计数器模式（Counter Mode），它是一种加密模式，用于将块密码转换为流密码。在CTR模式中，加密器使用一个计数器和密钥来生成密钥流，然后将明文与密钥流按位异或得到密文。解密器使用相同的计数器和密钥来生成相同的密钥流，并将密文与密钥流按位异或得到明文。
CTR模式具有以下优点：
1. 可以并行加密和解密，因为加密和解密所需的密钥流是相同的。
2. 可以随机访问加密数据，因为每个块都是独立加密的。
3. 对数据进行加密时，可以使用非常快速的硬件来生成密钥流。
4. 可以轻松地实现数据完整性检查，因为解密器可以使用相同的密钥流来计算MAC（Message Authentication Code）。
CTR模式的缺点是，如果密钥流中存在重复的计数器值，则可能会导致数据泄漏。因此，在使用CTR模式时，必须确保计数器值是唯一的。
				Android Studio命令行编译提示Unable to make field private final java.lang.String java.io.File.path accessib
					26012
                Android Studio命令行编译提示Unable to make field private final java.lang.String java.io.File.path accessib
                    fredhurui: 
                    把java版本换一下
                Android Studio命令行编译提示Unable to make field private final java.lang.String java.io.File.path accessib
                    CxyAndyC: 
您的方法好像可复制性比较弱，像我适配的版本是gradle-7.2， 要是改成7.1.1又有其他不适合了。而且底下的jvmargs，您这个方法我再这篇文章里也看到了，操作下来也不成功，不知道您还能给我一些指示嘛：
https://stackoverflow.com/questions/72323063/unable-to-make-field-private-final-java-lang-string-java-io-file-path-accessible
                Ubuntu20.4安装QT6
                    fredhurui: 
                    挂个代理软件，设置代理后是否可以解决？