lookup.cpp

含有多种公开密钥算法、多种块加密、多种数据流加密、多种HASH函数、多种CheckSum校验、多种MAC校验等几十种加密算法的程序

/* This file is in the public domain */

#include <botan/filters.h>
#include <botan/cbc.h>
#include <botan/cts.h>
#include <botan/cfb.h>
#include <botan/ofb.h>
#include <botan/ctr.h>

#ifdef BOTAN_EXT_COMPRESSOR_BZIP2
#include <botan/bzip2.h>
#endif

#ifdef BOTAN_EXT_COMPRESSOR_GZIP
#include <botan/gzip.h>
#endif

#ifdef BOTAN_EXT_COMPRESSOR_ZLIB
#include <botan/zlib.h>
#endif

using namespace Botan;

Filter* lookup_block(const std::string&, const std::string&);
Filter* lookup_mode(const std::string&, const std::string&,
                    const std::string&);
Filter* lookup_stream(const std::string&, const std::string&);
Filter* lookup_hash(const std::string&);
Filter* lookup_mac(const std::string&, const std::string&);
Filter* lookup_rng(const std::string&);
Filter* lookup_encoder(const std::string&);
Filter* lookup_s2k(const std::string&, const std::string&);

Filter* lookup(const std::string& algname, const std::string& key,
               const std::string& iv)
   {
   Filter* filter;

   filter = lookup_mode(algname, key, iv);
   if(filter) return filter;

   filter = lookup_rng(algname);
   if(filter) return filter;

   filter = lookup_encoder(algname);
   if(filter) return filter;

   filter = lookup_s2k(algname, key);
   if(filter) return filter;

   filter = lookup_block(algname, key);
   if(filter) return filter;

   filter = lookup_stream(algname, key);
   if(filter) return filter;

   filter = lookup_hash(algname);
   if(filter) return filter;

   filter = lookup_mac(algname, key);
   if(filter) return filter;

   return 0;
   }

// Lookup should be able to do all of this name->Filter mapping for us someday,
// but probably not before 1.1.x
Filter* lookup_hash(const std::string& algname)
   {
   Filter* hash = 0;

   try {
      hash = new Hash_Filter(algname);
   }
   catch(Algorithm_Not_Found) {}

   return hash;
   }

Filter* lookup_mac(const std::string& algname, const std::string& key)
   {
   Filter* mac = 0;
   try {
      mac = new MAC_Filter(algname, key);
   }
   catch(Algorithm_Not_Found) {}

   return mac;
   }

Filter* lookup_stream(const std::string& algname, const std::string& key)
   {
   Filter* sc = 0;

   try {
      sc = new StreamCipher_Filter(algname, key);
   }
   catch(Algorithm_Not_Found) {}

   return sc;
   }

Filter* lookup_mode(const std::string& algname, const std::string& key,
                    const std::string& iv)
   {
   std::vector<std::string> name = parse_algorithm_name(algname);
   if(name.size() == 0)
      return 0;

   const std::string mode_name = name[0];

   if(mode_name == "CBC_Encryption" || mode_name == "CBC_Decryption")
      {
      if(name.size() != 3)
         throw Invalid_Algorithm_Name(algname);
      if(mode_name == "CBC_Encryption")
         return new CBC_Encryption(name[1], name[2], key, iv);
      else
         return new CBC_Decryption(name[1], name[2], key, iv);
      }

   if(mode_name == "CTS_Encryption" || mode_name == "CTS_Decryption")
      {
      if(name.size() != 2)
         throw Invalid_Algorithm_Name(algname);
      if(mode_name == "CTS_Encryption")
         return new CTS_Encryption(name[1], key, iv);
      else
         return new CTS_Decryption(name[1], key, iv);
      }

   if(mode_name == "CFB_Encryption" || mode_name == "CFB_Decryption")
      {
      if(name.size() != 3)
         throw Invalid_Algorithm_Name(algname);
      if(mode_name == "CFB_Encryption")
         return new CFB_Encryption(name[1], key, iv, to_u32bit(name[2]));
      else
         return new CFB_Decryption(name[1], key, iv, to_u32bit(name[2]));
      }

   if(mode_name == "OFB" || mode_name == "CTR")
      {
      if(name.size() != 2)
         throw Invalid_Algorithm_Name(algname);
      if(mode_name == "OFB")
         return new OFB(name[1], key, iv);
      else
         return new CTR(name[1], key, iv);
      }
   return 0;
   }

Filter* lookup_encoder(const std::string& algname)
   {
   if(algname == "Base64_Encode")
      return new Base64_Encoder;
   if(algname == "Base64_Decode")
      return new Base64_Decoder;

#ifdef BOTAN_EXT_COMPRESSOR_BZIP2
   if(algname == "Bzip_Compress")
      return new Bzip_Compress(9);
   if(algname == "Bzip_Decompress")
      return new Bzip_Decompress;
#endif

#ifdef BOTAN_EXT_COMPRESSOR_GZIP
   if(algname == "Gzip_Compress")
      return new Gzip_Compress(9);
   if(algname == "Gzip_Decompress")
      return new Gzip_Decompress;
#endif

#ifdef BOTAN_EXT_COMPRESSOR_ZLIB
   if(algname == "Zlib_Compress")
      return new Zlib_Compress(9);
   if(algname == "Zlib_Decompress")
      return new Zlib_Decompress;
#endif

   return 0;
   }