https://blog.csdn.net/jingzi123456789/article/details/104783728

https://cloud.tencent.com/developer/article/1682597

Attribute-Based Encryption（ABE）属性加密

参考资料：

http://cpfd.cnki.com.cn/Article/CPFDTOTAL-ZGTH201310001015.htm

https://blog.csdn.net/benguniang/article/details/90230096

http://www.elecfans.com/blockchain/816750.html

https://blog.csdn.net/ping802363/article/details/65639016

https://github.com/stefano81/dcpabe.git


import (
    "github.com/fentec-project/gofe/abe"
    "github.com/stretchr/testify/assert"
    "testing"
)

func TestMAABE(t *testing.T) {
    // create new MAABE struct with Global Parameters
    maabe := abe.NewMAABE()

    // create three authorities, each with two attributes
    attribs1 := []string{"auth1:at1", "auth1:at2"}
    attribs2 := []string{"auth2:at1", "auth2:at2"}
    attribs3 := []string{"auth3:at1", "auth3:at2"}
    auth1, err := maabe.NewMAABEAuth("auth1", attribs1)
    if err != nil {
       t.Fatalf("Failed generation authority %s: %v\n", "auth1", err)
    }
    auth2, err := maabe.NewMAABEAuth("auth2", attribs2)
    if err != nil {
       t.Fatalf("Failed generation authority %s: %v\n", "auth2", err)
    }
    auth3, err := maabe.NewMAABEAuth("auth3", attribs3)
    if err != nil {
       t.Fatalf("Failed generation authority %s: %v\n", "auth3", err)
    }

    // create a msp struct out of the boolean formula
    msp, err := abe.BooleanToMSP("((auth1:at1 AND auth2:at1) OR (auth1:at2 AND auth2:at2)) OR (auth3:at1 AND auth3:at2)", false)
    if err != nil {
       t.Fatalf("Failed to generate the policy: %v\n", err)
    }

    // define the set of all public keys we use
    pks := []*abe.MAABEPubKey{auth1.PubKeys(), auth2.PubKeys(), auth3.PubKeys()}

    // choose a message
    msg := "Attack at dawn!"

    // encrypt the message with the decryption policy in msp
    ct, err := maabe.Encrypt(msg, msp, pks)
    if err != nil {
       t.Fatalf("Failed to encrypt: %v\n", err)
    }

    // also check for empty message
    msgEmpty := ""
    _, err = maabe.Encrypt(msgEmpty, msp, pks)
    assert.Error(t, err)

    // use a pub keyring that is too small
    pksSmall := []*abe.MAABEPubKey{auth1.PubKeys()}
    _, err = maabe.Encrypt(msg, msp, pksSmall)
    assert.Error(t, err)

    // choose a single user's Global ID
    gid := "gid1"

    // authority 1 issues keys to user
    keys1, err := auth1.GenerateAttribKeys(gid, attribs1)
    if err != nil {
       t.Fatalf("Failed to generate attribute keys: %v\n", err)
    }
    key11, key12 := keys1[0], keys1[1]
    // authority 2 issues keys to user
    keys2, err := auth2.GenerateAttribKeys(gid, attribs2)
    if err != nil {
       t.Fatalf("Failed to generate attribute keys: %v\n", err)
    }
    key21, key22 := keys2[0], keys2[1]
    // authority 3 issues keys to user
    keys3, err := auth3.GenerateAttribKeys(gid, attribs3)
    if err != nil {
       t.Fatalf("Failed to generate attribute keys: %v\n", err)
    }
    key31, key32 := keys3[0], keys3[1]

    // try and generate key for an attribute that does not belong to the
    // authority (or does not exist)
    _, err = auth3.GenerateAttribKeys(gid, []string{"auth3:at3"})
    assert.Error(t, err)

    // user tries to decrypt with different key combos
    ks1 := []*abe.MAABEKey{key11, key21, key31} // ok
    ks2 := []*abe.MAABEKey{key12, key22, key32} // ok
    ks3 := []*abe.MAABEKey{key11, key22}        // not ok
    ks4 := []*abe.MAABEKey{key12, key21}        // not ok
    ks5 := []*abe.MAABEKey{key31, key32}        // ok

    // try to decrypt all messages
    msg1, err := maabe.Decrypt(ct, ks1)
    if err != nil {
       t.Fatalf("Error decrypting with keyset 1: %v\n", err)
    }
    assert.Equal(t, msg, msg1)

    msg2, err := maabe.Decrypt(ct, ks2)
    if err != nil {
       t.Fatalf("Error decrypting with keyset 2: %v\n", err)
    }
    assert.Equal(t, msg, msg2)

    _, err = maabe.Decrypt(ct, ks3)
    assert.Error(t, err)

    _, err = maabe.Decrypt(ct, ks4)
    assert.Error(t, err)

    msg5, err := maabe.Decrypt(ct, ks5)
    if err != nil {
       t.Fatalf("Error decrypting with keyset 5: %v\n", err)
    }
    assert.Equal(t, msg, msg5)

    // generate keys with a different GID
    gid2 := "gid2"
    // authority 1 issues keys to user
    foreignKeys, err := auth1.GenerateAttribKeys(gid2, []string{"auth1:at1"})
    if err != nil {
       t.Fatalf("Failed to generate attribute key for %s: %v\n", "auth1:at1", err)
    }
    foreignKey11 := foreignKeys[0]
    // join two users who have sufficient attributes together, but not on their
    // own
    ks6 := []*abe.MAABEKey{foreignKey11, key21}
    // try and decrypt
    _, err = maabe.Decrypt(ct, ks6)
    assert.Error(t, err)

    // add a new attribute to some authority
    err = auth3.AddAttribute("auth3:at3")
    if err != nil {
       t.Fatalf("Error adding attribute: %v\n", err)
    }
    // now try to generate the key
    _, err = auth3.GenerateAttribKeys(gid, []string{"auth3:at3"})
    if err != nil {
       t.Fatalf("Error generating key for new attribute: %v\n", err)
    }

    // regenerate a compromised key for some authority
    err = auth1.RegenerateKey("auth1:at2")
    if err != nil {
       t.Fatalf("Error regenerating key: %v\n", err)
    }
    // regenerate attrib key for that key and republish pubkey
    keysNew, err := auth1.GenerateAttribKeys(gid, []string{"auth1:at2"})
    if err != nil {
       t.Fatalf("Error generating attrib key for regenerated key: %v\n", err)
    }
    key12New := keysNew[0]
    pks = []*abe.MAABEPubKey{auth1.Pk, auth2.Pk, auth3.Pk}
    // reencrypt msg
    ctNew, err := maabe.Encrypt(msg, msp, pks)
    if err != nil {
       t.Fatalf("Failed to encrypt with new keys")
    }
    ks7 := []*abe.MAABEKey{key12New, key22}
    // decrypt reencrypted msg
    msg7, err := maabe.Decrypt(ctNew, ks7)
    if err != nil {
       t.Fatalf("Failed to decrypt with regenerated keys: %v\n", err)
    }
    assert.Equal(t, msg, msg7)
}

