身份证识别

#include <iostream>
#include <curl/curl.h>

// libcurl库下载链接：https://curl.haxx.se/download.html
// jsoncpp库下载链接：https://github.com/open-source-parsers/jsoncpp/
const static std::string request_url = "https://aip.baidubce.com/rest/2.0/ocr/v1/idcard";
static std::string idcard_result;
/**
 * curl发送http请求调用的回调函数，回调函数中对返回的json格式的body进行了解析，解析结果储存在全局的静态变量当中
 * @param 参数定义见libcurl文档
 * @return 返回值定义见libcurl文档
 */
static size_t callback(void *ptr, size_t size, size_t nmemb, void *stream) {
    // 获取到的body存放在ptr中，先将其转换为string格式
    idcard_result = std::string((char *) ptr, size * nmemb);
    return size * nmemb;
}
/**
 * 身份证识别
 * @return 调用成功返回0，发生错误返回其他错误码
 */
int idcard(std::string &json_result, const std::string &access_token) {
    std::string url = request_url + "?access_token=" + access_token;
    CURL *curl = NULL;
    CURLcode result_code;
    int is_success;
    curl = curl_easy_init();
    if (curl) {
        curl_easy_setopt(curl, CURLOPT_URL, url.data());
        curl_easy_setopt(curl, CURLOPT_POST, 1);
        curl_httppost *post = NULL;
        curl_httppost *last = NULL;
        curl_formadd(&post, &last, CURLFORM_COPYNAME, "id_card_side", CURLFORM_COPYCONTENTS, "front", CURLFORM_END);
        curl_formadd(&post, &last, CURLFORM_COPYNAME, "image", CURLFORM_COPYCONTENTS, "【base64_img】", CURLFORM_END);

        curl_easy_setopt(curl, CURLOPT_HTTPPOST, post);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, callback);
        result_code = curl_easy_perform(curl);
        if (result_code != CURLE_OK) {
            fprintf(stderr, "curl_easy_perform() failed: %s\n",
                    curl_easy_strerror(result_code));
            is_success = 1;
            return is_success;
        }
        json_result = idcard_result;
        curl_easy_cleanup(curl);
        is_success = 0;
    } else {
        fprintf(stderr, "curl_easy_init() failed.");
        is_success = 1;
    }
    return is_success;
}

#include <iostream>
#include <map>
#include <curl/curl.h>
#include <cryptopp/aes.h>
#include <cryptopp/filters.h>
#include "json/json.h"
#include "aip/base/base64.h"
#include "cryptopp/hex.h"
#include "openssl/aes.h"
#include <openssl/evp.h>
#include <fstream>

#define KEY_SIZE_16B            16
#define KEY_SIZE_24B            24
#define KEY_SIZE_32B            32

using CryptoPP::HexEncoder;
using CryptoPP::HexDecoder;

using CryptoPP::StringSource;

// libcurl库下载链接：https://curl.haxx.se/download.html
// jsoncpp库下载链接：https://github.com/open-source-parsers/jsoncpp/
//const static std::string request_url = "https://aip.baidubce.com/rest/2.0/ocr/v1/idcard";
//获取token
inline size_t onWriteData(void *buffer, size_t size, size_t nmemb, void *userp) {
    std::string *str = dynamic_cast<std::string *>((std::string *) userp);
    str->append((char *) buffer, size * nmemb);
    return nmemb;
}

int get_token(
        std::string ak,
        std::string sk,
        std::string *token) {
    CURL *curl = curl_easy_init();
    struct curl_slist *slist = NULL;
    std::map<std::string, std::string> params;
    std::string response;
    std::string error;
    params["grant_type"] = "client_credentials";
    params["client_id"] = ak;
    params["client_secret"] = sk;
    std::string url = "https://aip.baidubce.com/oauth/2.0/token?"
                      "grant_type=client_credentials&client_id=" + ak + "&client_secret=" + sk;
    curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, slist);
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, onWriteData);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
    curl_easy_setopt(curl, CURLOPT_NOSIGNAL, true);
    curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT_MS, 2000);
    curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS, 2000);
    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, false);
    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, false);
    curl_easy_setopt(curl, CURLOPT_VERBOSE, false);
    int status_code = curl_easy_perform(curl);
    curl_easy_cleanup(curl);
    curl_slist_free_all(slist);
    Json::CharReaderBuilder crbuilder;
    std::unique_ptr<Json::CharReader> reader(crbuilder.newCharReader());
    Json::Value obj;
    reader->parse(response.data(), response.data() + response.size(), &obj, &error);
    *token = obj["access_token"].asString();

    return status_code;
}


std::string JsonToString(const Json::Value &root) {
    static Json::Value def = []() {
        Json::Value def;
        Json::StreamWriterBuilder::setDefaults(&def);
        def["emitUTF8"] = true;
        return def;
    }();

    std::ostringstream stream;
    Json::StreamWriterBuilder stream_builder;
    stream_builder.settings_ = def;//Config emitUTF8
    std::unique_ptr<Json::StreamWriter> writer(stream_builder.newStreamWriter());
    writer->write(root, &stream);
    return stream.str();
}


int hex_char_value(char c) {
    if (c >= '0' && c <= '9')
        return c - '0';
    else if (c >= 'a' && c <= 'f')
        return (c - 'a' + 10);
    else if (c >= 'A' && c <= 'F')
        return (c - 'A' + 10);
    assert(0);
    return 0;
}

std::string get_key(std::string res) {
    std::string lvStr;
    for (int i = 0; i < 16; i++) {
        int x = hex_char_value(res[i]);
        char c = x;
        std::cout << c;
        lvStr.append(1, c);
    }
    return lvStr;
}

