openssl3.2 - exp - 用base64后的字符串作为配置项的值

概述

今天解析自己封装的内存型的openssl 配置数据，发现openssl并不支持配置项的值为base64之后的直接字符串。

笔记

配置项的值长度有限制

配置项的值(字符串)的长度好像有512字节的限制，具体没实验。看源码能看出来。

bool CMyOsslConfig::updateConfig()
{
	bool b_rc = false;
	int i_rc = 0;
	long lineSn = 0;
	int len1 = 0;
	int len2 = 0;

	do {
		if ((NULL == m_pMyOsslMem) || (NULL == m_conf))
		{
			break;
		}

		// BIO_seek(m_bio, 0);
		// len1 = this->bio_get_length(m_bio);
		assert(NULL != m_pMyOsslMem->get_bio());
		i_rc = NCONF_load_bio(m_conf, m_pMyOsslMem->get_bio(), &lineSn); // !
		// len2 = this->bio_get_length(m_bio);
		// m_bio有东西有数据长度, 但是经过NCONF_load_bio()后, m_conf里面有东西了, 但是m_bio的东西没了
		// 所以, 经过NCONF_load_bio后(), 就得当m_bio是空的来处理.
		// 如果是向m_bio中写东西, 然后写配置.
		// 如果要更新m_bio中的配置内容, 就必须重新写.

		if (i_rc <= 0)
		{
			break;
		}

		b_rc = true;
	} while (false);

	return b_rc;
}

跟进NCONF_load_bio(), 可以看到openssl读一行开的缓冲区为512字节。

#define CONFBUFSIZE     512

虽然配置项的值一般没有那么长。不过如果要存一段很大的数据转成的base64值，那么就可能遇到问题。
解决的方法：自己做个多buffer的封装类(C++ - 多个buffer合并成一个buffer的管理类)，比较长的信息，自己来管理。配置项值比较短的值，用openssl配置函数来读取。

openssl的配置文件(可以自己封装为内存操作的函数)，并没有写入配置的API. 只有读取配置项的API.
如果需要用程序来写openssl的配置文件，可以自己封装一个。写入的格式和普通的ini格式一样(如果简单的用)。

配置项的值不能是base64之后的直接值，需要处理之后才行。

原因 ：base64之后的值，每隔64个字符，有一个’\n’, 没有了这个’\n’, 用openssl的unbase64就不会成功。
折中的方法 ：
在base64之后，写入配置项之前，处理一下，将’\n’去掉后，再写入openssl配置文件。
在读取配置项值之后(自己知道是base64的字符串)，再处理一下，每64个字符加一个‘\n’(如果不是整除64个字符，bas64的尾巴上也要加’\n’), 然后再调用openssl的unbase64的API, 就能执行成功。

openssl配置项的值并不是所有可见字符都可以

有’\n’不行，openssl读取时，是整行(以回车’\n’为结尾)读取的，导致opensslbase64之后的值被截断(如果base64之后的值长度>64)，导致unbase64不成功.

有’\'不行，e.g. 一个路径值(“d:\my_tmp\xx.dat”), 用openssl配置接口读取出来时，‘\’字符消失了, 变为了"d:my_tmpxx.dat"，这就乱套了。
如果正好有\d这样的字符，读出的配置项的值直接乱码了。

如果配置项的值中有上述字符，都要base64之后才能正常读取。

例子

将base64写入openssl配置文件（去掉’\n’后，再base64, 然后写入配置项的值）

	// 
	obj.add_config_section("PE");

	//
	ptszBuf = (TCHAR*)m_PeFileCheck.getFilePathName();
	// 需要base64,否则'\'都没了，还有乱码
	strTmp = strOpt.my_W2A(ptszBuf);
	base64.base64(true, (UCHAR*)strTmp.data(), (int)strTmp.size(), pOsslBufTmp, len_OsslBufTmp);
	// base64之后，每65个字符之后有一个\n, 不能移除,base64解码时,如果不是每64个字符后面带一个\n, 会unbase64失败
	strTmp = base64.remove_char_0a(pOsslBufTmp, len_OsslBufTmp);
	
	obj.add_config_item_after_section("getFilePathName", (const char*)strTmp.data());
	MY_OPENSSL_FREE(pOsslBufTmp);

