如何在C/C中将十六进制字符串转换为十六进制字符数组[重复]

Question

我有一个十六进制值字符串，由空格分隔。

std::string hexString = "0x60 0xC7 0x80" and so on...

我需要读取这个，并存储在无符号char数组中：

unsigned char array[] = {0x60, 0xC7, 0x80}.

我被这件事缠住了。有人能帮忙吗？

场景：

我正在写AES 256 CBC加密/解密程序。加密和解密部分是隔离的。我们计划用（key，value）将数据库密码从明文加密到存储在配置文件中的加密密码。独立加密二进制文件将生成一个十六进制等效文件。我们分别加密所有必要的属性，并将它们写入配置文件。应用程序在运行时应该对这些配置进行解密，以便将其用于连接到数据库等。我必须读取十六进制字符串，并将其作为字符数组发送给AES解密算法。




Answer 1

我有std:：string hextstring。。。我需要将其存储在无符号字符数组[]中。

请看看下面这个基于函数的解决方案。输入字符串可以由任意数量的空格和/或制表符组成，可能后面跟着一个符号，后面跟着一串数字。因此，即使是不完美的输入，如"01 2\t ab\t\t 3\n"也可以正确解析。

功能：

unsigned char * create_hex_array (const std::string * str, size_t * nr_of_elements);

获取指向输入的指针std:：string hextstring创建并返回无符号字符数组以及数组中元素的计数。

#include <iostream>     // std::cout, std::endl
#include <sstream>      // std::stringstream
#include <iomanip>      // std::setfill, std::setw
#include <string>       // std::string
#include <cstring>      // functions to manipulate C strings and arrays

unsigned char * create_hex_array (const std::string * str, size_t * nr_of_elements)
{
    size_t index = 0;                       // elements counter       
    size_t arr_len = str->size () / 2 + 1;  // maximum number or array elements        
    const char *current = str->c_str ();    // start from the beginning of the string   
    char *end = NULL;                       // init the end pointer 
    unsigned char *arr = new unsigned char[arr_len]; // allocate memory for our array

    while (1)
    {
        unsigned long hex = strtoul (current, &end, 16);  
        if (current == end)                 // end of string reached
            break;
        arr[index] = (unsigned char) hex;   // store the hex number in the array 
        index++;                            // increase index to the next slot in array    
        current = end;                      // move the to next number
    }

    *nr_of_elements = index;                // return number of elements in the array             
    return arr;                             // return created array 
}

void print_hex_array (size_t size, unsigned char *arr)
{
    std::cout << "Nr of elements in the array is = " << size << std::endl;
    // Fancy print out:
    // Getting a buffer into a stringstream in hex representation with zero padding
    // with 0-padding on small values so  `5` would become `05`
    std::stringstream ss;
    ss << std::hex << std::setfill ('0');

    for (size_t i = 0; i < size; i++)
    {
        // In C this is enough:  printf("%02x ", arr[i]);
        ss << std::setw (2) << static_cast < unsigned >(arr[i]) << " ";
    }

    std::cout << ss.rdbuf() << std::endl;
}

int main ()
{
    const std::string hexString = " 5 8d  77 77 96 1 \t\t bc 95 b9 ab 9d 11 \n";  
    size_t arr_size;                    // Number of elements in the array

    unsigned char * array = create_hex_array (&hexString, &arr_size); 
    print_hex_array (arr_size, array);  // printout with 0- padding.

    delete[]array;                      // release memory
    return 0;
}

输出：

Nr of elements in the array is = 12                                                                                                                    
05 8d 77 77 96 01 bc 95 b9 ab 9d 11 

Answer 2

下面是一个例子：

#include <regex>
#include <string>
#include <iostream>

template <typename Iterator>
class iterator_pair {
    public:
        iterator_pair(Iterator first, Iterator last): f_(first), l_(last) {}
        Iterator begin() const { return f_; }
        Iterator end() const { return l_; }

    private:
        Iterator f_;
        Iterator l_;
};

template <typename Iterator>
iterator_pair<Iterator> make_iterator_pair(Iterator f, Iterator l) {
    return iterator_pair<Iterator>(f, l);
}

int main() {
    std::string hexString = "0x60 0xC7 0x80";
    std::regex whitespace("\\s+");
    std::vector<int> hexArray;

    auto tokens = make_iterator_pair(
            std::sregex_token_iterator(hexString.begin(), hexString.end(), whitespace, -1),
            std::sregex_token_iterator());

    for (auto token : tokens)
        hexArray.push_back(stoi(token, 0, 0));

    for (auto hex : hexArray)
        std::cout << hex << std::endl;
}