std::string ecb_encrypt(std::string res, std::string source) {
    int outlen = 0;
    int i = source.size() / 16;
    int tail = source.size() % 16;
    if (tail > 0) {
        i++;
    }
    unsigned char encData[16 * i];
    EVP_CIPHER_CTX *ctx;
    ctx = EVP_CIPHER_CTX_new();
    EVP_CipherInit_ex(ctx, EVP_aes_128_ecb(), NULL,
                      reinterpret_cast<const unsigned char *>(get_key(res).c_str()), NULL, 1);
    EVP_CipherUpdate(ctx, encData, &outlen, reinterpret_cast<const unsigned char *>(source.c_str()), source.size());
    EVP_CipherFinal(ctx, encData + outlen, &outlen);
    EVP_CIPHER_CTX_free(ctx);
    std::string data = aip::base64_encode(reinterpret_cast<const char *>(encData), sizeof(encData));
    return data;
}

std::string ecb_decrypt(std::string res, std::string decode) {
    std::string data = aip::base64_decode(decode);
    int decLen = 0;
    int outlen = 0;
    unsigned char decData[data.size()];
    EVP_CIPHER_CTX *ctx2;
    ctx2 = EVP_CIPHER_CTX_new();
    EVP_CipherInit_ex(ctx2, EVP_aes_128_ecb(), NULL, reinterpret_cast<const unsigned char *>(get_key(res).c_str()),
                      NULL, 0);
    EVP_CipherUpdate(ctx2, decData, &outlen, reinterpret_cast<const unsigned char *>(data.c_str()), data.size());
    decLen = outlen;
    EVP_CipherFinal(ctx2, decData + outlen, &outlen);
    decLen += outlen;
    EVP_CIPHER_CTX_free(ctx2);
    decData[decLen] = '\0';
    printf("decrypt: %s\n", decData);
    std::string result;
    result = reinterpret_cast<const char *>(decData);
    return result;
}

template<class CharT, class Traits, class Allocator>
std::basic_istream<CharT, Traits> &getall(std::basic_istream<CharT, Traits> &input,
                                          std::basic_string<CharT, Traits, Allocator> &str) {
    std::ostringstream oss;
    oss << input.rdbuf();
    str.assign(oss.str());
    return input;
}

inline int get_file_content(const char *filename, std::string *out) {
    std::ifstream in(filename, std::ios::in | std::ios::binary);
    if (in) {
        getall(in, *out);
        return 0;
    } else {
        return -1;
    }
}

/**
 * 身份证识别
 * @return 调用成功返回0，发生错误返回其他错误码
 */
Json::Value idcard(const std::string &access_token) {
    Json::Value obj;
    std::string url = "https://aip.baidubce.com/rest/2.0/ocr/v1/idcard?access_token=" + access_token;
    CURL *curl = NULL;
    CURLcode result_code;
    //图片内容
    std::string file_content;
    get_file_content("/Users/lidang/pyproject/baidu/aip/api-python-sdk/test/resources/my.jpg", &file_content);
//    std::string base64 = aip::base64_encode(file_content.c_str(), (int) file_content.size());
    std::string res = "e1ad10e3d69689e0";
    std::string base64 = ecb_encrypt(res, file_content);
    int is_success;
    std::string response;
    std::string error;
    curl = curl_easy_init();
    if (curl) {
        curl_easy_setopt(curl, CURLOPT_URL, url.data());
        curl_easy_setopt(curl, CURLOPT_POST, 1);
        curl_httppost *post = NULL;
        curl_httppost *last = NULL;
        curl_formadd(&post, &last, CURLFORM_COPYNAME, "id_card_side", CURLFORM_COPYCONTENTS, "front", CURLFORM_END);
        curl_formadd(&post, &last, CURLFORM_COPYNAME, "image", CURLFORM_COPYCONTENTS, base64.c_str(), CURLFORM_END);
        curl_formadd(&post, &last, CURLFORM_COPYNAME, "AESEncry", CURLFORM_COPYCONTENTS, "true", CURLFORM_END);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
        curl_easy_setopt(curl, CURLOPT_HTTPPOST, post);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, onWriteData);
        result_code = curl_easy_perform(curl);
        if (result_code != CURLE_OK) {
            fprintf(stderr, "curl_easy_perform() failed: %s\n",
                    curl_easy_strerror(result_code));
            is_success = 1;
            return is_success;
        }
        Json::CharReaderBuilder crbuilder;
        std::unique_ptr<Json::CharReader> reader(crbuilder.newCharReader());
        reader->parse(response.data(), response.data() + response.size(), &obj, &error);
        curl_easy_cleanup(curl);
        is_success = 0;
        return obj;
    } else {
        fprintf(stderr, "curl_easy_init() failed.");
        is_success = 1;
    }
    return obj;
}

int main() {

//    aipt::test_ocr();
//    aipt::test_kg();
//    aipt::test_speech();
//    aipt::test_face();
//    aipt::test_nlp();
//    aipt::test_ocr();
//    aipt::test_image_censor();
//    aipt::run_test(1);
    std::string ak = "ak";
    std::string sk = "sk";
    std::string res = "控制台的aeskey";
    std::string output;
    std::string token;
    get_token(ak, sk, &token);
    Json::Value result;
    result = idcard(token);
    std::cout << result["result"];
    std::string data = ecb_decrypt(res, result["result"].asString());
    std::cout << data + "\n";
//    std::string encate = ecb_encrypt(res, "123456789123456789");
//    std::cout << encate + "\n";
//    std::string decode = ecb_decrypt(res,encate);
//    std::cout << decode+"\n";
    return 0;
}