1. ABE加密算法核心

将（属性、策略P）嵌入到（密钥K、密文C）中。

根据嵌入的对象不同，划分成了KP-ABE与CP-ABE。

KP-ABE（基于密钥策略的属性加密）是将策略嵌入到密钥中，属性嵌入到密文中。
CP-ABE（基于密文策略的属性加密）是将策略嵌入到密文中，属性嵌入到密钥中。

注：“属性”的概念，“策略”的概念，属性是事物或者信息文件的特征，策略则是这些特征之间的与或关系。

2.应用场景

CP-ABE由于策略嵌入密文中，这就意味着，数据拥有者可以通过设定策略去决定拥有哪些属性的人能够访问这份密文，也就相当于对这份数据做了一个粒度可以细化到属性级别的加密访问控制。

CP-ABE的应用场景一般是公有云上的数据加密存储与细粒度共享；
KP-ABE的应用场景则更加偏向于付费视频网站、日志加密管理等等。

3.ABE的优势我们以CP-ABE为例，举一个简单的例子说明ABE相较传统公钥加密算法的优势。一个数据拥有者需要将一份明文文件，加密发送给N个不同的用户，倘若使用传统公钥加密算法，数据拥有者需要首先保存这N个用户的公钥（不考虑公钥证书的情况下），利用这N个不同公钥，使用该份明文文件，加密N次，形成N份不同的密文，分别发送给这个N个用户。

（传统公钥方案）

若使用ABE来完成这项任务则会轻松很多。此时，数据拥有者只需要制定一条仅有这N个用户才能满足的访问策略，接着输入公共参数PP、该条策略以及明文文件至ABE加密算法，进行加密一次，形成唯一一份密文。得到密文后，数据拥有者将该份密文分别发送给这N个不同用户。

