身份证识别 -奇异果体育app竞彩官网下载

#include 
#include 
// 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 
#include 
#include 
#include 
#include 
#include "json/json.h"
#include "aip/base/base64.h"
#include "cryptopp/hex.h"
#include "openssl/aes.h"
#include 
#include 
#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;
}