key生成算法

① java des 加密 解密 密钥随机取得方法

java DES 加密 解密 生成随机密钥
举例说明：
//保存生成的key
public static void saveDesKey() {
try {
SecureRandom sr = new SecureRandom();
// 选择的DES算法生成一个KeyGenerator对象
KeyGenerator kg = KeyGenerator.getInstance("DES");
kg.init(sr);
// 相对路径 需要新建 conf 文件夹
// String fileName = "conf/DesKey.xml";
// 绝对路径
String fileName = "d:/DesKey.xml";
FileOutputStream fos = new FileOutputStream(fileName);
ObjectOutputStream oos = new ObjectOutputStream(fos);
// 生成密钥
Key key = kg.generateKey();
oos.writeObject(key);
oos.close();
} catch (Exception e) {
e.printStackTrace();
}
}
//获取生成的key
public static Key getKey() {
Key kp = null;
try {
// 相对路径 需要新建 conf 文件夹
// String fileName = "conf/DesKey.xml";
// InputStream is = Encrypt.class.getClassLoader().getResourceAsStream(fileName);
// 绝对路径
String fileName = "d:/DesKey.xml";
FileInputStream is = new FileInputStream(fileName);
ObjectInputStream oos = new ObjectInputStream(is);
kp = (Key) oos.readObject();
oos.close();
} catch (Exception e) {
e.printStackTrace();
}
return kp;
}
//加密开始
public static void encrypt(String file, String dest) throws Exception {
Cipher cipher = Cipher.getInstance("DES");
cipher.init(Cipher.ENCRYPT_MODE, getKey());
InputStream is = new FileInputStream(file);
OutputStream out = new FileOutputStream(dest);
CipherInputStream cis = new CipherInputStream(is, cipher);
byte[] buffer = new byte[1024];
int r;
while ((r = cis.read(buffer)) > 0) {
out.write(buffer, 0, r);
}
cis.close();
is.close();
out.close();
}
//解密开始
public static void decrypt(String file, String dest) throws Exception {
Cipher cipher = Cipher.getInstance("DES");
cipher.init(Cipher.DECRYPT_MODE, getKey());
InputStream is = new FileInputStream(file);
OutputStream out = new FileOutputStream(dest);
CipherOutputStream cos = new CipherOutputStream(out, cipher);
byte[] buffer = new byte[1024];
int r;
while ((r = is.read(buffer)) >= 0) {
cos.write(buffer, 0, r);
}
cos.close();
out.close();
is.close();
}
}
//des加密主方法
public class DES {
public static void main(String[] args) throws Exception {
Encrypt.saveDesKey();
System.out.println("生成key");
Encrypt.getKey();
System.out.println("获取key");
Encrypt.encrypt("d:\\hello.txt", "d:\\encrypt.txt");
System.out.println("加密");
Encrypt.decrypt("d:\\encrypt.txt", "d:\\decrypt.txt");
System.out.println("解密");
}
以上方法亲测可用。

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

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

加密必备要素：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、3DES算法

3DES（即Triple DES）是DES向AES过渡的加密算法（1999年，NIST将3-DES指定为过渡的加密标准），加密算法，其具体实现如下：设Ek()和Dk()代表DES算法的加密和解密过程，K代表DES算法使用的密钥，M代表明文，C代表密文，这样：

3DES加密过程为：C=Ek3(Dk2(Ek1(M)))

3DES解密过程为：M=Dk1(EK2(Dk3(C)))

2、Blowfish算法

BlowFish算法用来加密64Bit长度的字符串。

BlowFish算法使用两个“盒”——unsignedlongpbox[18]和unsignedlongsbox[4,256]。

BlowFish算法中，有一个核心加密函数:BF_En(后文详细介绍）。该函数输入64位信息，运算后，以64位密文的形式输出。用BlowFish算法加密信息，需要两个过程：密钥预处理和信息加密。

分别说明如下：

密钥预处理：

BlowFish算法的源密钥——pbox和sbox是固定的。我们要加密一个信息，需要自己选择一个key，用这个key对pbox和sbox进行变换，得到下一步信息加密所要用的key_pbox和key_sbox。具体的变化算法如下：

1)用sbox填充key_sbox

2)用自己选择的key8个一组地去异或pbox，用异或的结果填充key_pbox。key可以循环使用。

比如说：选的key是"abcdefghijklmn"。则异或过程为：

key_pbox[0]=pbox[0]abcdefgh；

key_pbox[1]=pbox[1]ijklmnab；

…………

…………

如此循环，直到key_pbox填充完毕。

3)用BF_En加密一个全0的64位信息，用输出的结果替换key_pbox[0]和key_pbox[1],i=0；

4)用BF_En加密替换后的key_pbox,key_pbox[i+1]，用输出替代key_pbox[i+2]和key_pbox[i+3]；

5)i+2，继续第4步，直到key_pbox全部被替换；

6)用key_pbox[16]和key_pbox[17]做首次输入（相当于上面的全0的输入），用类似的方法，替换key_sbox信息加密。

信息加密就是用函数把待加密信息x分成32位的两部分:xL,xRBF_En对输入信息进行变换。

