提供更多文本转换模式

others/C++/text converter/src/MainWindow.cpp

@@ -22,6 +22,10 @@ MainWindow::MainWindow(int w, int h, const char* title) : Fl_Window(w, h, title)
     conversionType->add("MD5");
     conversionType->add("SHA1");
     conversionType->add("SHA256");
+    conversionType->add("SHA224");
+    conversionType->add("SHA384");
+    conversionType->add("SHA512");
+    conversionType->add("SHA3");
     conversionType->add("Base64");
     conversionType->add("Base32");
     conversionType->add("Ascii85");
@@ -48,19 +52,25 @@ void MainWindow::ConvertCallback(Fl_Widget* widget, void* data) {
 }
 
 void MainWindow::ConvertText() {
-    const char* input = inputText->value();
-    if (!input || strlen(input) == 0) {
-        fl_alert("请输入要转换的文本");
-        return;
-    }
+    try {
+        const char* input = inputText->value();
+        if (!input || strlen(input) == 0) {
+            fl_alert("请输入要转换的文本");
+            return;
+        }
 
-    int type = conversionType->value();
-    auto converter = Utils::createConverter(type);
-    if (!converter) {
-        fl_alert("不支持的转换类型");
-        return;
-    }
+        int type = conversionType->value();
+        auto converter = Utils::createConverter(type);
+        if (!converter) {
+            fl_alert("不支持的转换类型");
+            return;
+        }
 
-    std::string result = converter->convert(input);
-    outputText->value(result.c_str());
+        std::string result = converter->convert(input);
+        outputText->value(result.c_str());
+    } catch (const std::exception& e) {
+        fl_alert(("转换失败: " + std::string(e.what())).c_str());
+    } catch (...) {
+        fl_alert("未知错误: 转换失败");
+    }
 }

others/C++/text converter/src/SHA224Converter.cpp

@@ -0,0 +1,45 @@
+#include "../include/SHA224Converter.hpp"
+#include <openssl/evp.h>
+#include <sstream>
+#include <iomanip>
+#include <stdexcept>
+
+std::string SHA224Converter::convert(const std::string& input) {
+    EVP_MD_CTX* mdctx = EVP_MD_CTX_new();
+    if (!mdctx) {
+        throw std::runtime_error("Failed to create EVP_MD_CTX");
+    }
+
+    const EVP_MD* md = EVP_sha224();
+    if (!md) {
+        EVP_MD_CTX_free(mdctx);
+        throw std::runtime_error("SHA224 not supported by this OpenSSL version");
+    }
+
+    unsigned char digest[EVP_MAX_MD_SIZE];
+    unsigned int digest_len;
+
+    if (EVP_DigestInit_ex(mdctx, md, nullptr) != 1) {
+        EVP_MD_CTX_free(mdctx);
+        throw std::runtime_error("Failed to initialize digest");
+    }
+
+    if (EVP_DigestUpdate(mdctx, input.c_str(), input.length()) != 1) {
+        EVP_MD_CTX_free(mdctx);
+        throw std::runtime_error("Failed to update digest");
+    }
+
+    if (EVP_DigestFinal_ex(mdctx, digest, &digest_len) != 1) {
+        EVP_MD_CTX_free(mdctx);
+        throw std::runtime_error("Failed to finalize digest");
+    }
+
+    EVP_MD_CTX_free(mdctx);
+
+    std::stringstream ss;
+    for(unsigned int i = 0; i < digest_len; i++) {
+        ss << std::hex << std::setw(2) << std::setfill('0') << (int)digest[i];
+    }
+
+    return ss.str();
+}

others/C++/text converter/src/SHA384Converter.cpp

@@ -0,0 +1,45 @@
+#include "../include/SHA384Converter.hpp"
+#include <openssl/evp.h>
+#include <sstream>
+#include <iomanip>
+#include <stdexcept>
+
+std::string SHA384Converter::convert(const std::string& input) {
+    EVP_MD_CTX* mdctx = EVP_MD_CTX_new();
+    if (!mdctx) {
+        throw std::runtime_error("Failed to create EVP_MD_CTX");
+    }
+
+    const EVP_MD* md = EVP_sha384();
+    if (!md) {
+        EVP_MD_CTX_free(mdctx);
+        throw std::runtime_error("SHA384 not supported by this OpenSSL version");
+    }
+
+    unsigned char digest[EVP_MAX_MD_SIZE];
+    unsigned int digest_len;
+
+    if (EVP_DigestInit_ex(mdctx, md, nullptr) != 1) {
+        EVP_MD_CTX_free(mdctx);
+        throw std::runtime_error("Failed to initialize digest");
+    }
+
+    if (EVP_DigestUpdate(mdctx, input.c_str(), input.length()) != 1) {
+        EVP_MD_CTX_free(mdctx);
+        throw std::runtime_error("Failed to update digest");
+    }
+
+    if (EVP_DigestFinal_ex(mdctx, digest, &digest_len) != 1) {
+        EVP_MD_CTX_free(mdctx);
+        throw std::runtime_error("Failed to finalize digest");
+    }
+
+    EVP_MD_CTX_free(mdctx);
+
+    std::stringstream ss;
+    for(unsigned int i = 0; i < digest_len; i++) {
+        ss << std::hex << std::setw(2) << std::setfill('0') << (int)digest[i];
+    }
+
+    return ss.str();
+}

