使用 KMS 白盒密钥保护 COS SecretKey 最佳实践

echo lY9Ynrabcdj05YH1234LE37xxxx | openssl base64

/*
#cgo CFLAGS: -I${SRCDIR}/include
#cgo LDFLAGS: -L${SRCDIR}/lib -lydwbcrypto

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "wrp.h"

static int clt_load_key(WRP_KEY_CTX *key_ctx, char *decrypt_key_path, const char *file_name,
        uint32_t mode, uint32_t algoType) {
    printf("begin to load key in dir: %s\\n", decrypt_key_path);
    printf("begin to load key: %s\\n", file_name);
    int err;
    const WRP_KEY* keyalg = WRP_KEY_wbaes();
    if (algoType == 1) { keyalg = WRP_KEY_wbsm4(); }

    err = WRP_KEY_init(key_ctx, keyalg, 0);
    if (err) { printf("Err: orig_byte init\\n"); goto end; }

    err = WRP_KEY_ctrl(key_ctx, WRP_KEY_CTRL_WB_SET_PATH, decrypt_key_path, strlen(decrypt_key_path));
    if (err) { printf("Err: set path\\n"); goto end; }

    err = WRP_KEY_import(key_ctx, file_name, mode);
    if (err) { printf("Err: WRP_KEY_import error: %d， \\n", err); goto end; }

end:
    return err;
}


int clt_cbc_dec(char * file_dir, const char * file_name, uint8_t* ciph, uint32_t ciphlen, char* iv,
        uint32_t algoType, uint8_t* out, uint32_t* outlen) {
    WRP_KEY_CTX *mykey;
    WRP_CIPHER_CTX *myaes = NULL;

    uint32_t bits;
    ERRNO err = ERRNO_OK;

    const WRP_CIPHER* alg = WRP_wbaes_cbc();
    if (algoType == 1) { alg = WRP_wbsm4_cbc(); }

    // IO: load wbkey
    mykey = WRP_KEY_CTX_new();
    err = clt_load_key(mykey, file_dir, file_name, KEYMODE_DECRYPT, algoType);
    if (err) { printf("load whitebox key error: %d\\n", err); goto cleanup; }

    printf("load key success\\n");
    bits = WRP_KEY_key_len(mykey, KEYLEN_TYPE_BITS);
    printf("key len=%u\\n", bits);

    if (bits == 0) { printf("get whitebox key length error\\n"); err=-1; goto cleanup; }

    // crypto
    myaes = WRP_CIPHER_CTX_new();

    err = WRP_CIPHER_Decrypt_init(myaes, alg, mykey, (uint8_t *)iv);
    if (err) { printf("Dec: init Err**\\n"); goto cleanup; }
    printf("decrypt init success, begin to decrypt cipher\\n");

    err = WRP_CIPHER_Decrypt_doCipher(myaes, ciph, ciphlen, out, outlen);
    if (err) { printf("decrypt error: %.8X\\n", err); goto cleanup; }
    //printf("decrypt success\\n");
    //printf("output: %s\\n", deout);
    //printf("\\n");

cleanup:
    WRP_KEY_CTX_free(mykey);
    WRP_CIPHER_CTX_free(myaes);
    return err;
}

void set_fingerprint_env_name(char *fingerprint_env_name) {
    WRP_getENV_KEY((uint8_t *)fingerprint_env_name, strlen(fingerprint_env_name));
}

*/
import “C”

// Decrypt ...
func Decrypt(input DecryptionInput) ([]byte, error) {
    if input.KeyDir == "" || input.KeyFileName == "" || input.CipherText == "" || input.InitializationVector == "" {
        return nil, errors.New("invalid white-box decryption input")
    }
    cipher, err := base64.StdEncoding.DecodeString(input.CipherText)
    if err != nil {
        return nil, fmt.Errorf("failed to decode cipher text: %w", err)
    }
    iv, err := base64.StdEncoding.DecodeString(input.InitializationVector)
    if err != nil {
        return nil, fmt.Errorf("failed to decode initialization vector: %w", err)
    }

    decryptionKeyDir := C.CString(input.KeyDir)
    defer C.free(unsafe.Pointer(decryptionKeyDir))

    decryptionKeyFileName := C.CString(input.KeyFileName)
    defer C.free(unsafe.Pointer(decryptionKeyFileName))

    // malloc a buffer which size is a little greater than your plaintext
    outLen := len(input.CipherText) + 1024
    outBuf := C.malloc(C.size_t(outLen))
    defer C.free(unsafe.Pointer(outBuf))

    errC := C.clt_cbc_dec(
        decryptionKeyDir, decryptionKeyFileName,
        (*C.uchar)(unsafe.Pointer(&cipher[0])),
        C.uint(len(cipher)),
        (*C.char)(unsafe.Pointer(&iv[0])),
        C.uint(input.AlgorithmType),
        (*C.uchar)(outBuf),
        (*C.uint)(unsafe.Pointer(&outLen)),
    )
    if errC != 0 {
        return nil, fmt.Errorf("whitebox decryption failed with code %d", int(errC))
    }
    plain := C.GoBytes(outBuf, C.int(outLen))
    return plain, nil
}

func main() {
    //将<bucket>和<region>修改为真实的信息
    //bucket的命名规则为{name}-{appid} ，此处填写的存储桶名称必须为此格式
    u, _ := url.Parse("https://<bucket>.cos.<region>.myqcloud.com")
    // 使用环境变量指定白盒密钥相关信息，以及加密后的 secret ID 以及 secret key。
    encryptionAlgorithm, _ := strconv.Atoi(os.Getenv("EncryptionAlgorithm"))
    whiteboxDecryptInput := DecryptionInput{
        KeyDir:               os.Getenv("WhiteboxKeyDir"),      // e.g.: /usr/local/
        KeyFileName:          os.Getenv("WhiteboxKeyFileName"), // e.g.: whitebox_key.bin
        InitializationVector: os.Getenv("WhiteboxDecryptionIV"),
        AlgorithmType:        uint(encryptionAlgorithm),
    }
    // 使用白盒 sdk 解密 secret ID
    whiteboxDecryptInput.CipherText = os.Getenv("COS_Encrypted_Secret_ID")
    secretID, err := Decrypt(whiteboxDecryptInput)
    if err != nil {
        panic(err)
    }
    // 使用白盒 sdk 解密 secret key
    whiteboxDecryptInput.CipherText = os.Getenv("COS_Encrypted_Secret_Key")
    secretKey, err := Decrypt(whiteboxDecryptInput)
    if err != nil {
        panic(err)
    }

    b := &cos.BaseURL{BucketURL: u}
    c := cos.NewClient(b, &http.Client{
        //设置超时时间
        Timeout: 100 * time.Second,
        Transport: &cos.AuthorizationTransport{
            //如实填写账号和密钥，也可以设置为环境变量
            SecretID:  string(secretID),
            SecretKey: string(secretKey),
        },
    })

    name := "test/hello.txt"
    resp, err := c.Object.Get(context.Background(), name, nil)
    if err != nil {
        panic(err)
    }
    bs, _ := ioutil.ReadAll(resp.Body)
    _ = resp.Body.Close()
    fmt.Printf("%s\\n", string(bs))
}

type DecryptionInput struct {
    KeyDir               string
    KeyFileName          string
    InitializationVector string // Base64 encoded.
    CipherText           string // Base64 encoded.
    AlgorithmType        uint   // 0: AES_256, 1: SM4.
}