3、RC5算法

RC5是种比较新的算法，Rivest设计了RC5的一种特殊的实现方式，因此RC5算法有一个面向字的结构：RC5-w/r/b，这里w是字长其值可以是16、32或64对于不同的字长明文和密文块的分组长度为2w位，r是加密轮数，b是密钥字节长度。

(3)key生成算法扩展阅读：

普遍而言，有3个独立密钥的3DES（密钥选项1）的密钥长度为168位（三个56位的DES密钥），但由于中途相遇攻击，它的有效安全性仅为112位。密钥选项2将密钥长度缩短到了112位，但该选项对特定的选择明文攻击和已知明文攻击的强度较弱，因此NIST认定它只有80位的安全性。

对密钥选项1的已知最佳攻击需要约2组已知明文，2部，2次DES加密以及2位内存（该论文提到了时间和内存的其它分配方案）。

这在现在是不现实的，因此NIST认为密钥选项1可以使用到2030年。若攻击者试图在一些可能的（而不是全部的）密钥中找到正确的，有一种在内存效率上较高的攻击方法可以用每个密钥对应的少数选择明文和约2次加密操作找到2个目标密钥中的一个。

④ 区块链论文精读——Pixel: Multi-signatures for Consensus

论文主要提出了一种兆数茄针对共识机制PoS的多重签名算法Pixel。

所有基于PoS的区块链以及允许的区块链均具有通用结构，其中节点运行共识子协议，以就要添加到分类账的下一个区块达成共识。这样的共识协议通常要求节点检查阻止提议并通过对可接受提议进行数字签名来表达其同意。当一个节点从特定块上的其他节点看到足够多的签名时，会将其附加到其分类帐视图中。

由于共识协议通常涉及成千上万的节点，为了达成共识而共同努力，因此签名方案的效率至关重要。此外，为了使局外人能够有效地验证链的有效性，签名应紧凑以进行传输，并应快速进行验证。已发现多重签名对于此任务特别有用，因为它们使许多签名者可以在公共消息上创建紧凑而有效的可验证签名。

补充知识： 多重签名
是一种数字签名。在数字签名应用中，有时需要多个用户对同一个文件进行签名和认证。比如，一个公司发布的声明中涉及财务部、开发部、销售部、售后服务部等部门，需要得到这些部门签名认可，那么，就需要这些部门对这个声明文件进行签名。能够实现多个用户对同一文件进行签名的数字签名方案称作多重数字签名方案。
多重签名是数字签名的升级，它让区块链相关技术应用到各行各业成为可能。 在实际的操作过程中，一个多重签名地址可以关联n个私钥，在需要转账等操作时，只要其中的m个私钥签名就可以把资金转移了，其中m要小于等于n，也就是说m/n小于1，可以是2/3, 3/5等等，是要在建立这个多重签名地址的时候确定好的。

本文提出了Pixel签名方案，这是一种基于配对的前向安全多签名方案，可用于基于PoS的区块链，可大幅节省带宽和存储要求。为了支持总共T个时间段和一个大小为N的委员会，多重签名仅包含两个组元素，并且验证仅需要三对配对，一个乘幂和N -1个乘法。像素签名几乎与BLS多重签名一样有效，而且还满足前向安全性。此外，就像在BLS多签名中一样，任何人都可以非交互地将单个签名聚合到一个多签名中。

有益效果：
为了验证Pixel的设计，将Pixel的Rust实施的性能与以前的基于树的前向安全解决方案进行了比较。展示了如何将Pixel集成到任何PoS区块链中。接下来，在Algorand区块链上评估Pixel，表明它在存储，带宽和块验证时间方面产生了显着的节省。我们的实验结果表明，Pixel作为独立的原语并在区块链中使用是有效的。例如，与一组128位安全级别的N = 1500个基于树的前向安全签名（对于T = 232）相比，可以认证整个集合的单个Pixel签名要毕型小2667倍，并且可以被验证快40倍。像素签名将1500次事务的Algorand块的大小减少了约35％，并将块验证时间减少了约38％。

对比传统BLS多重签名方案最大的区别是BLS并不具备前向安全性。

对比基于树的前向安全签名，基于树的前向安全签名可满足安全性，但是其构造的签名太大，验证速度有待提升。 本文设计减小了签名大小、降低了验证时间。

补充知识： 前向安全性
是密码学中通讯协议的安全属性，指的是长期使用的主密钥泄漏不会导致过去的会话密钥泄漏。前向安全能够保护过去进行的通讯不受密码或密钥在未来暴露的威胁。如果系统具有前向安全性，就可以保证在主密钥泄露时历史通讯的安全，即使系统遭到主动攻击也是如此。

构建基于分层身份的加密（HIBE）的前向安全签名，并增加了在同一消息上安全地聚合签名以及生成没有可信集的公共参数的能力。以实现：
1、生成与更新密钥
2、防止恶意密钥攻击的安全性
3、无效的信任设置