用openssl配置文件的一方，先读出配置项的值，加上’\n’(每64个字符)， 再unbase64.

		pszKeyValue = _ossl_cfg.get_conf_item_value("PE", "getFilePathName");
		if (NULL == pszKeyValue)
		{
			break;
		}

		strTmp = base64.add_char_0a((UCHAR*)pszKeyValue, (int)strlen(pszKeyValue));
		b = base64.base64(false, (UCHAR*)strTmp.data(), (int)strTmp.size(), pOsslBufTmp, lenOsslBufTmp);
		if (!b)
		{
			break;
		}

现在用的base64的类

cipher_base64.h

//! \file cipher_base64.h

#ifndef __CIPHER_BASE64_H__
#define __CIPHER_BASE64_H__

class CBase64
{
public:
	CBase64();
	virtual ~CBase64();

	bool base64(bool isEncode, UCHAR* pucBufIn, int lenBufIn, UCHAR*& pucBufOut, int& lenBufOut);
	std::string remove_char_0a(UCHAR* pucBufIn, int lenBufIn);
	std::string add_char_0a(UCHAR* pucBufIn, int lenBufIn);
};

#endif // #ifndef __CIPHER_BASE64_H__

cipher_base64.cpp

//! \file cipher_base64.cpp

#include "pch.h"
#include "cipher_base64.h"

#include "openssl/bio.h"
#include "openssl/evp.h"

#include "memOpt/my_debug_new_define.h"

CBase64::CBase64()
{

}

CBase64::~CBase64()
{

}

std::string CBase64::remove_char_0a(UCHAR* pucBufIn, int lenBufIn)
{
	std::string str_rc;
	int i = 0;

	do {
		if ((NULL == pucBufIn) || (lenBufIn <= 0))
		{
			break;
		}

		for (i = 0; i < lenBufIn; i++)
		{
			if (pucBufIn[i] != '\n')
			{
				str_rc += pucBufIn[i];
			}
		}
	} while (false);

	return str_rc;
}

std::string CBase64::add_char_0a(UCHAR* pucBufIn, int lenBufIn)
{
	std::string str_rc;
	int cnt = 0;
	int i = 0;

	// openssl每一行(64个字符一行，最后一行除外)后面都有一个'\n', 才能正确解码
	do {
		if ((NULL == pucBufIn) || (lenBufIn <= 0))
		{
			break;
		}

		for (i = 0; i < lenBufIn; i++)
		{
			str_rc += pucBufIn[i];
			if (++cnt == 64)
			{
				cnt = 0;
				str_rc += '\n';
			}
		}
	} while (false);

	if (cnt > 0)
	{
		str_rc += '\n';
	}
	
	return str_rc;
}

bool CBase64::base64(bool isEncode, UCHAR* pucBufIn, int lenBufIn, UCHAR*& pucBufOut, int& lenBufOut)
{
	bool b_rc = false;
	BIO* bio_container = NULL;
	BIO* bio_to_base64 = NULL;

	BIO* bio_header = NULL; // BIO链头
	BIO* bio_tail = NULL; // BIO链尾

	BIO* bio_to_write = NULL; // 将数据写入的BIO指针
	BIO* bio_read_from = NULL; // 将数据读出的BIO指针

	size_t sz_wt = 0;
	size_t sz_rd = 0;
	int i_rc = 0;
	int len = 0;

	do {
		pucBufOut = NULL;
		lenBufOut = 0;
		if ((NULL == pucBufIn) || (lenBufIn <= 0))
		{
			break;
		}

		bio_container = BIO_new(BIO_s_mem());
		if (NULL == bio_container)
		{
			break;
		}

		bio_to_base64 = BIO_new(BIO_f_base64());
		if (NULL == bio_to_base64)
		{
			break;
		}

		bio_header = BIO_push(bio_to_base64, bio_container);
		bio_tail = bio_container;

		if (isEncode)
		{
			bio_to_write = bio_header;
			bio_read_from = bio_tail;
		}
		else {
			// ! base64解码时, 是从链尾写入, 从链头读取
			bio_to_write = bio_tail;
			bio_read_from = bio_header;
		}

		i_rc = BIO_write_ex(bio_to_write, pucBufIn, lenBufIn, &sz_wt);
		if ((1 != i_rc) || (lenBufIn != sz_wt))
		{
			break;
		}

		BIO_flush(bio_to_write); // 数据写完后, 必须对写入的BIO执行 BIO_flush.

		// 必须从bio_read_from读取处理完的数据长度, 才是处理之后的数据长度
		len = BIO_pending(bio_read_from); // 必须BIO_flush()之后, 才能读取到BIO内可以读出的数据长度. 否则读出的长度是0
		// 当解码时, 得到的处理完的长度还是没解码之前的长度, 不过不影响
		// 拿这个长度开buffer, 实际数据处理完的长度按照从bio_read_from()中累计出的数据长度为准

		// 将处理过的数据从bio_header中读出来
		pucBufOut = (UCHAR*)OPENSSL_malloc(len + 1); // 再多加1个字节的空间, 便于观察得到的可见字符串
		if (NULL == pucBufOut)
		{
			break;
		}

		pucBufOut[len] = '\0';

		do {
			// 不能从bio_header读取, 因为读取后, 还是原来的数据长度
			i_rc = BIO_read_ex(bio_read_from, pucBufOut + lenBufOut, len - lenBufOut, &sz_rd);
			if (i_rc <= 0)
			{
				// 多次读, 直到读空了, 不算错
				break;
			}

			lenBufOut += (int)sz_rd;
		} while (true);

		if (NULL != pucBufOut)
		{
			pucBufOut[lenBufOut] = 0x00;
		}

		b_rc = true;
	} while (false);

	if (NULL != bio_header)
	{
		BIO_free_all(bio_header);
		bio_header = NULL;
	}

	return b_rc;
}

