【常见开源库的二次开发】基于openssl的加密与解密——Base的编解码(二进制转ascll)(二)

目录:

目录:

[一、 Base64概述和应用场景](#一、 Base64概述和应用场景)

[1.1 概述](#1.1 概述)

[1.2 应用场景](#1.2 应用场景)

二、Base16

[2.1 Base16编码](#2.1 Base16编码)

[2.2 Base16编解码](#2.2 Base16编解码)

三、Base64

[四、OpenSSL BIO接☐](#四、OpenSSL BIO接☐)

[4.1 Filter BIOs:](#4.1 Filter BIOs:)

[4.2 Source/Sink BIOs:](#4.2 Source/Sink BIOs:)

[4.3 应用场景:](#4.3 应用场景:)

[4.4 具体使用:](#4.4 具体使用:)

[4.5 进行BIO编码:](#4.5 进行BIO编码:)

4.6进行BIO解密:

1.Base64编码(Base64Encode函数)

[2. Base64解码(Base64Decode`函数)](#2. Base64解码(Base64Decode`函数))

[3. main函数](#3. main函数)


一、 Base64概述和应用场景

1.1 概述

Base64是一种编码方式,用于将二进制数据转换为ASCII字符串,以便在只支持文本的媒体上进行存储和传输。它不是一种加密算法,而是一种数据编码技术。Base64编码是一种简单而有效的数据编码方式,它允许二进制数据在文本环境中安全地传输和存储。尽管它不提供安全性(数据在传输过程中可以被读取),但它确保了数据的完整性和可移植性。

1.2 应用场景

邮件编码(base64)

xml或者json存储二进制内容

网页传递数据URL

数据库中以文本形式存放二进制数据

可打印的比特币钱包地址base58 Check(hash校验)

比特币地址bech32(base32)

二、Base16

2.1 Base16编码

Base16是一种编码方法,它使用16个可打印的ASCII字符来表示二进制数据。这些字符包括数字0到9和字母A到F。每个字符代表4个二进制位,因此Base16有时也称为十六进制编码。

在Base16编码过程中,首先将原始数据(如文本或文件)转换成二进制形式。对于ASCII编码字符,这一步直接涉及将每个字符转换为其对应的8位二进制值。对于UTF-8或其他编码,可能涉及更复杂的转换过程。

接下来,将得到的二进制串按照每4位一组进行切分。由于每组4位可以对应一个0到15之间的十进制数,这个数可以直接映射到上述提到的16个字符之一 。例如,二进制组0101对应十进制数5,按Base16编码转换成字符5;二进制组1001对应十进制数9,转换成字符9;二进制组1010对应十进制数10,转换成字符A,依此类推。

由于Base16使用4位二进制表示一个字符,一个字节(8位)被编码为两个Base16字符。因此,Base16编码后的数据大小是原始数据大小的两倍。

cpp 复制代码
#include  <iostream>

using  namespace  std;
//  定义一个静态的常量字符数组,用于Base16编码的字符映射表
static  const  char  BASE16_ENC_TAB[] = "123456789ABCDEF";

//  函数:将输入的原始数据按照Base16编码规则编码到输出字符串中
//  参数:in  -  指向原始数据的指针;size  -  原始数据的字节数;out  -  指向输出编码字符串的指针
//  返回值:编码后的字符串长度,即原始数据长度的两倍
int  Base16Encode(const  unsigned  char* in, int  size, char* out)
{
    //  遍历原始数据的每个字节
    for (int i = 0; i < size; i++)
    {
        //  将当前字节的高四位右移四位,得到高四位的值
        char  h = in[i] >> 4;  //  例如:二进制1000  0001通过移位变为0000  1000
        //  将当前字节的低四位与0x0F进行与操作,得到低四位的值
        char  l = in[i] & 0x0F;  //  例如:二进制0000  1111与0x0F与操作后得到0000  0001
        //  根据高四位的值,在编码表中查找对应的字符,并存入输出字符串
        out[i * 2] = BASE16_ENC_TAB[h];  //  映射高四位到编码表对应的字符
        //  根据低四位的值,在编码表中查找对应的字符,并存入输出字符串
        out[i * 2 + 1] = BASE16_ENC_TAB[l];  //  映射低四位到编码表对应的字符
    }
    //  返回编码后的字符串长度,即原始数据长度的两倍
    return  size * 2;
}

int  main(int  argc, char* argv[])
{
    cout << "测试Base16编码" << endl;
    //  定义待编码的原始数据
    const  unsigned  char  data[] = "测试base16";
    //  获取原始数据的字节长度
    int  len = sizeof(data) - 1;  //  减1是因为sizeof包含了结尾的'\0'字符
    //  定义足够大的输出数组来存放编码后的字符串
    char  out1[1024] = { 0 };
    //  打印原始数据
    cout << "原始数据:  " << data << endl;
    //  调用Base16编码函数
    int  re = Base16Encode(data, len, out1);
    //  打印编码后的字符串及其长度
    cout << "编码后长度:  " << re << ",  编码结果:  " << out1 << endl;
    return  0;
}

(1) 定义了一个静态常量字符数组`BASE16_ENC_TAB`,包含了Base16编码所需的字符('0'-'9'和'A'-'F')。

**(2)Base16Encode`函数接收三个参数:**指向原始数据的指针`in`,原始数据的字节数`size`,以及指向输出编码字符串的指针`out`。

**(3) 在`Base16Encode`函数中,使用一个循环遍历输入数据的每个字节。**对于每个字节,进行以下操作:

将字节的高四位右移四位,得到一个0到15之间的值,这个值对应于该字节的高四位。

将字节与0x0F进行位与操作,得到一个0到15之间的值,这个值对应于该字节的低四位。

使用这两个值作为索引,在`BASE16_ENC_TAB`数组中查找对应的字符,并将这些字符分别存储到输出字符串的相应位置。

(4)循环结束后,返回编码后的字符串长度,即原始数据长度的两倍。

**(5)在`main`函数中,定义了一个待编码的字符串`data`,计算其长度(不包括结尾的空字符'\0'),**并声明了一个足够大的字符数组`out1`来存储编码后的字符串。

(6)`main`函数打印出原始数据,调用`Base16Encode`函数进行编码,并打印出编码后的字符串及其长度。

代码定义了一个Base16Encode函数,用于将输入的原始数据按照Base16编码规则编码到输出字符串中 ,并在main函数中进行了测试。sizeof(data)包含了字符串结尾的空字符\0,所以在计算长度时应该减去1,否则会将空字符也进行编码。

2.2 Base16编解码

Base16(或称为十六进制)编码是一种将二进制数据转换为一种使用16个可打印字符(0-9和A-F)表示的方法。Base16编码的解码过程是将编码后的字符串转换回原始的二进制数。

实现了Base16编码和解码的功能。

cpp 复制代码
#include  <iostream>
//  引入iostream库,用于输入输出操作

using  namespace  std;
//  使用std命名空间,避免在代码中重复写std::前缀

//  定义一个静态的常量字符数组,用于Base16编码的字符映射表
static  const  char  BASE16_ENC_TAB[] = "0123456789ABCDEF";    //  包含16进制编码的字符,从0到F

static  const  char  BASE16_DEC_TAB[128] = {
      -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,    //  ASCII码0-15,非16进制字符映射为-1
      -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,    //  ASCII码16-31,非16进制字符映射为-1
      -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,    //  ASCII码32-47,非16进制字符映射为-1
       0,    1,    2,    3,    4,    5,    6,    7,    8,    9,  -1,  -1,  -1,  -1,  -1,  -1,    //  ASCII码48-57,对应0-9
      -1,  10,  11,  12,  13,  14,  15,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,    //  ASCII码65-70,对应A-F
      -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,    //  ASCII码71-76,非16进制字符映射为-1
      -1,  10,  11,  12,  13,  14,  15,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,    //  ASCII码91-96,对应a-f
      -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1     //  ASCII码97-102,非16进制字符映射为-1
};    //  正确填充解码表,非16进制字符映射为-1

//  函数:将输入的原始数据按照Base16编码规则编码到输出字符串中
int  Base16Encode(const  unsigned  char* in, int  size, char* out) {
    for (int i = 0; i < size; i++) {
        char  h = in[i] >> 4;            //  获取字节的高4位
        char  l = in[i] & 0x0F;          //  获取字节的低4位
        out[i * 2] = BASE16_ENC_TAB[h];    //  将高4位转换为对应的16进制字符
        out[i * 2 + 1] = BASE16_ENC_TAB[l];    //  将低4位转换为对应的16进制字符
    }
    return  size * 2;    //  返回编码后的长度,是输入长度的两倍
}

//  函数:将Base16编码的字符串解码回原始数据
int  Base16Decode(const  string& in, char* out) {
    for (int i = 0; i < in.size(); i += 2) {    //  以2个字符为一组进行解码
        unsigned  char  h = BASE16_DEC_TAB[static_cast<unsigned  char>(in[i])];    //  获取高4位
        unsigned  char  l = BASE16_DEC_TAB[static_cast<unsigned  char>(in[i + 1])];    //  获取低4位
        out[i / 2] = (h << 4) | l;    //  将高4位和低4位合并成原始字节
    }
    return  in.size() / 2;    //  返回解码后的长度,与输入长度相同
}

int main(int argc, char* argv[]) {
    cout << "测试Base16编码" << endl;
    const unsigned char data[] = "测试base16编码";
    int len = sizeof(data) - 1;
    char out1[1024] = { 0 };
    unsigned char out2[1024] = { 0 };

    cout << "原始数据: " << data << endl;
    int encodedLength = Base16Encode(data, len, out1);
    cout << "编码后长度: " << encodedLength << ", 编码结果: " << out1 << endl;

    int decodedLength = Base16Decode(out1, reinterpret_cast<char*>(out2));
    cout << "解码后长度: " << decodedLength << ", 解码结果: " << out2 << endl;

    return 0;
}

1. 字符映射表:

BASE16_ENC_TAB 是一个包含16进制编码字符的静态常量字符数组,从'0'到'F'

BASE16_DEC_TAB 是一个静态常量字符数组,用于将ASCII码转换为对应的16进制数值。数组中索引0-15对应ASCII码0-9和A-F,其他索引为-1,表示不是16进制字符。

2. Base16Encode函数:

接受三个参数:输入数据的指针in,输入数据的大小size,输出字符串的指针out。

循环遍历输入数据的每个字节,提取高4位和低4位。

使用高4位和低4位索引`BASE16_ENC_TAB`数组,获取对应的16进制字符。

将两个字符依次写入输出字符串的相应位置。

函数返回编码后的长度,即输入长度的两倍。

3. Base16Decode函数:

接受两个参数:Base16编码的字符串`in`和输出数据的指针out。

以两个字符为一组进行解码,因为Base16编码是将每个字节转换为两个字符。

使用输入字符串的每个字符索引BASE16_DEC_TAB数组,获取对应的16进制数值。

将高4位和低4位合并成一个字节,写入输出数据。

函数返回解码后的长度,即输入长度的一半。

4. main函数:

定义测试数据data,它是要编码和解码的字符串。

定义输出缓冲区out1用于存储编码后的字符串,以及`out2`用于存储解码后的数据。

打印原始数据。

调用Base16Encode函数编码数据,并打印编码后的长度和结果。

调用Base16Decode函数解码数据,并打印解码后的长度和结果。

通过定义字符映射表和实现编码和解码函数,实现了对字符串进行Base16编码和解码的功能。在`main`函数中,通过示例数据展示了如何使用这些函数。

三、Base64

**1. 分组处理:**Base64编码将每3个字节的二进制数据(24位)作为一组进行处理。

**2. 转换:**将这3个字节的24位分成4组,每组6位。每组的6位二进制数转换成对应的4位Base64字符。

**3. 补齐:**如果原始数据不是3的倍数,那么在最后可能会剩下1个或2个字节。为了将这些数据也能编码,Base64会在编码后的字符串末尾添加'='字符。如果剩余1个字节,就会添加一个'=';如果剩余2个字节,就会添加两个'='。

四、OpenSSL BIO接☐

penSSL BIO(Basic I/O)是OpenSSL库中用于抽象I/O操作的一个组件。BIO提供了多种接口来控制不同类型的I/O操作

4.1 Filter BIOs

这些BIOs用于在数据从一个BIO流向另一个BIO的过程中进行转换或过滤。

  • BIO_f_base64():用于Base64编码和解码。
  • BIO_f_cipher():用于加密和解密。
  • BIO_f_md5():用于MD5散列。
  • BIO_f_md4():用于MD4散列。
  • BIO_f_sha1():用于SHA-1散列。
  • BIO_f_sm3():用于SM3散列。
  • BIO_f_sign():用于签名。
  • BIO_f_verify():用于验证签名。
  • BIO_f_negotiate():用于TLS/SSL协商。
  • BIO_f_buffer():用于缓冲。

4.2 Source/Sink BIOs

这些BIOs是数据源或接收器

    • BIO_new(BIO_s_mem()):创建一个内存BIO,用于存储数据。
    • BIO_new(BIO_s_file()):创建一个文件BIO,用于文件读写。
    • BIO_new(BIO_s_socket()):创建一个套接字BIO,用于网络通信。
    • BIO_new(BIO_s_fd()):创建一个文件描述符BIO。
    • BIO_new(BIO_s_open()):创建一个用于打开文件的BIO。
    • BIO_new(BIO_s_mem()):创建一个内存BIO。
    • BIO_new(BIO_s_connect()):创建一个用于连接的BIO。
    • BIO_new(BIO_s_accept()):创建一个用于接受连接的BIO。

4.3 应用场景:

  • BIOs常用于构建复杂的I/O操作,如加密通信、数据转换等。
  • 在TLS/SSL通信中,BIOs用于封装底层的I/O操作,如读写数据。

4.4 具体使用:

  • BIO_new()用于创建一个新的BIO对象。
  • 数据源BIO,例如BIO_new(BIO_s_mem())创建一个内存BIO。
  • 过滤BIO,例如BIO_new(BIO_f_base64())创建一个Base64编码和解码的过滤BIO。
  • 创建BIO链,例如BIO_push(b64_bio, mem_bio)将Base64过滤BIO和内存BIO连接起来。
  • BIO_write():用于向BIO写入数据。当使用Base64过滤BIO时,数据会被编码。
  • BIO_read_ex():用于**从BIO读取数据。**当使用Base64过滤BIO时,数据会被解码。

4.5 进行BIO编码:

通过**使用OpenSSL的BIO链表和Base64编码过滤器,将输入数据编码为Base64格式,并将结果输出到控制台。**主要思路是利用OpenSSL库提供的功能,通过BIO链表处理编码过程,最后将编码后的数据存储并输出。

cpp 复制代码
#include  <iostream>
#include  <openssl/rand.h>
#include  <openssl/evp.h>
#include  <openssl/buffer.h>
#include  <cstring> 

using  namespace  std;

int  Base64Encode(const  unsigned  char*  in,  int  len,  char*  out_base64)
{
      if  (!in  ||  len  <=  0  ||  !out_base64)
          return  0;

      //  内存源
      auto  mem_bio  =  BIO_new(BIO_s_mem());
      if  (!mem_bio)  return  0;

      //  base64  filter
      auto  b64_bio  =  BIO_new(BIO_f_base64());

      if  (!b64_bio)
      {
          BIO_free(mem_bio);
          return  0;
      }

      //  形成BIO链表
      //  b64-mem
      BIO_push(b64_bio,  mem_bio);

      //  写入到base64  filter  进行编码,结果会传递到链表的下一个节点
      //  到mem中读取结果(从链表头部,代表了整个链表)
      int  re  =  BIO_write(b64_bio,  in,  len);
      if  (re  <  0)
      {
          //  清空整个链表节点
          BIO_free_all(b64_bio);
          return  0;
      }

      //  刷新缓存,写入链表的mem
      BIO_flush(b64_bio);

      int  outsize  =  0;

      //  从链表源内存读取
      BUF_MEM*  p_data  =  NULL;
      BIO_get_mem_ptr(b64_bio,  &p_data);
      if  (p_data)
      {
          //  确保输出数组足够大
          if  (p_data->length  <  len  *  4  /  3  +  1)
          {
              BIO_free_all(b64_bio);
              return  0;
          }
          memcpy(out_base64,  p_data->data,  p_data->length);
          outsize  =  p_data->length;
      }
      BIO_free_all(b64_bio);
      return  outsize;
}

int  main(int  argc,  char  *argv[])
{
      cout  <<  "The  openssl  BIO  base64!"  <<  endl;
      unsigned  char  data[]  =  "测试Base64数据";
      int  len  =  sizeof(data);
      char  out[len  *  4  /  3  +  1];  //  基于最大编码长度分配内存
      int  encoded_len  =  Base64Encode(data,  len,  out);
      if  (encoded_len  >  0)
      {
          out[encoded_len]  =  '\0';  //  确保字符串以null终止
          cout  <<  out  <<  endl;
      }
      getchar();
      return  0;
}

1. 包含必要的头文件:

<iostream>:用于输入输出流。

<openssl/evp.h>:用于加密和编码操作。

<openssl/buffer.h>:用于缓冲区操作。

<cstring>:用于字符串操作。

2. 命名空间声明:

使用`using namespace std;`使得`std`命名空间下的元素可以直接使用,无需前缀。

3. 定义Base64编码函数`Base64Encode:

函数接收三个参数:输入数据指针`in`,输入数据长度`len`,输出Base64编码数据指针out_base64。

进行参数有效性检查,如果输入无效,则返回0。

创建一个`BIO`(BASIC I/O)对象`mem_bio`,用于内存操作。

创建一个`BIO`对象`b64_bio`,用于Base64编码。

将`b64_bio`连接到`mem_bio`后面,形成BIO链表,以便将编码后的数据写入内存。

使用`BIO_write`将输入数据写入到`b64_bio`。

使用`BIO_flush`将缓存中的数据写入到内存中。

获取编码后的数据长度,并确保输出数组足够大。

将编码后的数据复制到输出数组中。

释放BIO资源,并返回编码后的数据长度。

4. 主函数main:

打印一个信息字符串。

定义一个要编码的字符数组`data`。

调用`Base64Encode`函数进行编码。

如果编码成功,将编码后的数据输出到控制台。

等待用户按键,然后退出程序。

4.6进行BIO解密:

使用了OpenSSL库中的BIO(块I/O)抽象,它提供了一种灵活的方式来处理不同类型的I/O操作,包括加密和编码操作 。通过将Base64编码和解码功能封装在BIO链表中。

cpp 复制代码
#include  <iostream>
#include  <openssl/rand.h>
#include  <openssl/evp.h>
#include  <openssl/buffer.h>
#include  <cstring>

using  namespace  std;

int  Base64Encode(const  unsigned  char* in, int  len, char* out_base64)
{
    if (!in || len <= 0 || !out_base64)
        return  0;

    //  内存源
    auto  mem_bio = BIO_new(BIO_s_mem());
    if (!mem_bio) 
	return  0;

    //  base64  filter
    auto  b64_bio = BIO_new(BIO_f_base64());

    if (!b64_bio)
    {
        BIO_free(mem_bio);
        return  0;
    }

    //  形成BIO链表
    //  b64-mem
    BIO_push(b64_bio, mem_bio);

    //  写入到base64  filter  进行编码,结果会传递到链表的下一个节点
    //  到mem中读取结果(从链表头部,代表了整个链表)
    //write为编码  3字节-》4字节,不足3字节补充0和=
    int  re = BIO_write(b64_bio, in, len);
    if (re < 0)
    {
        //  清空整个链表节点
        BIO_free_all(b64_bio);
        return  0;
    }

    //  刷新缓存,写入链表的mem
    BIO_flush(b64_bio);

    int  outsize = 0;

    //  从链表源内存读取
    BUF_MEM* p_data = NULL;
    BIO_get_mem_ptr(b64_bio, &p_data);
    if (p_data)
    {
        //  确保输出数组足够大
        if (p_data->length < len * 4 / 3 + 1)
        {
            BIO_free_all(b64_bio);
            return  0;
        }
        memcpy(out_base64, p_data->data, p_data->length);
        outsize = p_data->length;
    }
    BIO_free_all(b64_bio);
    return  outsize;
}
        

int  Base64Decode(const  char*  in,  int  len,  unsigned  char*  out_data)
{
      if  (!in  ||  len  <=  0  ||  !out_data)
          return  0;

      //  内存源:密文
      BIO*  mem_bio  =  BIO_new_mem_buf(in,  len);
      if  (!mem_bio)
          return  0;

      //  base64过滤器
      BIO*  b64_bio  =  BIO_new(BIO_f_base64());
      if  (!b64_bio)
      {
          BIO_free(mem_bio);
          return  0;
      }

      //  形成BIO链
      BIO_push(b64_bio,  mem_bio);

      //  读取  解码
      //  read为解码  4字节  ->  3字节
      size_t  size  =  0;
      BIO_read_ex(b64_bio,  out_data,  len,  &size);
      BIO_free_all(b64_bio);

      //  将解码后的字节转换为字符串
      string  decoded_string((char*)out_data,  size);

      //  打印解码后的字符串,以便于检查
      cout  <<  "Decoded  data:  "  <<  decoded_string  <<  endl;

      return  size;
}


int  main(int  argc,  char*  argv[])  {
      cout  <<  "The    openssl    BIO    base64!"  <<  endl;
      unsigned  char  data[]  =  "测试Base数据的结果";
      int  len  =  sizeof(data);
      char  out[len  *  4  /  3  +  1];      //  基于最大编码长度分配内存
      unsigned  char  out2[len  *  4  /  3  +  1];      //  声明变量out2

      int  encoded_len;

      cout << "source:  " << data << endl << endl;
      encoded_len  =  Base64Encode(data,  len,  out);
      cout << "encode:  ";
      if  (encoded_len  >  0)  {
          out[encoded_len]  =  '\0';      //  确保字符串以null终止
          cout  <<  out  <<  endl;
      }

      encoded_len  =  Base64Decode(out,  encoded_len,  out2);      //  使用编码后的长度
      cout  << endl << "Decoded  data:   ";
      cout  <<  (const  char*)out2  <<  endl;
      getchar();
      return  0;
}

实现了两个主要功能:Base64编码和Base64解码。

1.Base64编码(Base64Encode函数)

**(1). 输入验证:**首先检查输入参数是否有效,包括输入数据指针、长度和输出缓冲区指针。

(2). BIO链表初始化:

创建一个内存BIO(`BIO_s_mem`),用于临时存储编码数据。

创建一个Base64过滤器BIO(`BIO_f_base64`),用于执行Base64编码。

**(3). 形成BIO链表:**将Base64过滤器BIO插入到内存BIO的前面,形成链表。

**(4). 写入数据:**使用`BIO_write`函数将输入数据写入Base64过滤器BIO。

**(5). 刷新缓存:**使用`BIO_flush`函数刷新缓存,确保所有数据都被编码。

(6). 读取编码数据:

使用`BIO_get_mem_ptr`函数获取内存BIO中的数据。

检查输出缓冲区是否足够大以存储编码数据。

使用`memcpy`将编码数据复制到输出缓冲区。

**(7). 清理:**释放所有BIO资源。

2. Base64解码(Base64Decode`函数)

**(1). 输入验证:**同样检查输入参数是否有效。

(2). BIO链表初始化:

创建一个内存BIO,用于存储输入的Base64编码数据。

创建一个Base64过滤器BIO,用于执行Base64解码。

**(3). 形成BIO链表:**将Base64过滤器BIO插入到内存BIO的前面。

(4). 读取和解码数据:

使用`BIO_read_ex`函数从Base64过滤器BIO中读取和解码数据。

输出解码后的数据到用户提供的缓冲区。

**(5). 清理:**释放所有BIO资源。

3. main函数

(1). 打印欢迎信息。

(2). 编码数据:

调用`Base64Encode`函数进行编码。

输出编码后的Base64字符串。

(3). 解码数据:

调用`Base64Decode`函数进行解码。

输出解码后的原始数据。

(4). 等待用户输入,以便用户可以看到输出并手动关闭程序。

到此我们就算对Base64的编解码都实现其功能

相关推荐
ClkLog-开源埋点用户分析1 小时前
ClkLog企业版(CDP)预售开启,更有鸿蒙SDK前来助力
华为·开源·开源软件·harmonyos
funnyZpC4 小时前
quartz集群增强版🎉
java·分布式·开源·集群·定时任务
憧憬一下8 小时前
Pinctrl子系统中Pincontroller和client驱动程序的编写
arm开发·嵌入式·c/c++·linux驱动开发
蓝天居士8 小时前
ES8388 —— 带耳机放大器的低功耗立体声音频编解码器(4)
嵌入式·音频·es8388
vvw&10 小时前
如何使用Netdata部署高性能的服务器监控平台
linux·运维·服务器·docker·开源·服务器监控·netdata
田三番11 小时前
使用 vscode 简单配置 ESP32 连接 Wi-Fi 每日定时发送 HTTP 和 HTTPS 请求
单片机·物联网·http·https·嵌入式·esp32·sntp
启明智显15 小时前
AI笔筒操作说明及应用场景
人工智能·嵌入式硬件·嵌入式·ai大模型·启明智显·esp32-s3
Goboy17 小时前
0帧起步:3分钟打造个人博客,让技术成长与职业发展齐头并进
程序员·开源·操作系统