对于常见的后攻击有两种变体：
1、短程变体：对手试图在共识协议达成之前破坏委员会成员。解决：通过假设攻击延迟长于共识子协议的运行时间来应对短距离攻击。
2、远程变体：通过分叉选择规则解决。
前向安全签名为这两种攻击提供了一种干净的解决方案，而无需分叉选择规则或有关对手和客户的其他假设。（说明前向安全签名的优势）。

应用于许可的区块链共识协议（例如PBFT）也是许多许可链（例如Hyperledger）的核心，在这些区块链中，只有经过批准的方可以加入族察网络。我们的签名方案可以类似地应用于此设置， 以实现前向保密性，减少通信带宽并生成紧凑的块证书。

传统Bellare-Miner 模型，消息空间M的前向安全签名方案FS由以下算法组成：
1、Setup
pp ←Setup(T), pp为各方都同意的公共参数，Setup(T)表示在T时间段内对于固定参数的分布设置。

2、Key generation
(pk,sk1) ←Kg
签名者在输入的最大时间段T上运行密钥生成算法，以为第一时间段生成公共验证密钥pk和初始秘密签名密钥sk1。

3、Key update
skt+1←Upd(skt) 签名者使用密钥更新算法将时间段t的秘密密钥skt更新为下一个周期的skt + 1。该方案还可以为任何t0> t提供 “快速转发”更新算法 skt0←$ Upd0（skt，t0），该算法比重复应用Upd更有效。

4、Signing
σ ←Sign(skt,M),在输入当前签名密钥skt消息m∈M时，签名者使用此算法来计算签名σ。

5、Verification
b ← Vf(pk,t,M,σ)任何人都可以通过运行验证算法来验证消息M在公共密钥pk下的时间段t内的签名M的签名，该算法返回1表示签名有效，否则返回0。

1、依靠非对称双线性组来提高效率，我们的签名位于G2×G1中而不是G2 ^2中。这样，就足以给出公共参数到G1中（然后我们可以使用散列曲线实例化而无需信任设置），而不必生成“一致的”公共参数（hi，h0 i）=（gxi 1，gxi 2）∈G1× G2。

2、密钥生成算法，公钥pk更小，参数设置提升安全性。

除了第3节中的前向安全签名方案的算法外，密钥验证模型中的前向安全多重签名方案FMS还具有密钥生成，该密钥生成另外输出了公钥的证明π。
新增Key aggregation密钥汇总、Signature aggregation签名汇总、Aggregate verification汇总验证。满足前向安全的多重签名功能的前提下也证明了其正确性和安全性。

1、PoS在后继损坏中得到保护
后继损坏：后验证的节点对之前的共识验证状态进行攻击破坏。
在许多用户在同一条消息上传播许多签名（例如交易块）的情况下，可以将Pixel应用于所有这些区块链中，以防止遭受后继攻击并潜在地减少带宽，存储和计算成本。

2、Pixel整合
为了对区块B进行投票，子协议的每个成员使用具有当前区块编号的Pixel签署B。当我们看到N个委员会成员在同一块B上签名的集合时，就达成了共识，其中N是某个固定阈值。最后，我们将这N个签名聚合为单个多重签名Σ，而对（B，Σ）构成所谓的 区块证书 ，并将区块B附加到区块链上。

3、注册公共密钥
希望参与共识的每个用户都需要注册一个参与签名密钥。用户首先采样Pixel密钥对并生成相应的PoP。然后，用户发出特殊交易（在她的消费密钥下签名）， 注册新的参与密钥 。交易包括PoP。选择在第r轮达成协议的PoS验证者，检查（a）特殊交易的有效性和（b）PoP的有效性。如果两项检查均通过，则 使用新的参与密钥更新用户的帐户 。从这一点来看，如果选中，则用户将使用Pixel登录块。
即不断更换自己的参与密钥，实现前向安全性。

4、传播和聚集签名
各个委员会的签名将通过网络传播，直到在同一块B上看到N个委员会成员的签名为止。请注意，Pixel支持非交互式和增量聚合：前者意味着签名可以在广播后由任何一方聚合，而无需与原始签名者，而后者意味着我们可以将新签名添加到多重签名中以获得新的多重签名。实际上，这意味着传播的节点可以对任意数量的委员会签名执行中间聚合并传播结果，直到形成块证书为止。或者，节点可以在将块写入磁盘之前聚合所有签名。也就是说，在收到足够的区块证明票后，节点可以将N个委员会成员的签名聚集到一个多重签名中，然后将区块和证书写入磁盘。

5、密钥更新
在区块链中使用Pixel时，时间对应于共识协议中的区块编号或子步骤。将时间与区块编号相关联时，意味着所有符合条件的委员会成员都应在每次形成新区块并更新轮回编号时更新其Pixel密钥。

在Algorand 项目上进行实验评估，与Algorand项目自带的防止后腐败攻击的解决方案BM-Ed25519以及BLS多签名解决方案做对比。

存储空间上：

节省带宽：
Algorand使用基于中继的传播模型，其中用户的节点连接到中继网络（具有更多资源的节点）。如果在传播过程中没有聚合，则中继和常规节点的带宽像素节省来自较小的签名大小。每个中继可以服务数十个或数百个节点，这取决于它提供的资源。

节省验证时间