encryption_tentacle.cpp

Go to the documentation of this file.

#ifndef ENCRYPTION_TENTACLE_IMPLEMENTATION_FILE
#define ENCRYPTION_TENTACLE_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : encryption_tentacle                                               *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 2004-$now By Author.  This program is free software; you can  *
* redistribute it and/or modify it under the terms of the GNU General Public  *
* License as published by the Free Software Foundation; either version 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#ifndef OMIT_CRYPTO_SUPPORT

#include "encryption_tentacle.h"
#include "encryption_wrapper.h"
#include "key_repository.h"

#include <basis/auto_synch.h>
#include <basis/log_base.h>
#include <crypto/blowfish_crypto.h>
#include <crypto/rsa_crypto.h>
#include <data_struct/symbol_table.cpp>
#include <textual/byte_format.h>

#undef LOG
#define LOG(s) CLASS_EMERGENCY_LOG(program_wide_logger(), s)

#define DEBUG_ENCRYPTION_TENTACLE
  // uncomment for noisier code.


encryption_tentacle::encryption_tentacle()
: tentacle_helper<encryption_infoton>
    (encryption_infoton::encryption_classifier(), false),
  _server_side(true),
  _keys(new key_repository),
  _rsa_private(NIL)
{
}

encryption_tentacle::encryption_tentacle(const byte_array &private_key)
: tentacle_helper<encryption_infoton>
    (encryption_infoton::encryption_classifier(), false),
  _server_side(false),
  _keys(new key_repository),
  _rsa_private(new RSA_crypto(private_key))
{
}

encryption_tentacle::encryption_tentacle(int key_size)
: tentacle_helper<encryption_infoton>
    (encryption_infoton::encryption_classifier(), false),
  _server_side(false),
  _keys(new key_repository),
  _rsa_private(new RSA_crypto(key_size))
{
}

encryption_tentacle::~encryption_tentacle()
{
  WHACK(_rsa_private);
  WHACK(_keys);
}

key_repository &encryption_tentacle::keys() const { return *_keys; }

const RSA_crypto &encryption_tentacle::private_key() const
{ return *_rsa_private; }

outcome encryption_tentacle::reconstitute(const string_array &classifier,
    byte_array &packed_form, infoton * &reformed)
{
  if (classifier != encryption_infoton::encryption_classifier()) 
    return NO_HANDLER;

  return reconstituter(classifier, packed_form, reformed,
      (encryption_infoton *)NIL);
}

void encryption_tentacle::expunge(const octopus_entity &formal(to_remove))
{
//we need a better approach.  it seems there are places where an entity
//can get reused and it still expects its key to be present.
}

outcome encryption_tentacle::consume(infoton &to_chow,
    const octopus_request_id &item_id, byte_array &transformed)
{
  FUNCDEF("consume");
  transformed.reset();
  encryption_infoton *inf = dynamic_cast<encryption_infoton *>(&to_chow);
  if (!inf) {
    // this package is not explicitly an encryption infoton.  we need to
    // decrypt it using what we already know.

    encryption_wrapper *wrap = dynamic_cast<encryption_wrapper *>(&to_chow);
    if (!wrap) {
#ifdef DEBUG_ENCRYPTION_TENTACLE
//      LOG(istring("got a stray infoton that was not encrypted: ")
//          + to_chow.text_form());
#endif
      // this signals that we were expecting an encrypted package.
      return ENCRYPTION_MISMATCH;
    }

    octenc_key_record record;
    octenc_key_record *rec = _keys->lock(item_id._entity);
    if (!rec) {
#ifdef DEBUG_ENCRYPTION_TENTACLE
      LOG(istring("no key stored for entity ")
          + item_id._entity.mangled_form()
          + "; rejecting packet.");
#endif
      return DISALLOWED;
    }
    record = *rec;
    _keys->unlock(rec);

    byte_array decro;
    bool decrypts_properly = record._key.decrypt(wrap->_wrapped, decro);
    if (decrypts_properly) {
      // this package seems to be intact.  we need to reconstitute the
      // original infoton.
      transformed = decro;  // set the decrypted blob.
      return PARTIAL;
    }

#ifdef DEBUG_ENCRYPTION_TENTACLE
    LOG(istring("denying client ") + item_id._entity.mangled_form()
        + " due to erroneous decryption");
#endif

    // the infoton's client is not authorized; it needs to be dropped.
    return DISALLOWED;
  }

  // reaching here means this is explicitly an encryption startup request.

  if (!_server_side) {
    // client's side must track the key we were given for decryption.  we'll
    // use that from now on.
    blowfish_crypto new_key(blowfish_crypto::minimum_key_size());  // bogus.
    outcome ret = inf->extract_response(*_rsa_private, new_key);
    if (ret != OKAY) {
#ifdef DEBUG_ENCRYPTION_TENTACLE
      LOG(istring("client failed to process encrypted blowfish key for ")
          + item_id._entity.mangled_form());
#endif
    } else {
      _keys->add(item_id._entity, new_key);  // add our key for this guy.
    }
    // we do not store a copy of the infoton; it's just done now.
    return ret;
  } else {
    // server's side need to process a key request and send it back using
    // the public key the requester provided.
    blowfish_crypto agreed_key(blowfish_crypto::minimum_key_size());
      // initialized with junk.
    outcome worked = inf->prepare_blowfish_key(agreed_key);
    if (worked != OKAY) {
#ifdef DEBUG_ENCRYPTION_TENTACLE
      LOG(istring("server failed to encrypt blowfish key for ")
          + item_id._entity.mangled_form());
#endif
    } else {
      _keys->add(item_id._entity, agreed_key);  // add our key for this guy.
    }
  }

  if (!store_product((infoton *)inf->clone(), item_id))
    return NO_SPACE;
  return OKAY;
}

#endif  // crypto support.


#endif //ENCRYPTION_TENTACLE_IMPLEMENTATION_FILE

---