现在用的openssl配置文件读写类

CMyOsslConfig.h

//! \file CMyOsslConfig.h

#ifndef __CMYOSSLCONFIG_H__
#define __CMYOSSLCONFIG_H__

#include <openssl/bio.h>
#include <openssl/conf.h> // for CONF
#include "CMyOsslMem.h"

class CMyOsslConfig
{
public:
	CMyOsslConfig();
	virtual ~CMyOsslConfig();

	bool init();
	void uninit();
	bool add_config_section(const char* pszIn);
	bool add_config_item_after_section(const char* pszItemName, const char* pszItemContent);
	bool append_to_bio(uint8_t* pBuf, int lenBuf);
	bool updateConfig();
	char* get_conf_item_value(const char* group, const char* name);

	CMyOsslMem* getMem() { return m_pMyOsslMem; }

private:
	CMyOsslMem* m_pMyOsslMem;
	CONF* m_conf;
};

#endif // #ifndef __CMYOSSLCONFIG_H__

CMyOsslConfig.cpp

//! \file CMyOsslConfig.cpp

#include "pch.h"

#include "CMyOsslConfig.h"
#include <string.h>
#include <openssl/err.h>
#include <cassert>
#include "CMyOsslMem.h"

#include "memOpt/my_debug_new_define.h"

CMyOsslConfig::CMyOsslConfig()
	:m_pMyOsslMem(NULL),
	m_conf(NULL)
{

}

CMyOsslConfig::~CMyOsslConfig()
{
	// 必须在程序退出前，主动调用uninit(), 否则在mem_unhook()时，就会报mem leak的错
}

void CMyOsslConfig::uninit()
{
	if (NULL != m_pMyOsslMem)
	{
		m_pMyOsslMem->uninit();
		delete m_pMyOsslMem;
		m_pMyOsslMem = NULL;
	}

	if (NULL != m_conf)
	{
		NCONF_free(m_conf);
		m_conf = NULL;
	}
}

bool CMyOsslConfig::init()
{
	bool b_rc = false;

	do {
		if (NULL == m_pMyOsslMem)
		{
			m_pMyOsslMem = new CMyOsslMem();
			assert(NULL != m_pMyOsslMem);
			if (NULL == m_pMyOsslMem)
			{
				break;
			}

			m_pMyOsslMem->init();
		}

		if (NULL == m_conf)
		{
			m_conf = NCONF_new_ex(OSSL_LIB_CTX_get0_global_default(), NULL);
			if (NULL == m_conf)
			{
				break;
			}
		}

		b_rc = true;
	} while (false);

	return b_rc;
}

bool CMyOsslConfig::add_config_section(const char* pszIn)
{
	bool b_rc = false;
	char szBuf[1024];
	int len = 0;

	do {
		if (NULL == pszIn)
		{
			break;
		}

		len = (int)strlen(pszIn);
		if (len > (sizeof(szBuf) - 0x10))
		{
			break;
		}

		sprintf(szBuf, "[ %s ]\n", pszIn);
		assert(NULL != m_pMyOsslMem);
		if (!m_pMyOsslMem->append_to_bio((uint8_t*)szBuf, (int)strlen(szBuf)))
		{
			break;
		}

		b_rc = true;
	} while (false);

	return b_rc;
}

