加解密 签名

最新推荐文章于 2024-01-21 18:08:33 发布
最新推荐文章于 2024-01-21 18:08:33 发布
阅读量286 收藏
点赞数
分类专栏： 算法 数据结构 加密
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011244446/article/details/51841990
版权


string NS_PUB_API::DesEncode(const string encodeSrc,const string encodeKey){


try{
        //3des加密
        string stData = TC_Des::encrypt3(encodeKey.c_str(),encodeSrc.c_str(), encodeSrc.size());
//base64编码
string stRet;
Base64::Encode(stData,stRet);
        return stRet;
    } catch(TC_DES_Exception &ex){
    ELOG("desEncode error.....!!!");
        return "";
    }


}


bool NS_PUB_API::DesDecode(const string decodeSrc,const string decodeKey,string &outResult){


try{
string base64Str;
//base64解码
Base64::Decode(decodeSrc,base64Str);
        //3des解密
        outResult = TC_Des::decrypt3(decodeKey.c_str(), base64Str.c_str(), base64Str.size());
        return true;
    }catch(TC_DES_Exception &ex)
    {
ELOG("catch TC_DES_Exception"); 
        return false;
    }catch(exception &ex)
{
ELOG("catch exception[%s]", ex.what()); 
return false;
}catch(...)
{
ELOG("catch NotTC_DES_Exception"); 
return false;
}
}
bool NS_PUB_API::checkSign(map_s2s mapin,string appid,string md5Key){
//暂不校验签名
return true;

string md5_whole_key = md5Key+appid;
string md5_src = get_md5_src(mapin,md5_whole_key);
string sign=MD5::sum(md5_src);
DLOG("check sigin  md5_key=[%s],md5_src=[%s]  sign=[%s]",md5_whole_key.c_str(),md5_src.c_str(),sign.c_str());


if (strcasecmp(sign.c_str(), mapin["sign"].c_str()) != 0){
_throw_m(NS_PUB_DEF::ERROR_CHECK_SIGN, "check sign err");
}


return true;
}
string NS_PUB_API::get_md5_src(map_s2s &map_in, const string &key)
{
map<string, string>::key_compare kcomp = map_in.key_comp();
map<string, string>::const_iterator iter = map_in.begin();


string md5_src = "";


do {
/* 如果值为空或者是参数名为sign，则跳过 */
if (!iter->second.empty() && "sign" != iter->first ) {
md5_src += iter->first + "=" + iter->second + "&";
}
} while (kcomp((*iter++).first, map_in.rbegin()->first));


md5_src += string("key=") + key;


return md5_src;

}





///.h头文件

//vi: set tabstop=4 shiftwidth=4 expandtab:
#ifndef _PUB_BASE64_H__
#define _PUB_BASE64_H__


#include <string>
using std::string;
//------------------------------------------------------------------------------
class Base64 
{
public:
    //标准base64算法（非RFC822，即不会在每76字符后添加回车换行）
    static bool Encode(const string &src, string &dst);
    static bool Encode(const char* src, const size_t len, string &dst);
    static bool Decode(const char* src, const size_t len, string &dst);
    static bool Decode(const string &src, string &dst);


    //为方便http传输将标准base64中的 +/= 分别转义为-_=
    //@note 财付通middle中常用此算法
    static bool WebSafeEncode(const string &src, string &dst);
    static bool WebSafeEncode(const char* src, const size_t len, string &dst);
    static bool WebSafeDecode(const char* src, const size_t len, string &dst);
    static bool WebSafeDecode(const string &src, string &dst);


    //用于cookie编码编码 +/= 分别转义为-_.
    static bool CookieEncode(const string &src, string &dst);
    static bool CookieEncode(const char* src, const size_t len, string &dst);
    static bool CookieDecode(const char* src, const size_t len, string &dst);
    static bool CookieDecode(const string &src, string &dst);
private:
    Base64();
    Base64(const Base64 &);
    Base64 & operator= (const Base64 &);
};
//------------------------------------------------------------------------------
#endif


///base 64 .cpp

#include "pub_base64.h"


//------------------------------------------------------------------------------
#define XX 127


