From b20ac2a4a8cf774ac9d9791445db35c3cb08ea23 Mon Sep 17 00:00:00 2001 From: xx Date: Fri, 14 Jun 2024 17:44:36 +0800 Subject: [PATCH] =?UTF-8?q?=E4=BC=98=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- CMakeLists.txt | 6 +- include/base/define.h | 3 + include/util/md5.h | 53 +++++++ include/util/sqlite3.h | 4 +- src/CMakeLists.txt | 4 - src/util/codec.cpp | 28 +--- src/util/md5.cpp | 346 +++++++++++++++++++++++++++++++++++++++++ src/util/sharedmem.cpp | 2 +- src/util/sqlite3.cpp | 16 +- 9 files changed, 423 insertions(+), 39 deletions(-) create mode 100644 include/util/md5.h create mode 100644 src/util/md5.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 4a61119..c87316a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -29,7 +29,7 @@ endif() include_directories(${PROJECT_SOURCE_DIR}/include) include_directories(${PROJECT_SOURCE_DIR}/3rdparty) if(MSVC) - include_directories(${PROJECT_SOURCE_DIR}/3rdparty/openssl/include) + else() include_directories(/usr/local/include) endif() @@ -55,10 +55,12 @@ endif() add_subdirectory(src) ######################## 三方库 ######################## if(MSVC) - add_subdirectory(3rdparty/zlib) + add_subdirectory(3rdparty/zlib) add_subdirectory(3rdparty/sqlite3) add_subdirectory(3rdparty/libzip) add_subdirectory(3rdparty/leveldb) +else() + add_subdirectory(3rdparty/sqlite3) endif() diff --git a/include/base/define.h b/include/base/define.h index 13624ed..cfe3e61 100644 --- a/include/base/define.h +++ b/include/base/define.h @@ -8,6 +8,9 @@ // 是否DEBUG调试内存申请情况 #define DEBUG_MEM 0 + +#define USE_OPENSSL 0 + using namespace ylib; // 斜杆 diff --git a/include/util/md5.h b/include/util/md5.h new file mode 100644 index 0000000..e40071c --- /dev/null +++ b/include/util/md5.h @@ -0,0 +1,53 @@ +// MD5.h +#ifndef BZF_MD5_H +#define BZF_MD5_H + +#include +#include +#include "base/buffer.h" +namespace ylib +{ + class MD5 + { + public: + typedef unsigned int size_type; // must be 32bit + + MD5(); + MD5(const ylib::buffer& value); + void update(const unsigned char* buf, size_type length); + void update(const char* buf, size_type length); + MD5& finalize(); + std::string hexdigest() const; + friend std::ostream& operator<<(std::ostream&, MD5 md5); + + private: + void init(); + typedef unsigned char uint1; // 8bit + typedef unsigned int uint4; // 32bit + enum { blocksize = 64 }; // VC6 won't eat a const static int here + + void transform(const uint1 block[blocksize]); + static void decode(uint4 output[], const uint1 input[], size_type len); + static void encode(uint1 output[], const uint4 input[], size_type len); + + bool finalized; + uint1 buffer[blocksize]; // bytes that didn't fit in last 64 byte chunk + uint4 count[2]; // 64bit counter for number of bits (lo, hi) + uint4 state[4]; // digest so far + uint1 digest[16]; // the result + + // low level logic operations + static inline uint4 F(uint4 x, uint4 y, uint4 z); + static inline uint4 G(uint4 x, uint4 y, uint4 z); + static inline uint4 H(uint4 x, uint4 y, uint4 z); + static inline uint4 I(uint4 x, uint4 y, uint4 z); + static inline uint4 rotate_left(uint4 x, int n); + static inline void FF(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac); + static inline void GG(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac); + static inline void HH(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac); + static inline void II(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac); + }; +} + + +#endif \ No newline at end of file diff --git a/include/util/sqlite3.h b/include/util/sqlite3.h index d9a74a8..c72de01 100644 --- a/include/util/sqlite3.h +++ b/include/util/sqlite3.h @@ -1,5 +1,5 @@ #pragma once -#include "sqlite3/sqlite3.h" + #include "base/define.h" #include "base/error.h" #include @@ -20,6 +20,6 @@ namespace ylib bool is_open() { return m_db != nullptr; } int64 last_insert_id(); private: - struct ::sqlite3* m_db; + void* m_db; }; } \ No newline at end of file diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index de70e77..2173dce 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -47,9 +47,5 @@ install(DIRECTORY ${PROJECT_SOURCE_DIR}/include/util ${PROJECT_SOURCE_DIR}/include/net DESTINATION include) -install(FILES - ${PROJECT_SOURCE_DIR}/3rdparty/openssl/lib/libcrypto_static_win64.lib - ${PROJECT_SOURCE_DIR}/3rdparty/openssl/lib/libcrypto_static_win32.lib -DESTINATION lib) diff --git a/src/util/codec.cpp b/src/util/codec.cpp index d4d1e97..6b8852f 100644 --- a/src/util/codec.cpp +++ b/src/util/codec.cpp @@ -32,7 +32,9 @@ #include "zlib/zlib.h" #include "HPSocket/HPSocket.h" +#if USE_OPENSSL== 1 #include +#endif #ifdef _WIN32 #include #endif @@ -40,27 +42,6 @@ #include -std::string ylib::codec::md5(const ylib::buffer &input) -{ - EVP_MD_CTX* mdctx; - const EVP_MD* md; - unsigned char md_value[EVP_MAX_MD_SIZE]; - unsigned int md_len; - - mdctx = EVP_MD_CTX_new(); - md = EVP_md5(); - EVP_DigestInit_ex(mdctx, md, NULL); - EVP_DigestUpdate(mdctx, input.data(), input.size()); - EVP_DigestFinal_ex(mdctx, md_value, &md_len); - EVP_MD_CTX_free(mdctx); - std::ostringstream hexStream; - hexStream << std::hex << std::setfill('0'); - for (unsigned int i = 0; i < md_len; i++) { - hexStream << std::setw(2) << (int)md_value[i]; - } - return hexStream.str(); -} - std::string ylib::codec::to_utf8(const std::string &gbk) { #ifdef _WIN32 @@ -200,7 +181,7 @@ ylib::buffer codec::url::de(const std::string& data) - +#if USE_OPENSSL== 1 ylib::buffer codec::aes::en(const ylib::buffer& data, const std::string& key, ylib::codec::aes::variant var, ylib::codec::aes::mode mod) { try @@ -321,4 +302,5 @@ ylib::buffer codec::aes::de(const ylib::buffer& ciphertext, const std::string& k std::cout << e.what() << std::endl; } return ylib::buffer(); -} \ No newline at end of file +} +#endif \ No newline at end of file diff --git a/src/util/md5.cpp b/src/util/md5.cpp new file mode 100644 index 0000000..9e2d012 --- /dev/null +++ b/src/util/md5.cpp @@ -0,0 +1,346 @@ +#include "util/md5.h" +#include +/* system implementation headers */ +#include +#include + + +// Constants for MD5Transform routine. +#define S11 7 +#define S12 12 +#define S13 17 +#define S14 22 +#define S21 5 +#define S22 9 +#define S23 14 +#define S24 20 +#define S31 4 +#define S32 11 +#define S33 16 +#define S34 23 +#define S41 6 +#define S42 10 +#define S43 15 +#define S44 21 +namespace ylib +{ + /////////////////////////////////////////////// + +// F, G, H and I are basic MD5 functions. + inline MD5::uint4 MD5::F(uint4 x, uint4 y, uint4 z) + { + return x & y | ~x & z; + } + + inline MD5::uint4 MD5::G(uint4 x, uint4 y, uint4 z) + { + return x & z | y & ~z; + } + + inline MD5::uint4 MD5::H(uint4 x, uint4 y, uint4 z) + { + return x ^ y ^ z; + } + + inline MD5::uint4 MD5::I(uint4 x, uint4 y, uint4 z) + { + return y ^ (x | ~z); + } + + // rotate_left rotates x left n bits. + inline MD5::uint4 MD5::rotate_left(uint4 x, int n) + { + return (x << n) | (x >> (32 - n)); + } + + // FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4. + // Rotation is separate from addition to prevent recomputation. + inline void MD5::FF(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) + { + a = rotate_left(a + F(b, c, d) + x + ac, s) + b; + } + + inline void MD5::GG(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) + { + a = rotate_left(a + G(b, c, d) + x + ac, s) + b; + } + + inline void MD5::HH(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) + { + a = rotate_left(a + H(b, c, d) + x + ac, s) + b; + } + + inline void MD5::II(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) + { + a = rotate_left(a + I(b, c, d) + x + ac, s) + b; + } + + ////////////////////////////////////////////// + + // default ctor, just initailize + MD5::MD5() + { + init(); + } + + ////////////////////////////////////////////// + + // nifty shortcut ctor, compute MD5 for string and finalize it right away + MD5::MD5(const ylib::buffer& value) + { + init(); + update((const char*)value.data(), (ylib::MD5::size_type)value.length()); + finalize(); + } + + ////////////////////////////// + + void MD5::init() + { + finalized = false; + + count[0] = 0; + count[1] = 0; + + // load magic initialization constants. + state[0] = 0x67452301; + state[1] = 0xefcdab89; + state[2] = 0x98badcfe; + state[3] = 0x10325476; + } + + ////////////////////////////// + + // decodes input (unsigned char) into output (uint4). Assumes len is a multiple of 4. + void MD5::decode(uint4 output[], const uint1 input[], size_type len) + { + for (unsigned int i = 0, j = 0; j < len; i++, j += 4) + output[i] = ((uint4)input[j]) | (((uint4)input[j + 1]) << 8) | (((uint4)input[j + 2]) << 16) | + (((uint4)input[j + 3]) << 24); + } + + ////////////////////////////// + + // encodes input (uint4) into output (unsigned char). Assumes len is + // a multiple of 4. + void MD5::encode(uint1 output[], const uint4 input[], size_type len) + { + for (size_type i = 0, j = 0; j < len; i++, j += 4) { + output[j] = input[i] & 0xff; + output[j + 1] = (input[i] >> 8) & 0xff; + output[j + 2] = (input[i] >> 16) & 0xff; + output[j + 3] = (input[i] >> 24) & 0xff; + } + } + + ////////////////////////////// + + // apply MD5 algo on a block + void MD5::transform(const uint1 block[blocksize]) + { + uint4 a = state[0], b = state[1], c = state[2], d = state[3], x[16]; + decode(x, block, blocksize); + + /* Round 1 */ + FF(a, b, c, d, x[0], S11, 0xd76aa478); /* 1 */ + FF(d, a, b, c, x[1], S12, 0xe8c7b756); /* 2 */ + FF(c, d, a, b, x[2], S13, 0x242070db); /* 3 */ + FF(b, c, d, a, x[3], S14, 0xc1bdceee); /* 4 */ + FF(a, b, c, d, x[4], S11, 0xf57c0faf); /* 5 */ + FF(d, a, b, c, x[5], S12, 0x4787c62a); /* 6 */ + FF(c, d, a, b, x[6], S13, 0xa8304613); /* 7 */ + FF(b, c, d, a, x[7], S14, 0xfd469501); /* 8 */ + FF(a, b, c, d, x[8], S11, 0x698098d8); /* 9 */ + FF(d, a, b, c, x[9], S12, 0x8b44f7af); /* 10 */ + FF(c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */ + FF(b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */ + FF(a, b, c, d, x[12], S11, 0x6b901122); /* 13 */ + FF(d, a, b, c, x[13], S12, 0xfd987193); /* 14 */ + FF(c, d, a, b, x[14], S13, 0xa679438e); /* 15 */ + FF(b, c, d, a, x[15], S14, 0x49b40821); /* 16 */ + + /* Round 2 */ + GG(a, b, c, d, x[1], S21, 0xf61e2562); /* 17 */ + GG(d, a, b, c, x[6], S22, 0xc040b340); /* 18 */ + GG(c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */ + GG(b, c, d, a, x[0], S24, 0xe9b6c7aa); /* 20 */ + GG(a, b, c, d, x[5], S21, 0xd62f105d); /* 21 */ + GG(d, a, b, c, x[10], S22, 0x2441453); /* 22 */ + GG(c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */ + GG(b, c, d, a, x[4], S24, 0xe7d3fbc8); /* 24 */ + GG(a, b, c, d, x[9], S21, 0x21e1cde6); /* 25 */ + GG(d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */ + GG(c, d, a, b, x[3], S23, 0xf4d50d87); /* 27 */ + GG(b, c, d, a, x[8], S24, 0x455a14ed); /* 28 */ + GG(a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */ + GG(d, a, b, c, x[2], S22, 0xfcefa3f8); /* 30 */ + GG(c, d, a, b, x[7], S23, 0x676f02d9); /* 31 */ + GG(b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */ + + /* Round 3 */ + HH(a, b, c, d, x[5], S31, 0xfffa3942); /* 33 */ + HH(d, a, b, c, x[8], S32, 0x8771f681); /* 34 */ + HH(c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */ + HH(b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */ + HH(a, b, c, d, x[1], S31, 0xa4beea44); /* 37 */ + HH(d, a, b, c, x[4], S32, 0x4bdecfa9); /* 38 */ + HH(c, d, a, b, x[7], S33, 0xf6bb4b60); /* 39 */ + HH(b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */ + HH(a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */ + HH(d, a, b, c, x[0], S32, 0xeaa127fa); /* 42 */ + HH(c, d, a, b, x[3], S33, 0xd4ef3085); /* 43 */ + HH(b, c, d, a, x[6], S34, 0x4881d05); /* 44 */ + HH(a, b, c, d, x[9], S31, 0xd9d4d039); /* 45 */ + HH(d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */ + HH(c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */ + HH(b, c, d, a, x[2], S34, 0xc4ac5665); /* 48 */ + + /* Round 4 */ + II(a, b, c, d, x[0], S41, 0xf4292244); /* 49 */ + II(d, a, b, c, x[7], S42, 0x432aff97); /* 50 */ + II(c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */ + II(b, c, d, a, x[5], S44, 0xfc93a039); /* 52 */ + II(a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */ + II(d, a, b, c, x[3], S42, 0x8f0ccc92); /* 54 */ + II(c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */ + II(b, c, d, a, x[1], S44, 0x85845dd1); /* 56 */ + II(a, b, c, d, x[8], S41, 0x6fa87e4f); /* 57 */ + II(d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */ + II(c, d, a, b, x[6], S43, 0xa3014314); /* 59 */ + II(b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */ + II(a, b, c, d, x[4], S41, 0xf7537e82); /* 61 */ + II(d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */ + II(c, d, a, b, x[2], S43, 0x2ad7d2bb); /* 63 */ + II(b, c, d, a, x[9], S44, 0xeb86d391); /* 64 */ + + state[0] += a; + state[1] += b; + state[2] += c; + state[3] += d; + + // Zeroize sensitive information. + memset(x, 0, sizeof x); + } + + ////////////////////////////// + + // MD5 block update operation. Continues an MD5 message-digest + // operation, processing another message block + void MD5::update(const unsigned char input[], size_type length) + { + // compute number of bytes mod 64 + size_type index = count[0] / 8 % blocksize; + + // Update number of bits + if ((count[0] += (length << 3)) < (length << 3)) + count[1]++; + count[1] += (length >> 29); + + // number of bytes we need to fill in buffer + size_type firstpart = 64 - index; + + size_type i; + + // transform as many times as possible. + if (length >= firstpart) { + // fill buffer first, transform + memcpy(&buffer[index], input, firstpart); + transform(buffer); + + // transform chunks of blocksize (64 bytes) + for (i = firstpart; i + blocksize <= length; i += blocksize) + transform(&input[i]); + + index = 0; + } + else + i = 0; + + // buffer remaining input + memcpy(&buffer[index], &input[i], length - i); + } + + ////////////////////////////// + + // for convenience provide a verson with signed char + void MD5::update(const char input[], size_type length) + { + update((const unsigned char*)input, length); + } + + ////////////////////////////// + + // MD5 finalization. Ends an MD5 message-digest operation, writing the + // the message digest and zeroizing the context. + MD5& MD5::finalize() + { + static unsigned char padding[64] = { 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0 }; + + if (!finalized) { + // Save number of bits + unsigned char bits[8]; + encode(bits, count, 8); + + // pad out to 56 mod 64. + size_type index = count[0] / 8 % 64; + size_type padLen = (index < 56) ? (56 - index) : (120 - index); + update(padding, padLen); + + // Append length (before padding) + update(bits, 8); + + // Store state in digest + encode(digest, state, 16); + + // Zeroize sensitive information. + memset(buffer, 0, sizeof buffer); + memset(count, 0, sizeof count); + + finalized = true; + } + + return *this; + } + + ////////////////////////////// + + // return hex representation of digest as string + std::string MD5::hexdigest() const + { + if (!finalized) + return ""; + const int buf_len = 33; + char buf[buf_len]; + for (int i = 0; i < 16; i++) +#ifdef _WIN32 + sprintf(buf + i * 2, "%02x", digest[i]); +#else + sprintf(buf + i * 2, "%02x", digest[i]); +#endif + buf[32] = 0; + + return std::string(buf); + } + + ////////////////////////////// + + std::ostream& operator<<(std::ostream& out, MD5 md5) + { + return out << md5.hexdigest().c_str(); + } + ////////////////////////////// + +} +namespace ylib +{ + namespace codec + { + std::string md5(const ylib::buffer& data) + { + MD5 md5 = MD5(data); + return md5.hexdigest(); + } + } +} diff --git a/src/util/sharedmem.cpp b/src/util/sharedmem.cpp index ba91f6d..fdac0f5 100644 --- a/src/util/sharedmem.cpp +++ b/src/util/sharedmem.cpp @@ -102,7 +102,7 @@ void ylib::sharedmem::destory() if (m_handle != -1) { close(m_handle); } - shm_unlink(m_name_.c_str()); + shm_unlink(m_name.c_str()); m_handle = -1; #endif m_memory = nullptr; diff --git a/src/util/sqlite3.cpp b/src/util/sqlite3.cpp index 73834b5..3193d1d 100644 --- a/src/util/sqlite3.cpp +++ b/src/util/sqlite3.cpp @@ -23,12 +23,14 @@ // EMail：1585346868@qq.com // QQ：1585346868 - +#include "sqlite3/sqlite3.h" #include "util/sqlite3.h" #include "util/codec.h" #include "util/file.h" #include "base/conversion.h" #define DEBUG_PRINT_SQL 0 + +#define DB_PTR (::sqlite3*)m_db ylib::sqlite3::sqlite3() { m_db = nullptr; @@ -42,9 +44,9 @@ bool ylib::sqlite3::open(const std::string& filepath, const std::string& usernam close(); m_db = nullptr; - if (sqlite3_open(codec::to_utf8(filepath).c_str(), &m_db) != 0) + if (sqlite3_open(codec::to_utf8(filepath).c_str(),(::sqlite3**)&m_db) != 0) { - this->m_lastErrorDesc = sqlite3_errmsg(m_db); + this->m_lastErrorDesc = sqlite3_errmsg(DB_PTR); return false; } return true; @@ -53,7 +55,7 @@ bool ylib::sqlite3::open(const std::string& filepath, const std::string& usernam void ylib::sqlite3::close() { if(m_db!= nullptr) - sqlite3_close(m_db); + sqlite3_close(DB_PTR); m_db = nullptr; } @@ -65,7 +67,7 @@ bool ylib::sqlite3::exec(const std::string& sql) #endif #endif char* cErrMsg = nullptr; - if (sqlite3_exec(m_db, sql.c_str(), nullptr, nullptr, &cErrMsg) != SQLITE_OK) + if (sqlite3_exec(DB_PTR, sql.c_str(), nullptr, nullptr, &cErrMsg) != SQLITE_OK) { m_lastErrorDesc = cErrMsg; return false; @@ -92,7 +94,7 @@ bool ylib::sqlite3::query(const std::string& sql, std::vectorm_lastErrorDesc = cErrMsg; return false; @@ -111,5 +113,5 @@ int64 ylib::sqlite3::count(const std::string& sql) } int64 ylib::sqlite3::last_insert_id() { - return sqlite3_last_insert_rowid(m_db); + return sqlite3_last_insert_rowid(DB_PTR); } \ No newline at end of file