md5sum.cpp

Go to the documentation of this file.

#include "md5sum.h"
#include "block.h"
#include <iomanip>
#include <iostream>
#include <sstream>
#include <vector>
 
namespace checksum {
    decltype(md5sum::factory) md5sum::factory("md5sum");
    md5sum::md5sum(const std::string& aName ): base(aName) {
        #ifdef USE_OPENSSL
        ctx = EVP_MD_CTX_create();
        mdType = EVP_md5();
        EVP_MD_CTX_init(ctx);
        EVP_DigestInit_ex(ctx, mdType, nullptr);
        #else
        __md5_init_ctx(&ctx);
        #endif
    }
    void  md5sum::update(void *data, size_t size) {
        for (size_t bytes_done = 0; bytes_done < size;) {
            size_t bytes = 4096;
            auto missing = size - bytes_done;
 
            if (missing < bytes) {
                bytes = missing;
            }
 
            auto dataStart = static_cast<void*>(static_cast<char*>(data) + bytes_done);
            #ifdef USE_OPENSSL
            EVP_DigestUpdate(ctx, dataStart, bytes);
            #else
 
            if (size & (64 - 1)) { // use processor that needs no 64Byte size
                __md5_process_bytes(dataStart, bytes, &ctx);
            } else {
                __md5_process_block(dataStart, bytes, &ctx);
            }
 
            #endif
            bytes_done += bytes;
        }
    }
    void  md5sum::update(size_t size) { // case for block of zeroes
        #ifndef USE_OPENSSL
        if ((size & (64 - 1)) == 0) {
            __md5_process_zero(size, &ctx);
        } else
        #endif
        {
            for (size_t bytes_done = 0; bytes_done < size;) {
                auto missing = size - bytes_done;
                auto bytes = std::min(missing, block::nullBufferSize());
                #ifdef USE_OPENSSL
                EVP_DigestUpdate(ctx, block::nullBuffer(), bytes);
                #else
 
                if (size & (64 - 1)) { // use processor that needs no 64Byte size
                    __md5_process_bytes(block::nullBuffer(), bytes, &ctx);
                } else {
                    __md5_process_zero(bytes, &ctx);
                }
 
                #endif
                bytes_done += bytes;
            }
        }
    }
 
    void md5sum::finish() {
        #ifdef USE_OPENSSL
        std::vector<unsigned char> md(EVP_MD_size(mdType));
        EVP_DigestFinal_ex(ctx, md.data(), nullptr);
        EVP_MD_CTX_cleanup(ctx);
        EVP_MD_CTX_destroy(ctx);
        #else
        unsigned char md[16];
        __md5_finish_ctx(&ctx, md);
        #endif
        std::ostringstream hashBuffer;
 
        for (auto c : md) {
            hashBuffer << std::hex << std::setw(2) << std::setfill('0') << static_cast<unsigned int>(c);
        }
 
        result = hashBuffer.str();
    }
}; // end namespace checksum