//Table for decoding standard base64
// if (ch >= 'A' && ch <= 'Z')  return ch - 'A';
// if (ch >= 'a' && ch <= 'z')  return ch - 'a' + 26;
// if (ch >= '0' && ch <= '9')  return ch - '0' + 52;
// if (ch == '+') return 62;
// if (ch == '/') return 63;
static const unsigned char index_64[256] = {
    XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
    XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
    XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,62, XX,XX,XX,63,
    52,53,54,55, 56,57,58,59, 60,61,XX,XX, XX,XX,XX,XX,
    XX, 0, 1, 2,  3, 4, 5, 6,  7, 8, 9,10, 11,12,13,14,
    15,16,17,18, 19,20,21,22, 23,24,25,XX, XX,XX,XX,XX,
    XX,26,27,28, 29,30,31,32, 33,34,35,36, 37,38,39,40,
    41,42,43,44, 45,46,47,48, 49,50,51,XX, XX,XX,XX,XX,
    XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
    XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
    XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
    XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
    XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
    XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
    XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
    XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX
};
#define CHAR64(c)  (index_64[(unsigned char)(c)])


//Table for decoding websafe base64
// if (ch >= 'A' && ch <= 'Z')  return ch - 'A';
// if (ch >= 'a' && ch <= 'z')  return ch - 'a' + 26;
// if (ch >= '0' && ch <= '9')  return ch - '0' + 52;
// if (ch == '-') return 62;
// if (ch == '_') return 63;
static const unsigned char websafe_index_64[256] = {
    XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
    XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
    XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,62,XX,XX,
    52,53,54,55, 56,57,58,59, 60,61,XX,XX, XX,XX,XX,XX,
    XX, 0, 1, 2,  3, 4, 5, 6,  7, 8, 9,10, 11,12,13,14,
    15,16,17,18, 19,20,21,22, 23,24,25,XX, XX,XX,XX,63,
    XX,26,27,28, 29,30,31,32, 33,34,35,36, 37,38,39,40,
    41,42,43,44, 45,46,47,48, 49,50,51,XX, XX,XX,XX,XX,
    XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
    XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
    XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
    XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
    XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
    XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
    XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX,
    XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX, XX,XX,XX,XX
};
#define WEBCHAR64(c)  (websafe_index_64[(unsigned char)(c)])


static const char base64_char[64] =
{
'A','B','C','D',  'E','F','G','H',
'I','J','K','L',  'M','N','O','P',
'Q','R','S','T',  'U','V','W','X',
'Y','Z','a','b',  'c','d','e','f',
'g','h','i','j',  'k','l','m','n',
'o','p','q','r',  's','t','u','v',
'w','x','y','z',  '0','1','2','3',
'4','5','6','7',  '8','9','+','/'
};


static const char websafe_base64_char[64] =
{
'A','B','C','D',  'E','F','G','H',
'I','J','K','L',  'M','N','O','P',
'Q','R','S','T',  'U','V','W','X',
'Y','Z','a','b',  'c','d','e','f',
'g','h','i','j',  'k','l','m','n',
'o','p','q','r',  's','t','u','v',
'w','x','y','z',  '0','1','2','3',
'4','5','6','7',  '8','9','-','_'
};
//------------------------------------------------------------------------------
bool Base64::Encode(const string &src, string &dst)
{
    return Base64::Encode(src.data(), src.size(), dst);
}


//------------------------------------------------------------------------------
bool Base64::Encode(const char* src, const size_t len, string &dst)
{
    if (src == NULL) return false;
    const size_t grp = (len + 2) / 3;
    const char pad = '=';
    for (size_t i = 0; i < grp; ++i)
    {
        const unsigned char *input = (unsigned char*)src + i * 3;
        size_t glen = 3;
        if (i == grp - 1) glen = len - i * 3;


        if (glen == 3)
        {
            dst.push_back(base64_char[input[0]>>2]);
            dst.push_back(base64_char[((input[0]&0x03)<<4) + (input[1]>>4)]);
            dst.push_back(base64_char[((input[1]&0x0f)<<2) + (input[2]>>6)]);
            dst.push_back(base64_char[input[2]&0x3f]);
        }
        else if (glen == 2)
        {
            dst.push_back(base64_char[input[0]>>2]);
            dst.push_back(base64_char[((input[0]&0x03)<<4) + (input[1]>>4)]);
            dst.push_back(base64_char[((input[1]&0x0f)<<2)]);
            dst.push_back(pad);
        }
        else if (glen == 1)
        {
            dst.push_back(base64_char[input[0]>>2]);
            dst.push_back(base64_char[((input[0]&0x03)<<4)]);
            dst.push_back(pad);
            dst.push_back(pad);
        }
    }


    return true;
}


