同态加密使用说明（Go）

// Init函数用于初始化两个键值对，用户输入的参数为KEY1_NAME, VALUE1, KEY2_NAME, VALUE2,其中VALUE1和VALUE2都是同态加密后的数据
// 在例子中，VALUE1是cipher1.pai的内容， VALUE2是ciphe2.pai的内容
func (t *SimpleChaincode) Init(stub shim.ChaincodeStubInterface) pb.Response {
    fmt.Println("ex02 Init")
    // 调用API GetFunctionAndParameters 获取用户输入参数
    _, args := stub.GetFunctionAndParameters()
    var A, B string    // Entities
    var Aval, Bval string // Asset holdings
    var err error

    if len(args) != 4 {
        return shim.Error("Incorrect number of arguments. Expecting 4")
    }

    // Initialize the chaincode
    A = args[0]
    Aval = args[1]

    B = args[2]
    Bval = args[3]

    // 调用API PutState把数据写入账本
    // Write the state to the ledger
    err = stub.PutState(A, []byte(Aval))
    if err != nil {
        return shim.Error(err.Error())
    }

    err = stub.PutState(B, []byte(Bval))
    if err != nil {
        return shim.Error(err.Error())
    }

    return shim.Success(nil)
}

// Invoke把用户调用的function细分到几个子function, 包含invoke和query
func (t *SimpleChaincode) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
    fmt.Println("ex02 Invoke")
    // 调用API GetFunctionAndParameters获取用户输入的业务类型和参数
    function, args := stub.GetFunctionAndParameters()
    if function == "invoke" {
        // Make payment of X units from A to B
        return t.invoke(stub, args)
    } else if function == "query" {
        // the old "Query" is now implemtned in invoke
        return t.query(stub, args)
    } 
    return shim.Error("Invalid invoke function name")
}

// invoke实现两个键之间的value转移，输入为KEY1_NAME, KEY1_PUBKEYINHEX, KEY2_NAME，KEY2_PUBKEYINHEX，VALUE
// 在例子中，KEY1_PUBKEYINHEX是pk1.pai内容的base64, KEY2_PUBKEYINHEX是pk2.pai的内容base64
func (t *SimpleChaincode) invoke(stub shim.ChaincodeStubInterface, args []string) pb.Response {
    var A, B string    // Entities
    var Apkpem, Bpkpem []byte //public key in hex 

    var Aval, Bval string // Asset encrypted holdings
    var X *big.Int          // Transaction value
    var err error

    if len(args) != 5 {
        return shim.Error("Incorrect number of arguments. Expecting 5")
    }

    A = args[0]
    Apkpem, err = base64.StdEncoding.DecodeString(args[1])
    if err != nil {
        return shim.Error("Failed to get Apkpem in hex")
    }

    B = args[2]
    Bpkpem, err = base64.StdEncoding.DecodeString(args[3])
    if err != nil{
        return shim.Error("Failed to get Bpkpem in hex")
    }
    X, isOK := new(big.Int).SetString(args[4], 10)
    if !isOK {
        return shim.Error("Fail to get X")
    }

    // Get the state from the ledger
    // API GetState获取对应账户的资产，这里的资产是同态加密后的数据
    Avalbytes, err := stub.GetState(A)
    if err != nil {
        return shim.Error("Failed to get state")
    }
    if Avalbytes == nil {
        return shim.Error("Entity not found")
    }
    Aval = string(Avalbytes)

    Bvalbytes, err := stub.GetState(B)
    if err != nil {
        return shim.Error("Failed to get state")
    }
    if Bvalbytes == nil {
        return shim.Error("Entity not found")
    }
    Bval = string(Bvalbytes)

    // 执行具体业务逻辑，这里是对应资产进行转移
    // Perform the execution
    // 调用同态接口GetPublicKeyFromHex获取公钥信息
    Apk, err := paillier.GetPublicKeyFromHex(string(Apkpem))
    if err != nil {
        return shim.Error("Fail to get A public key in PublicKey")
    }
    // 调用同态接口GetCiphertextFromHex获取同态密文信息
    Acipher, err := paillier.GetCiphertextFromHex(Aval)
    if err != nil {
        return shim.Error("Fail to get Ciphertext for A")
    }


    // 调用同态接口Sub执行密文和明文相减
    Aciphernew, err := paillier.Sub(Apk, Acipher, X.Text(10))
    if err != nil {
        return shim.Error("Fail to compute Aciphernew")
    }
    // 调用同态接口GetCiphertextHex获取同态密文16进制string
    Avalnew, err := paillier.GetCiphertextHex(Aciphernew)
    if err != nil {
        return shim.Error("Fail to get Avalnew")
    }

    Bpk, err := paillier.GetPublicKeyFromHex(string(Bpkpem))
    if err != nil {
        return shim.Error("Fail to get B public key in PublicKey")
    }

    Bcipher, err := paillier.GetCiphertextFromHex(Bval)
    if err != nil {
        return shim.Error("Fail to get Ciphertext for B")
    }
    // 调用同态接口Add执行密文和明文相加
    Bciphernew, err := paillier.Add(Bpk, Bcipher, X.Text(10))
    if err != nil {
        return shim.Error("Fail to compute Bciphernew")
    }

    Bvalnew, err := paillier.GetCiphertextHex(Bciphernew)
    if err != nil {
        return shim.Error("Fail to get Bvalnew")
    }

    // API PutState将对应资产写入账本
    // Write the state back to the ledger
    err = stub.PutState(A, []byte(Avalnew))
    if err != nil {
        return shim.Error(err.Error())
    }

    err = stub.PutState(B, []byte(Bvalnew))
    if err != nil {
        return shim.Error(err.Error())
    }

    return shim.Success(nil)
}

// query主要是查询键对应的值，输入为KEY_NAME
// query callback representing the query of a chaincode
func (t *SimpleChaincode) query(stub shim.ChaincodeStubInterface, args []string) pb.Response {
    var A string // Entities
    var err error

    if len(args) != 1 {
        return shim.Error("Incorrect number of arguments. Expecting name of the person to query")
    }

    A = args[0]

    // Get the state from the ledger
    Avalbytes, err := stub.GetState(A)
    if err != nil {
        jsonResp := "{\\"Error\\":\\"Failed to get state for " + A + "\\"}"
        return shim.Error(jsonResp)
    }

    if Avalbytes == nil {
        jsonResp := "{\\"Error\\":\\"Nil amount for " + A + "\\"}"
        return shim.Error(jsonResp)
    }

    return shim.Success(Avalbytes)
}

./paitool decrypt -skin=sk1.pai -cipherin=cipher1new.pai
./paitool decrypt -skin=sk2.pai -cipherin=cipher2new.pai