malware_samples/malwaredbdownloadsample/main.cpp

/* IBM Source Code */
/* (C) Copyright IBM Corp. 2009, 2012 */
/* Licensed Materials - Property of IBM */
/* US Government Users Restricted Rights - Use duplication or disclosure restricted by GSA Schedule Contract with IBM Corp. */
 
#include <cstdlib>
#include <string>
#include <iostream>
#include <fstream>
 
#include "dca/dca_base.h"
#include "dca/dca_malware_classification.h"
#include "dca/dca_callbacks.h"
 
#include "schedule_event_subscriber.h"
 
using namespace dca;
using namespace dca_malware;
 
const std::string S_ToolName = "malwaredbdownloadsample";
const std::string S_ToolVersion = "1.2";
 
const std::string S_UsageString =
        " <redist-folder> <ticket> <product>\n"
        "  redist-folder - the folder where the DCA is installed to\n"
        "  ticket - a valid ticket\n"
        "  product - the product associated with your ticket\n\n"
        ;
 
#ifdef WIN32
#       define DCA_BINDIR               "bin/Win32"
#else
#       define DCA_BINDIR               "bin/linux"
#endif
 
#define DCA_INITDIR             "init"
 
#define DCA_LOGDIR              "./logs"
 
static void SetupInitData( const std::string& redist_folder, InitData& initData )
{
        initData.binDir = redist_folder + DCA_BINDIR;
        initData.initDir = redist_folder + DCA_INITDIR;
        initData.logDir = DCA_LOGDIR;
}
 
static void SetupLicense( const std::string& ticket, const std::string& product,
        LicenseData& licenseData )
{
        licenseData.ticket      = ticket;
        licenseData.product     = product;
}
 
static void SetupConnectionData( DbConnectionData& cData )
{
        cData.useLocalDatabase = true;
        cData.dbType = DBT_Malware;
}
 
static void PrintToolHeader()
{
        std::cout << "IBM DCA Sample: " << S_ToolName << " (" << S_ToolVersion << ")" << std::endl;
}
 
static void PrintUsage( const char *name )
{
        std::cout << "usage: " << name << S_UsageString << std::endl;
}
 
static void PrintUpdateResults( const UpdateResults& results )
{
        std::cout << "UpdateResults: size=" << results.size() << ", restartRequired="
                << ( results.restartRequired() ? "true" : "false" )
                << std::endl;
 
        if( !results.size() ) {
                std::cout << "Currently there are no updates available" << std::endl;
                return;
        }
 
        // iterate through all received updates and print out the details
        const DCA_SIZE_TYPE size = results.size();
 
        for( DCA_INDEX_TYPE i = 0; i < size; ++i ) {
                const UpdateResult result = results[i];
 
                std::cout << "Result #" << i << " id=" << result.id() << ", contentUpdated="
                        << ( result.contentUpdated() ? "true" : "false" ) << ", engineUpdated="
                        << ( result.engineUpdated() ? "true" : "false" ) << std::endl;
 
                const DCA_SIZE_TYPE numDetals = result.size();
 
                for( DCA_INDEX_TYPE j = 0; j < numDetals; ++j ) {
                        const UpdateResultDetail detail = result[j];
 
                        std::string returnMsg = "internal error";
                        if( detail.returnCode() == DCA_UPDATE_DOWNLOAD_SCHEDULED ) {
                                returnMsg = "download scheduled";
                        }
                        else if( detail.returnCode() == 0 ) {
                                returnMsg = "success";
                        }
 
                        std::cout << "  Detail #" << j << ":"
                                      << "\n    component=" << detail.component()
                                          << "\n    old version=" << detail.oldVersion()
                                          << "\n    new version=" << detail.newVersion()
                                          << "\n    available=" << ( detail.available() ? "true" : "false" )
                                          << "\n    downloaded=" << ( detail.downloaded() ? "true" : "false" )
                                          << "\n    installed=" << ( detail.installed() ? "true" : "false" )
                                          << "\n    return=" << returnMsg << std::endl;
                }
        }
}
 