//------------------------------------------------------------------------------
bool Base64::Decode(const string &src, string &dst)
{
    return Base64::Decode(src.data(), src.size(), dst);
}


//------------------------------------------------------------------------------
bool Base64::Decode(const char* src, const size_t len, string &dst)
{
    if (src == NULL) return false;
    if ((len % 4) != 0) return false; //must be 4-bytes align.


    const char pad = '=';
    for (size_t i = 0; i < len; i += 4)
    {
        const unsigned char *input = (unsigned char *)src + i;


        size_t cnt = 0;
        unsigned char output[4] = {0};
        if (input[2] == pad && input[3] == pad)
        {
            output[0] = CHAR64(input[0])<<2;
            output[0] |= CHAR64(input[1])>>4;
            cnt = 1;
        }
        else if (input[3] == pad)
        {
            output[0] = CHAR64(input[0])<<2;
            output[0] |= CHAR64(input[1])>>4;
            output[1] = CHAR64(input[1])<<4;
            output[1] |= CHAR64(input[2])>>2;
            cnt = 2;
        }
        else
        {
            output[0] = CHAR64(input[0])<<2;
            output[0] |= CHAR64(input[1])>>4;
            output[1] = CHAR64(input[1])<<4;
            output[1] |= CHAR64(input[2])>>2;
            output[2] = CHAR64(input[2])<<6;
            output[2] |= CHAR64(input[3]);
            cnt = 3;
        }
        dst.append((char*)output, cnt);
    }


    return true;
}


//------------------------------------------------------------------------------
bool Base64::WebSafeEncode(const string &src, string &dst)
{
    return Base64::WebSafeEncode(src.data(), src.size(), dst);
}


//------------------------------------------------------------------------------
bool Base64::WebSafeEncode(const char* src, const size_t len, string &dst)
{
    if (src == NULL) return false;
    const size_t grp = (len + 2) / 3;
    const char pad = '=';
    for (size_t i = 0; i < grp; ++i)
    {
        const unsigned char *input = (unsigned char*)src + i * 3;
        size_t glen = 3;
        if (i == grp - 1) glen = len - i * 3;


        if (glen == 3)
        {
            dst.push_back(websafe_base64_char[input[0]>>2]);
            dst.push_back(websafe_base64_char[((input[0]&0x03)<<4) + (input[1]>>4)]);
            dst.push_back(websafe_base64_char[((input[1]&0x0f)<<2) + (input[2]>>6)]);
            dst.push_back(websafe_base64_char[input[2]&0x3f]);
        }
        else if (glen == 2)
        {
            dst.push_back(websafe_base64_char[input[0]>>2]);
            dst.push_back(websafe_base64_char[((input[0]&0x03)<<4) + (input[1]>>4)]);
            dst.push_back(websafe_base64_char[((input[1]&0x0f)<<2)]);
            dst.push_back(pad);
        }
        else if (glen == 1)
        {
            dst.push_back(websafe_base64_char[input[0]>>2]);
            dst.push_back(websafe_base64_char[((input[0]&0x03)<<4)]);
            dst.push_back(pad);
            dst.push_back(pad);
        }
    }


    return true;
}


//------------------------------------------------------------------------------
bool Base64::WebSafeDecode(const string &src, string &dst)
{
    return Base64::WebSafeDecode(src.data(), src.size(), dst);
}