bool CMyOsslConfig::add_config_item_after_section(const char* pszItemName, const char* pszItemContent)
{
	bool b_rc = false;
	char szBuf[1024];
	int len = 0;

	do {
		if ((NULL == pszItemName) || (NULL == pszItemContent))
		{
			break;
		}

		len = (int)(strlen(pszItemName) + strlen(pszItemContent));
		if (len > (sizeof(szBuf) - 0x10))
		{
			break;
		}

		sprintf(szBuf, "%s = %s\n", pszItemName, pszItemContent);

		if (NULL == m_pMyOsslMem)
		{
			break;
		}

		assert(NULL != m_pMyOsslMem);
		if (!m_pMyOsslMem->append_to_bio((uint8_t*)szBuf, (int)strlen(szBuf)))
		{
			break;
		}

		b_rc = true;
	} while (false);

	return b_rc;
}

bool CMyOsslConfig::append_to_bio(uint8_t* pBuf, int lenBuf)
{
	assert(NULL != m_pMyOsslMem);
	return m_pMyOsslMem->append_to_bio(pBuf, lenBuf);
}

bool CMyOsslConfig::updateConfig()
{
	bool b_rc = false;
	int i_rc = 0;
	long lineSn = 0;
	int len1 = 0;
	int len2 = 0;

	do {
		if ((NULL == m_pMyOsslMem) || (NULL == m_conf))
		{
			break;
		}

		// BIO_seek(m_bio, 0);
		// len1 = this->bio_get_length(m_bio);
		assert(NULL != m_pMyOsslMem->get_bio());
		i_rc = NCONF_load_bio(m_conf, m_pMyOsslMem->get_bio(), &lineSn);
		// len2 = this->bio_get_length(m_bio);
		// m_bio有东西有数据长度, 但是经过NCONF_load_bio()后, m_conf里面有东西了, 但是m_bio的东西没了
		// 所以, 经过NCONF_load_bio后(), 就得当m_bio是空的来处理.
		// 如果是向m_bio中写东西, 然后写配置.
		// 如果要更新m_bio中的配置内容, 就必须重新写.

		if (i_rc <= 0)
		{
			break;
		}

		b_rc = true;
	} while (false);

	return b_rc;
}

char* CMyOsslConfig::get_conf_item_value(const char* group, const char* name)
{
	char* res = NULL;
	
	int i_rc = 0;

	do {
		if (NULL == m_conf)
		{
			break;
		}

		res = NCONF_get_string(m_conf, group, name);
		if (NULL == res)
		{
			ERR_pop_to_mark();
		}
		else {
			ERR_clear_last_mark();
		}
	} while (false);

	return res;
}

CMyOsslMem.h

//! \file CMyOsslMem.h

#ifndef __C_MY_OSSL_MEM_H__
#define __C_MY_OSSL_MEM_H__

#include <openssl/bio.h>
#include <openssl/conf.h> // for CONF

class CMyOsslMem
{
public:
	CMyOsslMem();
	virtual ~CMyOsslMem();

	bool init();
	void uninit();

	BIO* get_bio();

	bool append_to_bio(uint8_t* pBuf, int lenBuf);
	bool bio_to_buf(BIO* bio, uint8_t*& pBuf, int& lenBuf); // 执行之后，东西还在. 需要调用者释放pBuf

	bool to_file(const TCHAR* psz_file_pathname); // for test only
	bool get_bio_buffer(uint8_t*& pBuf, int& lenBuf); // 需要自己释放(OPENSSL_free)

	size_t get_length();
	size_t bio_get_length(BIO* bio);

	unsigned char* get_bio_data_tail(); // only for test

private:
	BIO* m_bio;

	// only for test
	unsigned char* m_bio_data;
	int m_bio_len;
};

#endif // #ifndef __C_MY_OSSL_MEM_H__

CMyOsslMem.cpp

//! \file CMyOsslMem.cpp

#include "pch.h"

#include "CMyOsslMem.h"
#include <string.h>
#include <openssl/err.h>
#include <cassert>

#include "memOpt/my_debug_new_define.h"

CMyOsslMem::CMyOsslMem()
	:m_bio(NULL),
	m_bio_len(0),
	m_bio_data(NULL)
{

}

CMyOsslMem::~CMyOsslMem()
{
	// 必须在程序退出前，主动调用uninit(), 否则在mem_unhook()时，就会报mem leak的错
}

void CMyOsslMem::uninit()
{
	if (NULL != m_bio)
	{
		BIO_free(m_bio);
		m_bio = NULL;
	}
}

