ckfactory.cpp

Go to the documentation of this file.

/*
 * libxcks
 * Copyright (C) 2022 Julien Couot
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 * License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
//---------------------------------------------------------------------------
#include <boost/locale.hpp>
#include <cstring>
 
#include "libxcks/ckfactory.hpp"
 
#include "libxcks/defs.hpp"
#include "strutil.hpp"
#include "blake3.hpp"
#include "crc32.hpp"
#include "crc64.hpp"
#include "md2.hpp"
#include "md4.hpp"
#include "md5.hpp"
#include "rmd160.hpp"
#include "sha1.hpp"
#include "sha224_256.hpp"
#include "sha384_512.hpp"
#include "keccak.hpp"
#include "sm3.hpp"
#include "tiger.hpp"
#include "whirlpool.hpp"
//---------------------------------------------------------------------------
 
 
using namespace std;
 
// The Boost.Locale namespace.
using namespace boost::locale;
//---------------------------------------------------------------------------
 
 
namespace libxcks
{
typedef Checksum* (FnctGetChecksum)();
 
 
//###########################################################################
// ChecksumFactory::ChecksumEntry members
//###########################################################################
class ChecksumFactory::ChecksumEntry final
{
 public:
  FnctGetChecksum* fnctGetChecksum;  
  std::string name;  
  ArrayString altNames;  
  std::string descr;  
  ChecksumValue nullValue;  
 
 protected:
  // Clones the source instance in this instance.
  void clone(const ChecksumEntry& source);
 
 public:
  ChecksumEntry() { fnctGetChecksum = nullptr; }
 
  // Constructor.
  ChecksumEntry(FnctGetChecksum* getChecksum, const std::string& name,
                const ArrayString& alternativeNames,
                const std::string& description);
 
  ChecksumEntry(const ChecksumEntry& source) { clone(source); };
 
  ChecksumEntry& operator=(const ChecksumEntry& source) { clone(source); return *this; };
};
//---------------------------------------------------------------------------
 
 
ChecksumFactory::ChecksumEntry::ChecksumEntry(FnctGetChecksum* getChecksum,
                                              const std::string& name,
                                              const ArrayString& alternativeNames,
                                              const std::string& description) :
           fnctGetChecksum(getChecksum), name(name), altNames(alternativeNames),
           descr(description)
{
  if (getChecksum != nullptr)
  {
    Checksum* c = getChecksum();
    if (c != nullptr)
    {
      const size_t size = c->getSize();
      uint8_t* buf = new uint8_t[size];
      memset(buf, 0, size);
      nullValue.setValue(buf, size, c->getID());
 
      delete[] buf;
      delete c;
    }
  }
}
//---------------------------------------------------------------------------
 
 
void ChecksumFactory::ChecksumEntry::clone(const ChecksumEntry& source)
{
  if (this != &source)
  {
    this->fnctGetChecksum = source.fnctGetChecksum;
    this->name = source.name;
    this->altNames = source.altNames;
    this->descr = source.descr;
    this->nullValue = source.nullValue;
  }
}
//---------------------------------------------------------------------------
 
 
 
 
//###########################################################################
// ChecksumFactory members
//###########################################################################
 
// Static attributes of the ChecksumFactory class
ChecksumFactory::ChecksumEntries ChecksumFactory::checksumAlgorithms;
//---------------------------------------------------------------------------
 
 
void ChecksumFactory::initialise()
{
  checksumAlgorithms.emplace(BLAKE3::getIdentifier(),
    ChecksumEntry(BLAKE3::getNewInstance, BLAKE3::getHashName(),
                  BLAKE3::getAlternativeNames(), translate("BLAKE3 cryptographic hash function").str(libxcks_domain)));
  checksumAlgorithms.emplace(CRC32::getIdentifier(),
    ChecksumEntry(CRC32::getNewInstance, CRC32::getChecksumName(),
                  CRC32::getAlternativeNames(), translate("CRC32 cyclic redundancy check algorithm").str(libxcks_domain)));
  checksumAlgorithms.emplace(CRC64::getIdentifier(),
    ChecksumEntry(CRC64::getNewInstance, CRC64::getChecksumName(),
                  CRC64::getAlternativeNames(), translate("CRC64 cyclic redundancy check algorithm").str(libxcks_domain)));
  checksumAlgorithms.emplace(MD2::getIdentifier(),
    ChecksumEntry(MD2::getNewInstance, MD2::getHashName(),
                  MD2::getAlternativeNames(), translate("MD2 cryptographic hash function").str(libxcks_domain)));
  checksumAlgorithms.emplace(MD4::getIdentifier(),
    ChecksumEntry(MD4::getNewInstance, MD4::getHashName(),
                  MD4::getAlternativeNames(), translate("MD4 cryptographic hash function").str(libxcks_domain)));
  checksumAlgorithms.emplace(MD5::getIdentifier(),
    ChecksumEntry(MD5::getNewInstance, MD5::getHashName(),
                  MD5::getAlternativeNames(), translate("MD5 cryptographic hash function").str(libxcks_domain)));
  checksumAlgorithms.emplace(RIPEMD160::getIdentifier(),
    ChecksumEntry(RIPEMD160::getNewInstance, RIPEMD160::getHashName(),
                  RIPEMD160::getAlternativeNames(), translate("RIPEMD-160 cryptographic hash function").str(libxcks_domain)));
  checksumAlgorithms.emplace(SHA1::getIdentifier(),
    ChecksumEntry(SHA1::getNewInstance, SHA1::getHashName(),
                  SHA1::getAlternativeNames(), translate("SHA1 cryptographic hash function").str(libxcks_domain)));
  checksumAlgorithms.emplace(SHA224::getIdentifier(),
    ChecksumEntry(SHA224::getNewInstance, SHA224::getHashName(),
                  SHA224::getAlternativeNames(), translate("SHA224 cryptographic hash function").str(libxcks_domain)));
  checksumAlgorithms.emplace(SHA256::getIdentifier(),
    ChecksumEntry(SHA256::getNewInstance, SHA256::getHashName(),
                  SHA256::getAlternativeNames(), translate("SHA256 cryptographic hash function").str(libxcks_domain)));
  checksumAlgorithms.emplace(SHA384::getIdentifier(),
    ChecksumEntry(SHA384::getNewInstance, SHA384::getHashName(),
                  SHA384::getAlternativeNames(), translate("SHA384 cryptographic hash function").str(libxcks_domain)));
  checksumAlgorithms.emplace(SHA512::getIdentifier(),
    ChecksumEntry(SHA512::getNewInstance, SHA512::getHashName(),
                  SHA512::getAlternativeNames(), translate("SHA512 cryptographic hash function").str(libxcks_domain)));
  checksumAlgorithms.emplace(SHA3_224::getIdentifier(),
    ChecksumEntry(SHA3_224::getNewInstance, SHA3_224::getHashName(),
                  SHA3_224::getAlternativeNames(), translate("SHA3-224 cryptographic hash function").str(libxcks_domain)));
  checksumAlgorithms.emplace(SHA3_256::getIdentifier(),
    ChecksumEntry(SHA3_256::getNewInstance, SHA3_256::getHashName(),
                  SHA3_256::getAlternativeNames(), translate("SHA3-256 cryptographic hash function").str(libxcks_domain)));
  checksumAlgorithms.emplace(SHA3_384::getIdentifier(),
    ChecksumEntry(SHA3_384::getNewInstance, SHA3_384::getHashName(),
                  SHA3_384::getAlternativeNames(), translate("SHA3-384 cryptographic hash function").str(libxcks_domain)));
  checksumAlgorithms.emplace(SHA3_512::getIdentifier(),
    ChecksumEntry(SHA3_512::getNewInstance, SHA3_512::getHashName(),
                  SHA3_512::getAlternativeNames(), translate("SHA3-512 cryptographic hash function").str(libxcks_domain)));
  #if 0
  checksumAlgorithms.emplace(Keccak224::getIdentifier(),
    ChecksumEntry(Keccak224::getNewInstance, Keccak224::getHashName(),
                  Keccak224::getAlternativeNames(), translate("Keccak224 cryptographic hash function").str(libxcks_domain)));
  checksumAlgorithms.emplace(Keccak256::getIdentifier(),
    ChecksumEntry(Keccak256::getNewInstance, Keccak256::getHashName(),
                  Keccak256::getAlternativeNames(), translate("Keccak256 cryptographic hash function").str(libxcks_domain)));
  checksumAlgorithms.emplace(Keccak384::getIdentifier(),
    ChecksumEntry(Keccak384::getNewInstance, Keccak384::getHashName(),
                  Keccak384::getAlternativeNames(), translate("Keccak384 cryptographic hash function").str(libxcks_domain)));
  checksumAlgorithms.emplace(Keccak512::getIdentifier(),
    ChecksumEntry(Keccak512::getNewInstance, Keccak512::getHashName(),
                  Keccak512::getAlternativeNames(), translate("Keccak512 cryptographic hash function").str(libxcks_domain)));
  #endif
  checksumAlgorithms.emplace(SM3::getIdentifier(),
    ChecksumEntry(SM3::getNewInstance, SM3::getHashName(),
                  SM3::getAlternativeNames(), translate("SM3 cryptographic hash function").str(libxcks_domain)));
  checksumAlgorithms.emplace(Tiger::getIdentifier(),
    ChecksumEntry(Tiger::getNewInstance, Tiger::getHashName(),
                  Tiger::getAlternativeNames(), translate("Tiger cryptographic hash function").str(libxcks_domain)));
  checksumAlgorithms.emplace(Whirlpool::getIdentifier(),
    ChecksumEntry(Whirlpool::getNewInstance, Whirlpool::getHashName(),
                  Whirlpool::getAlternativeNames(), translate("Whirlpool cryptographic hash function").str(libxcks_domain)));
}
//---------------------------------------------------------------------------
 
 
void ChecksumFactory::cleanUp()
{
  checksumAlgorithms.clear();
}
//---------------------------------------------------------------------------
 
 
Checksum* ChecksumFactory::getNewInstance(const ChecksumAlgoId id)
{
  if (exists(id))
    return checksumAlgorithms[id].fnctGetChecksum();
  else
    return nullptr;
}
//---------------------------------------------------------------------------
 
 
Checksum* ChecksumFactory::getNewInstance(const std::string& name,
                                          const bool lookInAltNames)
{
  ChecksumAlgoId id;
  if (getAlgorithmId(id, name, lookInAltNames))
    return checksumAlgorithms[id].fnctGetChecksum();
  else
    return nullptr;
}
//---------------------------------------------------------------------------
 
 
ChecksumValue ChecksumFactory::getNullValue(const ChecksumAlgoId id)
{
  if (exists(id))
    return checksumAlgorithms[id].nullValue;
  else
    return ChecksumValue();
}
//---------------------------------------------------------------------------
 
 
ChecksumValue ChecksumFactory::getNullValue(const std::string& name,
                                            const bool lookInAltNames)
{
  ChecksumAlgoId id;
  if (getAlgorithmId(id, name, lookInAltNames))
    return checksumAlgorithms[id].nullValue;
  else
    return ChecksumValue();
}
//---------------------------------------------------------------------------
 
 
size_t ChecksumFactory::getSize(const ChecksumAlgoId id)
{
  if (exists(id))
    return checksumAlgorithms[id].nullValue.getSize();
  else
    return SIZE_MAX;
}
//---------------------------------------------------------------------------
 
 
size_t ChecksumFactory::getSize(const std::string& name, const bool lookInAltNames)
{
  ChecksumAlgoId id;
  if (getAlgorithmId(id, name, lookInAltNames))
    return checksumAlgorithms[id].nullValue.getSize();
  else
    return SIZE_MAX;
}
//---------------------------------------------------------------------------
 
 
bool ChecksumFactory::exists(const ChecksumAlgoId id)
{
  const ChecksumEntries& ca = checksumAlgorithms;
  ChecksumEntries::const_iterator it = ca.find(id);
 
  return (it != ca.end());
}
//---------------------------------------------------------------------------
 
 
bool ChecksumFactory::exists(const std::string& name, const bool lookInAltNames)
{
  ChecksumAlgoId id;
  return getAlgorithmId(id, name, lookInAltNames);
}
//---------------------------------------------------------------------------
 
 
bool ChecksumFactory::existsNoCase(const string& name, const bool lookInAltNames)
{
  ChecksumAlgoId id;
  return getAlgorithmIdNoCase(id, name, lookInAltNames);
}
//---------------------------------------------------------------------------
 
 
ArrayChecksumAlgoId ChecksumFactory::getAlgorithmsIds()
{
  ArrayChecksumAlgoId res;
  res.reserve(checksumAlgorithms.size());
 
  const ChecksumEntries& ca = checksumAlgorithms;
  for (ChecksumEntries::const_iterator it = ca.begin(); it != ca.end(); it++)
    res.push_back(it->first);
 
  return res;
}
//---------------------------------------------------------------------------
 
 
ArrayString ChecksumFactory::getAlgorithmsNames()
{
  ArrayString res;
  res.reserve(checksumAlgorithms.size());
 
  const ChecksumEntries& ca = checksumAlgorithms;
  for (ChecksumEntries::const_iterator it = ca.begin(); it != ca.end(); it++)
    res.emplace_back(it->second.name);
 
  return res;
}
//---------------------------------------------------------------------------
 
 
int ChecksumFactory::getAlgorithmsCount()
{
  return checksumAlgorithms.size();
}
//---------------------------------------------------------------------------
 
 
bool ChecksumFactory::getAlgorithmId(ChecksumAlgoId& id, const string& name,
                                     const bool lookInAltNames)
{
  bool found = false;
 
  const ChecksumEntries& ca = checksumAlgorithms;
  ChecksumEntries::const_iterator it = ca.begin();
  while (!found && it != ca.end())
  {
    if (it->second.name == name)
    {
      id = it->first;
      found = true;
    }
    else if (lookInAltNames)
    {
      const ArrayString& altNames = it->second.altNames;
      size_t s = altNames.size();
      size_t i = 0;
      while (!found && i < s)
      {
        if (altNames[i] == name)
        {
          found = true;
          id = it->first;
        }
 
        i++;
      }
    }
 
    it++;
  }
 
  return found;
}
//---------------------------------------------------------------------------
 
 
bool ChecksumFactory::getAlgorithmIdNoCase(ChecksumAlgoId& id, const string& name,
                                           const bool lookInAltNames)
{
  bool found = false;
 
  const ChecksumEntries& ca = checksumAlgorithms;
  ChecksumEntries::const_iterator it = ca.begin();
  while (!found && it != ca.end())
  {
    if (stringICompare(it->second.name, name))
    {
      id = it->first;
      found = true;
    }
    else if (lookInAltNames)
    {
      const ArrayString& altNames = it->second.altNames;
      size_t s = altNames.size();
      size_t i = 0;
      while (!found && i < s)
      {
        if (stringICompare(altNames[i], name))
        {
          found = true;
          id = it->first;
        }
 
        i++;
      }
    }
 
    it++;
  }
 
  return found;
}
//---------------------------------------------------------------------------
 
 
bool ChecksumFactory::getAlgorithmName(std::string& name, const ChecksumAlgoId id)
{
  if (exists(id))
  {
    name = checksumAlgorithms[id].name;
    return true;
  }
 
  return false;
}
//---------------------------------------------------------------------------
 
 
bool ChecksumFactory::getAlgorithmName(std::string& name, const std::string& altName)
{
  ChecksumAlgoId id;
  if (getAlgorithmId(id, altName, true))
    return getAlgorithmName(name, id);
 
  return false;
}
//---------------------------------------------------------------------------
 
 
bool ChecksumFactory::getAlgorithmAltNames(ArrayString& altNames,
                                           const ChecksumAlgoId id,
                                           const bool giveName)
{
  if (exists(id))
  {
    altNames = checksumAlgorithms[id].altNames;
    if (giveName)
      altNames.emplace(altNames.begin(), checksumAlgorithms[id].name);
    return true;
  }
 
  return false;
}
//---------------------------------------------------------------------------
 
 
bool ChecksumFactory::getAlgorithmAltNames(ArrayString& altNames,
                                           const std::string& name,
                                           const bool nameCouldBeAlt,
                                           const bool giveName)
{
  ChecksumAlgoId id;
  if (getAlgorithmId(id, name, nameCouldBeAlt))
    return getAlgorithmAltNames(altNames, id, giveName);
 
  return false;
}
//---------------------------------------------------------------------------
 
 
std::string ChecksumFactory::getAlgorithmDescription(const ChecksumAlgoId id)
{
  if (exists(id))
    return checksumAlgorithms[id].descr;
 
  return string();
}
//---------------------------------------------------------------------------
 
 
std::string ChecksumFactory::getAlgorithmDescription(const std::string& name,
                                                     const bool lookInAltNames)
{
  ChecksumAlgoId id;
  if (getAlgorithmId(id, name, lookInAltNames))
    return checksumAlgorithms[id].descr;
 
  return string();
}
//---------------------------------------------------------------------------
}  // namespace libxcks
//---------------------------------------------------------------------------