//------------------------------------------------------------------------------
bool Base64::WebSafeDecode(const char* src, const size_t len, string &dst)
{
    if (src == NULL) return false;
    if ((len % 4) != 0) return false; //must be 4-bytes align.


    const char pad = '=';
    for (size_t i = 0; i < len; i += 4)
    {
        const unsigned char *input = (unsigned char *)src + i;


        size_t cnt = 0;
        unsigned char output[4] = {0};
        if (input[2] == pad && input[3] == pad)
        {
            output[0] = WEBCHAR64(input[0])<<2;
            output[0] |= WEBCHAR64(input[1])>>4;
            cnt = 1;
        }
        else if (input[3] == pad)
        {
            output[0] = WEBCHAR64(input[0])<<2;
            output[0] |= WEBCHAR64(input[1])>>4;
            output[1] = WEBCHAR64(input[1])<<4;
            output[1] |= WEBCHAR64(input[2])>>2;
            cnt = 2;
        }
        else
        {
            output[0] = WEBCHAR64(input[0])<<2;
            output[0] |= WEBCHAR64(input[1])>>4;
            output[1] = WEBCHAR64(input[1])<<4;
            output[1] |= WEBCHAR64(input[2])>>2;
            output[2] = WEBCHAR64(input[2])<<6;
            output[2] |= WEBCHAR64(input[3]);
            cnt = 3;
        }
        dst.append((char*)output, cnt);
    }


    return true;
}


//------------------------------------------------------------------------------
bool Base64::CookieEncode(const string &src, string &dst)
{
    return Base64::CookieEncode(src.data(), src.size(), dst);
}


//------------------------------------------------------------------------------
bool Base64::CookieEncode(const char* src, const size_t len, string &dst)
{
    if (src == NULL) return false;
    const size_t grp = (len + 2) / 3;
    const char pad = '.';
    for (size_t i = 0; i < grp; ++i)
    {
        const unsigned char *input = (unsigned char*)src + i * 3;
        size_t glen = 3;
        if (i == grp - 1) glen = len - i * 3;


        if (glen == 3)
        {
            dst.push_back(websafe_base64_char[input[0]>>2]);
            dst.push_back(websafe_base64_char[((input[0]&0x03)<<4) + (input[1]>>4)]);
            dst.push_back(websafe_base64_char[((input[1]&0x0f)<<2) + (input[2]>>6)]);
            dst.push_back(websafe_base64_char[input[2]&0x3f]);
        }
        else if (glen == 2)
        {
            dst.push_back(websafe_base64_char[input[0]>>2]);
            dst.push_back(websafe_base64_char[((input[0]&0x03)<<4) + (input[1]>>4)]);
            dst.push_back(websafe_base64_char[((input[1]&0x0f)<<2)]);
            dst.push_back(pad);
        }
        else if (glen == 1)
        {
            dst.push_back(websafe_base64_char[input[0]>>2]);
            dst.push_back(websafe_base64_char[((input[0]&0x03)<<4)]);
            dst.push_back(pad);
            dst.push_back(pad);
        }
    }


    return true;
}


//------------------------------------------------------------------------------
bool Base64::CookieDecode(const string &src, string &dst)
{
    return Base64::CookieDecode(src.data(), src.size(), dst);
}


//------------------------------------------------------------------------------
bool Base64::CookieDecode(const char* src, const size_t len, string &dst)
{
    if (src == NULL) return false;
    if ((len % 4) != 0) return false; //must be 4-bytes align.


    const char pad = '.';
    for (size_t i = 0; i < len; i += 4)
    {
        const unsigned char *input = (unsigned char *)src + i;


        size_t cnt = 0;
        unsigned char output[4] = {0};
        if (input[2] == pad && input[3] == pad)
        {
            output[0] = WEBCHAR64(input[0])<<2;
            output[0] |= WEBCHAR64(input[1])>>4;
            cnt = 1;
        }
        else if (input[3] == pad)
        {
            output[0] = WEBCHAR64(input[0])<<2;
            output[0] |= WEBCHAR64(input[1])>>4;
            output[1] = WEBCHAR64(input[1])<<4;
            output[1] |= WEBCHAR64(input[2])>>2;
            cnt = 2;
        }
        else
        {
            output[0] = WEBCHAR64(input[0])<<2;
            output[0] |= WEBCHAR64(input[1])>>4;
            output[1] = WEBCHAR64(input[1])<<4;
            output[1] |= WEBCHAR64(input[2])>>2;
            output[2] = WEBCHAR64(input[2])<<6;
            output[2] |= WEBCHAR64(input[3]);
            cnt = 3;
        }
        dst.append((char*)output, cnt);
    }


    return true;
}