static int PerformUpdateAndSchedule( const DcaInstance& myDca, const DbConnection& myDbConnection, const UpdateModule& myUpdateModule )
{
        const std::string current_db_version = myDbConnection.getDatabaseVersion();
 
        // call UpdateModule::performUpdate
        std::cout << "Start update process, paramater force is set to 'false'..." << std::endl;
        UpdateResults results;
        FunctionResult myFR = myUpdateModule.performUpdate( false, results );
        if( !myFR ) {
                // we encounter an error... print detailed error code and return
                std::cerr << "Got error from update. Details: '" << myFR.getDescription()
                        << "' (" << myFR.getReturnCode() << "). Aborting." << std::endl;
                return 1;
        }
 
        PrintUpdateResults( results );
 
        // set up an instance of MyMalwareScheduleEventSubscriber to capture and log the schedule event information
        std::cout << std::endl << "Starting schedule process..." << std::endl;
        MyMalwareScheduleEventSubscriber mySubscriber;
        myFR = myDca.schedule( &mySubscriber );
        if( !myFR ) {
                // we encounter an error... print detailed error code and return
                std::cerr << "Received error from schedule. Details: '" << myFR.getDescription()
                        << "' (" << myFR.getReturnCode() << ")." << std::endl;
                return 2;
        }
 
        const std::string new_db_version = myDbConnection.getDatabaseVersion();
 
        std::cout << "Database has been updated from version " << current_db_version << " to " << new_db_version << std::endl;
        return 0;
}
 
int main( int argc, char *argv[] )
{
        PrintToolHeader();
 
        int rc = 0;
 
        try {
 
                if( argc < 4 ) {
                        PrintUsage( argv[0] );
                        return 5;
                }
 
                std::string myRedistFolder = argv[ 1 ];
                const std::string myTicket = argv[ 2 ];
                const std::string myProduct = argv[ 3 ];
 
                if( myRedistFolder.empty() || myTicket.empty() ||
                        myProduct.empty() ) {
                        PrintUsage( argv[0] );
                        return 5;
                }
 
                // check for traling fileslash - and add if necessary
                const char c = myRedistFolder[ myRedistFolder.length() - 1 ];
                if( c != '/' && c != '\\' )
                        myRedistFolder += "/";
 
                // init the 3rd party libraries
                InitCUrl();
                SetOpenSslCallbacks();
 
                {
                        // setup DCA directories
                        InitData myInitData;
                        SetupInitData( myRedistFolder, myInitData );
 
                        // instantiate DCA API
                        DcaInstance myDca;
                        myDca = DcaInstance::create( myInitData );
 
                        // setup license data
                        LicenseData myLicenseData;
                        SetupLicense( myTicket, myProduct, myLicenseData );
                        const License myLicense = myDca.createLicense( myLicenseData );
 
                        if( !myLicense.isLicensed( UpdateModule::ID ) ) {
                                std::cout << "DCA is not licensed!" << std::endl;
                                rc = 5;
                        }
                        else {
                                // setup a signature database connection
                                DbConnectionData myDbConnectionData;
                                SetupConnectionData( myDbConnectionData );
                                const DbConnection myDbConnection = myDca.createDbConnection( myLicense, myDbConnectionData );
 
                                // initialize the Malware classification, classifier and categories info modules
                                const MalwareClassification myMalwareClassification = MalwareClassification::create( myDca, myLicense );
                                const MalwareCategoriesInfo myCategoriesInfo = myMalwareClassification.getCategoriesInfo();
                                const MalwareDbClassifier myClassifier = myMalwareClassification.createDbClassifier( myDbConnection );
                                // create the update module
                                const UpdateModule myUpdateModule = UpdateModule::create( myDca, myLicense );
 
                                // call performUpdate and schedule functions to update active components
                                rc = PerformUpdateAndSchedule( myDca, myDbConnection, myUpdateModule );
                        }
                }
        }
        catch( const ExDca& ex ) {
                std::cerr << "DCA Exception occured. Details: " <<  ex.getDescription() <<
                        " (" << ex.getReturnCode() << ")." << std::endl;
                rc = 10;
        }
        catch( const std::exception& s ) {
                std::cerr << "std::exception occured. Details: " << s.what() << "." << std::endl;
                rc = 10;
        }
        catch(...) {
                std::cerr << "Unknown exception caught." << std::endl;
                rc = 10;
        }
 
        // deinit the 3rd party libraries
        UnsetOpenSslCallbacks();
        DeinitCUrl();
 
        return rc;
}