bool CMyOsslMem::init()
{
	bool b_rc = false;

	do {
		if (NULL == m_bio)
		{
			m_bio = BIO_new(BIO_s_mem());
			if (NULL == m_bio)
			{
				assert(false);
				break;
			}
		}

		b_rc = true;
	} while (false);

	return b_rc;
}

bool CMyOsslMem::append_to_bio(uint8_t* pBuf, int lenBuf)
{
	bool b_rc = false;
	int len = 0;
	size_t szLen = 0;
	int bio_len_before = 0;
	int bio_len_after = 0;

	unsigned char* pDebug = NULL;
	int lenDebug = 0;

	do {
		if ((NULL == pBuf) || (lenBuf <= 0))
		{
			break;
		}

		if (NULL == m_bio)
		{
			assert(false);
			break;
		}

		// szLen = bio_get_length(m_bio);
		// BIO_seek(m_bio, szLen);
		bio_len_before = (int)bio_get_length(m_bio);
		len = BIO_write(m_bio, pBuf, lenBuf);
		bio_len_after = (int)bio_get_length(m_bio);
		if (len != lenBuf)
		{
			break;
		}

		if (len != (bio_len_after - bio_len_before))
		{
			break;
		}

		b_rc = true;
	} while (false);

	return b_rc;

}

BIO* CMyOsslMem::get_bio()
{
	if (NULL != m_bio)
	{
		// BIO_seek(m_bio, 0);
	}

	return m_bio;
}

size_t CMyOsslMem::get_length()
{
	return bio_get_length(this->get_bio());
}

size_t CMyOsslMem::bio_get_length(BIO* bio)
{
	size_t bio_length = 0;

	do {
		if (NULL == bio)
		{
			break;
		}

		// BIO_seek(bio, 0);
		bio_length = BIO_ctrl_pending(bio);
	} while (false);

	return bio_length;
}

unsigned char* CMyOsslMem::get_bio_data_tail()
{
	unsigned char* p_rc = NULL;

	do {
		if (NULL == m_bio)
		{
			assert(false);
			break;
		}

		// 取出的指针是bio内部的buffer地址，不用释放
		m_bio_len = BIO_get_mem_data(m_bio, &m_bio_data);
		p_rc = m_bio_data + m_bio_len;
	} while (false);

	return p_rc;
}

bool CMyOsslMem::to_file(const TCHAR* psz_file_pathname)
{
	bool b_rc = false;
	FILE* pf = NULL;
	uint8_t* pBuf = NULL;
	int len = 0;
	size_t sz_rc = 0;

	do {
		if (NULL == psz_file_pathname)
		{
			break;
		}

		pf = _tfopen(psz_file_pathname, TEXT("w+b"));
		if (NULL == pf)
		{
			break;
		}

		if (!get_bio_buffer(pBuf, len))
		{
			break;
		}

		if ((NULL == pBuf) || (len <= 0))
		{
			break;
		}

		sz_rc = fwrite(pBuf, sizeof(char), len, pf);
		assert(sz_rc == len);

		b_rc = true;
	} while (false);

	if (NULL != pf)
	{
		fclose(pf);
		pf = NULL;
	}
	
	if (NULL != pBuf)
	{
		OPENSSL_free(pBuf);
		pBuf = NULL;
	}

	return b_rc;
}

bool CMyOsslMem::get_bio_buffer(uint8_t*& pBuf, int& lenBuf)
{
	bool b_rc = false;

	do {
		if (!bio_to_buf(get_bio(), pBuf, lenBuf))
		{
			break;
		}

		if ((NULL == pBuf) || (lenBuf <= 0))
		{
			break;
		}

		b_rc = true;
	} while (false);

	return b_rc;
}

bool CMyOsslMem::bio_to_buf(BIO* bio, uint8_t*& pBuf, int& lenBuf)
{
	bool b_rc = false;
	int i_rc = 0;

	do {
		if (NULL == bio)
		{
			break;
		}

		lenBuf = (int)bio_get_length(bio);
		pBuf = (uint8_t*)OPENSSL_malloc(lenBuf + 1);
		if (NULL == pBuf)
		{
			break;
		}

		pBuf[lenBuf] = '\0';
		i_rc = BIO_read(bio, pBuf, lenBuf);
		BIO_seek(bio, 0); // ! 读完了, 将数据读指针恢复.

		b_rc = (i_rc == lenBuf);
	} while (false);

	return b_rc;
}

END