others/C++/text converter/src/SHA3Converter.cpp

@@ -0,0 +1,45 @@
+#include "../include/SHA3Converter.hpp"
+#include <openssl/evp.h>
+#include <sstream>
+#include <iomanip>
+#include <stdexcept>
+
+std::string SHA3Converter::convert(const std::string& input) {
+    EVP_MD_CTX* mdctx = EVP_MD_CTX_new();
+    if (!mdctx) {
+        throw std::runtime_error("Failed to create EVP_MD_CTX");
+    }
+
+    const EVP_MD* md = EVP_sha3_256();
+    if (!md) {
+        EVP_MD_CTX_free(mdctx);
+        throw std::runtime_error("SHA3-256 not supported by this OpenSSL version");
+    }
+
+    unsigned char digest[EVP_MAX_MD_SIZE];
+    unsigned int digest_len;
+
+    if (EVP_DigestInit_ex(mdctx, md, nullptr) != 1) {
+        EVP_MD_CTX_free(mdctx);
+        throw std::runtime_error("Failed to initialize digest");
+    }
+
+    if (EVP_DigestUpdate(mdctx, input.c_str(), input.length()) != 1) {
+        EVP_MD_CTX_free(mdctx);
+        throw std::runtime_error("Failed to update digest");
+    }
+
+    if (EVP_DigestFinal_ex(mdctx, digest, &digest_len) != 1) {
+        EVP_MD_CTX_free(mdctx);
+        throw std::runtime_error("Failed to finalize digest");
+    }
+
+    EVP_MD_CTX_free(mdctx);
+
+    std::stringstream ss;
+    for(unsigned int i = 0; i < digest_len; i++) {
+        ss << std::hex << std::setw(2) << std::setfill('0') << (int)digest[i];
+    }
+
+    return ss.str();
+}

others/C++/text converter/src/SHA512Converter.cpp

@@ -0,0 +1,45 @@
+#include "../include/SHA512Converter.hpp"
+#include <openssl/evp.h>
+#include <sstream>
+#include <iomanip>
+#include <stdexcept>
+
+std::string SHA512Converter::convert(const std::string& input) {
+    EVP_MD_CTX* mdctx = EVP_MD_CTX_new();
+    if (!mdctx) {
+        throw std::runtime_error("Failed to create EVP_MD_CTX");
+    }
+
+    const EVP_MD* md = EVP_sha512();
+    if (!md) {
+        EVP_MD_CTX_free(mdctx);
+        throw std::runtime_error("SHA512 not supported by this OpenSSL version");
+    }
+
+    unsigned char digest[EVP_MAX_MD_SIZE];
+    unsigned int digest_len;
+
+    if (EVP_DigestInit_ex(mdctx, md, nullptr) != 1) {
+        EVP_MD_CTX_free(mdctx);
+        throw std::runtime_error("Failed to initialize digest");
+    }
+
+    if (EVP_DigestUpdate(mdctx, input.c_str(), input.length()) != 1) {
+        EVP_MD_CTX_free(mdctx);
+        throw std::runtime_error("Failed to update digest");
+    }
+
+    if (EVP_DigestFinal_ex(mdctx, digest, &digest_len) != 1) {
+        EVP_MD_CTX_free(mdctx);
+        throw std::runtime_error("Failed to finalize digest");
+    }
+
+    EVP_MD_CTX_free(mdctx);
+
+    std::stringstream ss;
+    for(unsigned int i = 0; i < digest_len; i++) {
+        ss << std::hex << std::setw(2) << std::setfill('0') << (int)digest[i];
+    }
+
+    return ss.str();
+}

others/C++/text converter/src/Utils.cpp

@@ -3,6 +3,10 @@
 #include "../include/MD5Converter.hpp"
 #include "../include/SHA1Converter.hpp"
 #include "../include/SHA256Converter.hpp"
+#include "../include/SHA224Converter.hpp"
+#include "../include/SHA384Converter.hpp"
+#include "../include/SHA512Converter.hpp"
+#include "../include/SHA3Converter.hpp"
 #include "../include/Base64Converter.hpp"
 #include "../include/Base32Converter.hpp"
 #include "../include/Ascii85Converter.hpp"
@@ -20,6 +24,10 @@ std::unique_ptr<Converter> Utils::createConverter(int type) {
         case 7: return std::unique_ptr<Converter>(new Base32Converter());
         case 8: return std::unique_ptr<Converter>(new Ascii85Converter());
         case 9: return std::unique_ptr<Converter>(new CRC32Converter());
+        case 10: return std::unique_ptr<Converter>(new SHA224Converter());
+        case 11: return std::unique_ptr<Converter>(new SHA384Converter());
+        case 12: return std::unique_ptr<Converter>(new SHA512Converter());
+        case 13: return std::unique_ptr<Converter>(new SHA3Converter());
         default: return nullptr;
     }
 }