linux c++ 使用sm4加密字符串123456并使用加密后的值做base64输出要求使用sm4源码和base64源码实现封装成类 给出加密解密的代码给出实现代码

以下是使用SM4和Base64源码实现加密和解密的C++类的示例代码：

#include <iostream>
#include <cstring>
#include <openssl/evp.h>
#include <openssl/sm4.h>
#include <openssl/bio.h>
#include <openssl/buffer.h>

class SM4Base64Encryptor {
public:
    SM4Base64Encryptor(const std::string& key) {
        // 初始化SM4加密上下文
        sm4_ctx = SM4_CTX_new();
        SM4_set_key(sm4_ctx, (const unsigned char*)key.c_str(), SM4_ENCRYPT);

        // 初始化Base64编码上下文
        base64_ctx = BIO_new(BIO_f_base64());
        bio_buf = BIO_new(BIO_s_mem());
        BIO_push(base64_ctx, bio_buf);
    }

    ~SM4Base64Encryptor() {
        // 释放资源
        SM4_CTX_free(sm4_ctx);
        BIO_free_all(base64_ctx);
    }

    std::string encrypt(const std::string& plaintext) {
        // 加密
        std::string ciphertext;
        int block_size = SM4_BLOCK_SIZE;
        unsigned char* input = (unsigned char*)plaintext.c_str();
        int input_length = plaintext.length();
        int output_length = input_length + block_size - (input_length % block_size);
        unsigned char* output = new unsigned char[output_length];
        memset(output, 0, output_length);
        SM4_cbc_encrypt(input, output, input_length, sm4_ctx, iv, SM4_ENCRYPT);

        // Base64编码
        BIO_write(base64_ctx, output, output_length);
        BIO_flush(base64_ctx);

        char* encoded_output;
        long encoded_output_length = BIO_get_mem_data(bio_buf, &encoded_output);
        ciphertext.assign(encoded_output, encoded_output_length);

        delete[] output;
        return ciphertext;
    }

    std::string decrypt(const std::string& ciphertext) {
        // Base64解码
        BIO_write(base64_ctx, ciphertext.c_str(), ciphertext.length());
        BIO_flush(base64_ctx);

        char* decoded_input;
        long decoded_input_length = BIO_get_mem_data(bio_buf, &decoded_input);

        // 解密
        std::string plaintext;
        int block_size = SM4_BLOCK_SIZE;
        unsigned char* input = (unsigned char*)decoded_input;
        int input_length = decoded_input_length;
        unsigned char* output = new unsigned char[input_length];
        memset(output, 0, input_length);
        SM4_cbc_encrypt(input, output, input_length, sm4_ctx, iv, SM4_DECRYPT);
        plaintext.assign((char*)output, input_length);

        delete[] output;
        return plaintext;
    }

private:
    SM4_CTX* sm4_ctx;
    BIO* base64_ctx;
    BIO* bio_buf;
    unsigned char iv[SM4_BLOCK_SIZE] = {0};
};

int main() {
    std::string key = "1234567890123456";
  
    SM4Base64Encryptor encryptor(key);
    std::string ciphertext = encryptor.encrypt("123456");
    std::cout << "Ciphertext: " << ciphertext << std::endl;

    std::string plaintext = encryptor.decrypt(ciphertext);
    std::cout << "Plaintext: " << plaintext << std::endl;

    return 0;
}

请注意，在编译之前，需要确保已安装OpenSSL库，并在编译时链接-lcrypto选项。

编译命令示例：`g++ main.cpp -o main -lcrypto