include/crypter.H

   1
   2  /*
   3   *   Copyright (C) 2007, Rus V. Brushkoff, All rights reserved.
   4   */
   5
   6 #ifndef _CRYPTER_H_
   7 #define _CRYPTER_H_
   8
   9 #include <netinet/in.h>
  10 #include <elements.H>
  11 #include <unistd.h>
  12 #include <gcrypt.h>
  13
  14 #define SFINX_HASH_BUF_SIZE  65536
  15
  16 class sfinx_hash_t {
  17   int algo;
  18   u32_t len;
  19   gcry_md_hd_t hd;
  20   gcry_error_t err;
  21   u8_t *buf;
  22   string strval;
  23   public :
  24     sfinx_hash_t(int alg) {
  25       algo = alg;
  26       len = gcry_md_get_algo_dlen(algo);
  27       err = gcry_md_open (&hd, algo, 0);
  28       if (err)
  29         throw("Can't open hash algorithm !");
  30       buf = new u8_t[SFINX_HASH_BUF_SIZE];
  31    }
  32     ~sfinx_hash_t() {
  33       delete [] buf;
  34       gcry_md_close(hd);
  35    }
  36     const char *strvalue() {
  37       char *p = (char *) gcry_md_read(hd, algo);
  38       strval.clear();
  39       for (u32_t i = 0; i < len; i++) {
  40         char b[16];
  41         sprintf(b, "%02hhx", p[i]);
  42         strval += b;
  43      }
  44       return strval.c_str();
  45    }
  46     void *value() { return gcry_md_read(hd, algo); }
  47     bool hash(const string &file) { return hash(file.c_str()); }
  48     bool hash(const char *file) {
  49       ifstream f(file, ios::in | ios::binary);
  50       if (!f) {
  51         debug("Error opening %s", file);
  52         return true;
  53      }
  54       gcry_md_reset(hd);
  55       while (!f.eof()) {
  56         f.read((char *)buf, SFINX_HASH_BUF_SIZE);
  57         if (!f.eof() && !f) {
  58           debug("Error reading %s", file);
  59           return true;
  60        }
  61         gcry_md_write(hd, buf, f.gcount());
  62       }
  63        f.close();
  64        // debug("%s", strvalue());
  65        return false;
  66    }
  67 };
  68
  69 class sfinx_crypter {
  70    u8_t header_[5 + 1 + 4]; // magic + type + next data len
  71    u8_t header_len_;
  72    u8_t type_;
  73 protected:
  74    virtual int crypt(u32_t size, u8_t **b) = 0;
  75    virtual int decrypt(u32_t size, u8_t **b) = 0;
  76  public:
  77    static bool get_random_bytes(sfinx_8bit_vector_t &buf, u32_t len) {
  78      // get some data from /dev/urandom - somewhat insecure
  79      int fd = open("/dev/urandom", O_RDONLY);
  80      if (fd < 0)
  81        return 1;
  82      u8_t byte;
  83      while (len--) {
  84        if (read(fd, &byte, 1) != 1)
  85          break;
  86        buf.add(byte);
  87     }
  88      close(fd);
  89      return len;
  90    }
  91    sfinx_crypter(u8_t t) {
  92      strcpy((char *)header_, SFINX_PACKET_MAGIC);
  93      header_[5] = type_ = t;
  94      header_len_ = 6;
  95   }
  96    virtual ~sfinx_crypter() { }
  97    u8_t type() { return type_; }
  98    u8_t header_len() { return header_len_; }
  99    u8_t *header() { return header_; }
 100    bool decrypt(sfinx_elements &buf) { return false; }
 101    bool crypt(sfinx_elements &buf) {
 102      // set header len
 103      header_len_ = 6;
 104      s8_t data_size_len = -1;
 105      // crypt(buf, len);
 106      u32_t coded_data_size_be32 = buf.code(buf.size(), &data_size_len);
 107      header_len_ += data_size_len;
 108      memcpy(header_ + 6, ((u8_t *)&coded_data_size_be32) + (sizeof(u32_t) - data_size_len), data_size_len);
 109     // debug("got %d elements, %d bytes", buf.n_elements, buf.data_size_);
 110      return 0;
 111    }
 112 };
 113
 114 class sfinx_crypter_plain : public sfinx_crypter {
 115   public:
 116     sfinx_crypter_plain() : sfinx_crypter(SFINX_PACKET_PLAIN) { }
 117     int crypt(u32_t size, u8_t **b) { return 0; }
 118     int decrypt(u32_t size, u8_t **b) { return 0; }
 119 };
 120
 121 class sfinx_crypter_crc32 : public sfinx_crypter {
 122   public:
 123     sfinx_crypter_crc32() : sfinx_crypter(SFINX_PACKET_CRC32) { }
 124     int crypt(u32_t size, u8_t **b) { return 1; }
 125     int decrypt(u32_t size, u8_t **b) { return 1; }
 126 };
 127
 128 class sfinx_crypter_aes : public sfinx_crypter {
 129   public:
 130     sfinx_crypter_aes() : sfinx_crypter(SFINX_PACKET_CRYPTED_AES) { }
 131     int crypt(u32_t size, u8_t **b) { return 1; }
 132     int decrypt(u32_t size, u8_t **b) { return 1; }
 133 };
 134
 135 class sfinx_crypter_rsa : public sfinx_crypter {
 136   public:
 137     sfinx_crypter_rsa() : sfinx_crypter(SFINX_PACKET_CRYPTED_RSA) { }
 138     int crypt(u32_t size, u8_t **b) { return 1; }
 139     int decrypt(u32_t size, u8_t **b) { return 1; }
 140 };
 141
 142 #endif