kmcfly
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
openssl 命令行国密sm2的加密解密签名验签操作
baron-周贺贺-代码改变世界ctw
07-31 2020
原始文件为in，签名为in.sign，使用sha256做摘要后使用SM2算法验签，输出验签结果。签名文件为in，使用sha256做摘要后使用SM2算法签名，输出文件为in.sign。
加密解签名验签
Young_____Hu的博客
06-12 275
图片展示加密解密签名验签过程
加密解密-签名验签学习笔记
霁风AI
11-09 2436
1.几个基本概念：加密:发送方利用接收方的公钥对要发送的明文进行加密。解密:接受方利用自己的私钥进行解密。公钥和私钥配对的，用公钥加密的文件，只有对应的私钥才能解密。当然也可以反过来，用私钥加密，用对应的公钥进行解密。签名：发送方用一个哈希函数从报文文本中生成报文摘要,然后用自己的私人密钥对这个摘要进行加密，得到的就是这个报文对应的数字签名。通常来说，发送方会把数字签名和报文原文一并发送给接受者。过
加解密与签名简介
季秀的博客
04-27 645
文章目录加密——公钥加密体系简介前言问题共享密钥——线上商量加密规则一个有趣的把戏使用数字玩颜料的把戏现实生活中数字的混合尝试破解钟大小和底数的选取原则结语“其他的公钥算法”——非对称加密公钥与私钥的产生加密消息解密消息生成公私钥对加密解密对称加密--DESMD5何时使用什么加密签名JWT致谢 加密——公钥加密体系简介 前言 加密的目的就是为了传输秘密。现实生活中，可以通过降低信息的传播范围来保证...
加解密签名验签数字信封解读
thetsunami的博客
01-30 1399
1. 什么是加解密 首先了解几个名词术语： 明文（plaintext）：未经过处理的数据； 密文（ciphertext）：明文经过密码转换而成的一种表现形式； 加密（Encryption）：将明文转换为密文的过程； 解密（Decryption）：将密文恢复为明文的过程； 哈希算法：对任意一组输入数据进行计算得到一个输出；用于验证原始数据是否被篡改； 对称加密：加密密钥和解密密钥相同；又称为单钥密码，常用的如：DES SM4； 非对称加密：加密密钥和解密密钥不同，又称为双钥密码，常用：RSA SM2； 软件加
各类编码加解密签名验签在线工具
qq19970496的博客
04-01 1269
在线签名工具 http://www.metools.info/code/c82.html RSA签名/验签 在线编码 https://www.sojson.com/md5/ 添加链接描述 各类哈希计算 在线加密 http://tool.chacuo.net/cryptaes/ http://www.jsons.cn/urlencode/
Java - 深入理解加密解密和签名算法
小工匠
01-21 3278
在数字时代，我们的个人信息、交易记录、健康数据等敏感信息经常被存储、传输和处理。如果这些信息以明文形式存在，就像是在一个不设防的房间里放置贵重物品，任何能够访问这些数据的人都能轻易地查看和利用它们。加密技术就像是为这个房间加上了一把锁，只有拥有钥匙（即解密密钥）的人才能打开房间，查看里面的内容。这样，即使数据在传输或存储过程中被第三方截获，他们也无法直接读取其中的信息，从而保护了数据的隐私性。
网络安全PGP加解密签名实验
在校大学生
12-20 1218
第八步 先签名（用自己的私钥）再加密（用合作方的公钥）文件，选第四个。第六步 数字签名（使用自己的私钥签名，合作方使用自己的公钥认证）选中对方发过来的加密文件，输入口令解密即可。第七步：对邮件进行数字签名。
加密解密、签名验签
骑个小蜗牛的博客
08-14 8459
1.加密解密 1.1什么是加密解密 加密∶在网络上传输的原始数据（明文）经过加密后形成（密文)传输，防止被窃取。 解密∶将密文还原成原始数据。 1.2加密方式分类 对称式加密:对加密和解密使用的是同一个密钥。 非对称式加密∶非对称式加密需要两个密钥（双钥），分别叫公钥和秘钥，这两把秘钥可以相互加解密。公钥公开的，不需要保密，而私钥是保密的。 1.3加密方式详解 对称加密技术 DES加密算法 AES加密算法 Base64加密算法 非对称加密技术( RSA加密算法) 场景1∶公钥加密，私钥.
加解密和签名验签简述
zijikanwa
05-01 2790
数字加密算法
php 非对称加密解密签名验签 类
07-09
几行代码就搞定 php 非对称加密解密签名验签 $stime=microtime(true); #获取程序开始执行的时间 $ps=newRsa(); $str='我是谁，我在哪'; $crypt=$ps->privateEncrypt($str); echo $ps->publicDecrypt($crypt); $sign=...
CryptoAPI加解密签名验证
01-14
加解密功能 CryptoAPI支持多种加密算法，如RSA、AES、DES等。通过这个接口，开发者可以对数据进行加密，以保护敏感信息不被未经授权的用户访问。例如，RSA是一种非对称加密算法，它使用一对公钥和私钥，公钥用于...
Delphi RSA 加密解密签名验签控件 RSA_Component(1.0.0.0).rar
12-13
但是没有提供Delphi使用的RSA支持，delphi开发者使用起来还是有些麻烦，特别是RSA加解密及签名验证等等，因此我们开发了这个RSA控件，秩序简单的几个API就可以立即实现RSA的加解密及签名验证等功能。
Android RSA加解密签名
06-19
综上所述，Android RSA加解密签名涉及了非对称加密、密钥生成、字符串和PEM文件的读取以及签名验证等多个环节。在实际应用中，开发者需要注意安全实践，如妥善保管私钥，避免密钥泄露。同时，理解并正确使用这些技术...
加密解密签名验签通用工具
12-17
SM2算法可以生成密钥和公钥，支持SM2的签名和验签；AES加密解密，支持各种常用的堆成非对称的加密算法的加密解密和验签
逆序链表
u011244446的专栏
02-16 293
linknode * reverserLinkNode(linkNode * rootNode){ linkNode * prev= NULL; linkNode * Next; while(rootNode != NULL){ Next = rootNode->next; rootNode->next=prev; prev=rootNode; rootNode = Next;
webgoat-server-8.2.2.zip
07-21
解压即可得到webgoat-server-8.2.2.jar
人工智能行业深度报告：WAIC2024，国产AI+应用“百花齐放”
最新发布
07-21
2024年世界人工智能大会（WAIC 2024）上，国产AI+应用生态呈现“百花齐放”的局面 1. WAIC 2024：国产 AI+应用生态“百花齐放” 多家厂商携大模型及AI应用成果亮相展会，涵盖金山办公、科大讯飞、华为、商汤等知名企业。 OpenAI 禁令加速推动国产 AI 生态，国产大模型性能持续提升，缩小与海外差距。 预计未来国产 AI+行业应用将迎来“百花齐放”局面，商业空间加速打开。 2. 国产大模型加速迭代，代表性厂商生态加速构建 科大讯飞 发布星火 V4.0 大模型，全面对标 GPT-4 Turbo，多模态能力显著提升。 星火医疗和教育垂类模型能力升级，赋能行业应用落地。 推出星火企业智能平台，赋能企业构建岗位专属助手。 华为 发布盘古大模型 5.0 系列，包括不同参数规模，适用于多种场景。 推出盘古具身智能大模型，推动人形机器人技术升级。 盘古 5.0 赋能华为小艺升级，在多个行业落地应用。 商汤 发布“日日新 5.5”模型，交互体验对标 GPT-4o，多模态能力实现突破。 推出面向 C 端用户的可控人物视频生成模型 Vimi。 率先实现原生多模态大模型车端部署
node SM2 加密解密 签名
01-10
对于node.js中的SM2加密解密和签名，可以使用`sm-crypto`库来实现。下面是一个示例代码： ```javascript const sm2 = require('sm-crypto').sm2; // 生成密钥对 const { publicKey, privateKey } = sm2....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值