加密和序列化 stl 字符串和其他容器

Question

我在 stl 容器（向量）中有数据。向量中的每个节点都是一个结构，其中也包含 stl 字符串。

struct record
{
string name;
string location;
int salary;
}

vector< record > employees;

我想对员工进行序列化，但我也想在序列化之前对其进行加密。

我的加密函数是这样的：

Encode(const char * inBfr, const int in_size, char ** outBfr, int& out_size )

通过搜索，stl 标准似乎不需要我的结构的内存是连续的，所以我不能只获取 employees 变量的内存。有没有其他智能方法可以将此编码功能与基于 stl 的结构/容器一起使用？ Encode 函数在普通的 char * 缓冲区中工作对我有好处，所以我确切地知道进出什么，但 stl 结构不是，我正在努力寻找一种好方法，以便我可以将 stl 与这个函数一起使用。

如果有帮助，我也愿意使用任何其他 stl 容器。

Answer 1

虽然std::vector<T> 中的元素保证连续布局，但这并没有真正的帮助：您拥有的记录可能包括填充，更重要的是，会将std::string 的内容存储在std::string 对象（如果使用小字符串优化，该值可能嵌入在 std::string 中，但它也将包含几个不属于 std::strings 值的字节）。因此，您最好的选择是格式化您的记录并加密格式化的字符串。

格式很简单，但我个人会将编码函数封装成一个简单的std::streambuf，以便可以通过过滤流缓冲区完成加密。鉴于您给出的签名，这可能看起来像这样：

class encryptbuf
    : public std::streambuf {
    std::streambuf* d_sbuf;
    char            d_buffer[1024];
public:
    encryptbuf(std::streambuf* sbuf)
        : d_sbuf(sbuf) {
        this->setp(this->d_buffer, this->d_buffer + sizeof(this->d_buffer) - 1);
    }
    int overflow(int c) {
        if (c != std::char_traits<char>::eof()) {
            *this->pptr() = std::char_traits<char>::to_char_type(c);
            this->pbump(1);
        }
        return this->pubsync()? std::char_traits<char>::eof(): std::char_traits<char>::not_eof(c);
    }
    int sync() {
        char* out(0);
        int   size(0);
        Encode(this->pbase(), this->pptr() - this->pbase(), &out, size);
        this->d_sbuf->sputn(out, size);
        delete[] out; // dunno: it seems the output buffer is allocated but how?
        this->setp(this->pbase(), this->epptr());
        return this->d_sbuf->pubsync();
    }
};

int main() {
    encryptbuf    sbuf(std::cout.rdbuf());
    std::ostream eout(&sbuf);
    eout << "print something encoded to standard output\n" << std::flush;
}

现在，为您的记录创建一个输出运算符，只需打印到 std::ostream 即可用于创建编码

Answer 2

将结构序列化为字符串，然后加密字符串可能是最简单的方法。例如：

std::ostringstream buffer;

buffer << a_record.name << "\n" << a_record.location << "\n" << a_record.salary;

encode(buffer.str().c_str(), buffer.str().length(), /* ... */);

如果是我，我可能会写 encode（或者至少是它的包装器）来获取向量、字符串或流中的输入（并可能产生输出）。

如果你想雄心勃勃，还有其他可能性。首先，@MooingDuck 提出了一个很好的观点，即通常值得为班级重载operator<<，而不是一直处理单个项目。这通常是一个类似于上面的小函数：

std::ostream &operator<<(std::ostream &os, record const &r) { 
    return os << r.name << "\n" << r.location << "\n" << r.salary;
}

使用它，您只需：

std::ostringstream os;
os << a_record;

encode(os.str().c_str(), os.str().length(), /* ... */);

其次，如果你想变得更加雄心勃勃，你可以将加密放入（例如）codecvt facet，这样你就可以在将所有数据写入流时自动加密所有数据，并将其解密为你读回来。另一种可能性是将加密构建到过滤streambuf对象中。 codecvt facet 可能是理论上应该首选的方法，但streambuf 几乎可以肯定更容易实现，涉及的不相关“东西”更少。