（ABE方案）

从加密计算开销与存储开销的角度来看，ABE在该场景下（数据加密共享场景）相较于传统公钥加密算法，有着肉眼可见的性能优势，此处便不再赘述。

4.密文策略基于属性加密(CP-ABE)访问树构造与解密

4.1访问树构造

在CP-ABE方案中，访问树用于隐藏源数据的加密密钥，其形状结构如其名一样，是一棵树。其叶子节点为数据所有者设定的属性和属性值以及父节点传于此节点的秘密值，并对其加密处理，只有数据访问者拥有此属性方可解密出此节点的秘密值；非叶子节点为门限节点，数据访问者需满足此门限最低值方可解密此节点秘密值，例如门限为3/5，此节点有5个子节点，数据访问者需至少满足3个子节点才能解密出秘密值。如下图所构造的访问树，能解密此访问树加密的源数据，数据访问者需满足的属性。

从根节点开始，其门限值为2，孩子节点有3个，随机生成一个多项式，其最高次数为门限值少1，故根节点的最高次数为1，然后将常数项设置为秘密数（秘密数为需要秘密保存的数）；如此根节点随机的多项式为f(x)=5+3x，秘密数为5。此外，将根节点的孩子节点从左至右依次标记为1,2,3,.....，将节点标记值代入f(x)函数中，所得值（即生成新的秘密值）传给该标记的孩子节点秘密保存；故“3/3”节点（左边第一个节点）标记为1，传给“3/3”节点的秘密值f(1)=5+3*1=8，中间“教师”节点（中间节点）标记为2，传给“教师”节点的秘密值f(2)=5+3*2=11，“1/2”节点（右边节点）标记为3，传给“1/2”节点的秘密值为f(3)=5+3*3=14。

“3/3”节点和“1/2”节点在接收到父节点传来的值后，按照上述方式生成随机多项式，将常数项设置为父节点传来的值，此外也按照上述方式生成新的秘密值并将它传给子节点，数据如图所示（对于非叶子节点，都按照此方式进行）。"3/3"节点门限值为3，所以最高次数为3-1=2。对于叶子节点，在接受到父节点的秘密值后，用此叶子节点的属性对秘密值进行加密处理。至此，访问树已构造完成！

4.2解密

对于叶子节点，在数据访问者属性集中寻找出和此节点属性与属性值一致的属性，用找出的属性解密出此节点的秘密值（即公式1），当然不能完全解密出，他是秘密值和加密时对此属性设置的加密值的乘积。

解密出叶子节点后，开始解密其父节点（非叶子节点），在解密出叶子节点后，即可得到多对值；如在上述访问树的“3/3”节点，其孩子节点解密出三个值19，44，83（推理过程忽略随机数），在生成这三个数时，f(1)=19，f(2)=44，f(3)=83，其中f(x)=8+4x+7x^2（解密时并不知道此多项式，只知道后面的三个点），因此在f(x)上有三个点是（1，19），（2，44），（3，83）；因为此节点存储的秘密值是多项式的常数项，即f(0)=秘密值，故我们需要根据这三个点得到0所对应的值是多少，根据拉格朗日公式就能求出0所对应的值，即解密出秘密值（即公式2）；对于非叶子节点均可按照上述方式解密出秘密值，在根节点处解密出整个树所隐藏的秘密值（是秘密值和加密时对此属性设置的加密值的乘积，所有节点解密出的秘密都存在一个随机数，解密出的值都是随机数和秘密值的乘积，只是讲述过程中为了方便忽略了随机数，最后根节点解密出的随机数在最后的解密过程中会抵消掉（公式3））。

另外需要说明的是“3/3”节点是一个3个孩子节点、门限值为3的节点，相当于且关系，数据访问者需解密出所有的孩子节点方可用拉格朗日公式解密出常数项（即秘密值）；“1/2”节点是一个2个孩子节点、门限值为1的节点，故为或关系，数据访问者只满足其中一个孩子节点即可解密出秘密值（秘密值就是孩子节点解密出的秘密值，因为根据随机多项式生成规则，多项式的最高次数为门限值少1，门限值为1，故最高次数为0，即常数项）；若如“2/3”这样的节点，既非且关系，也非或关系，3个孩子节点，门限值为2，若需解密出此节点的秘密值，数据访问者需解密出三个孩子节点中的两个节点即可解密出孩子节点。