malware_samples/malwareenumsample/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 <string>
#include <vector>
#include <iostream>
#include <fstream>
#include <ctime>
 
#include "dca/dca_base.h"
#include "dca/dca_malware_classification.h"
#include "dca/dca_callbacks.h"
 
using namespace dca;
using namespace dca_malware;
 
const std::string S_ToolName = "malwareenumsample";
const std::string S_ToolVersion = "1.2";
 
const std::string S_UsageString =
        "<redist-folder> <ticket> <product> [<locale>]\n"
        "  redist-folder - the folder where the DCA is installed\n"
        "  ticket - a valid ticket\n"
        "  product - the product associated with your ticket\n"
        "  locale - optional locale for the Malware category info names and descriptions, default = en_US\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& strRedistFolder,
                                                   InitData& aInitData )
{
        aInitData.binDir        = strRedistFolder + DCA_BINDIR;
        aInitData.initDir       = strRedistFolder + DCA_INITDIR;
        aInitData.logDir        = DCA_LOGDIR;
}
 
static void SetupLicense( const std::string& strTicket,
                                                  const std::string& strProduct,
                                                  LicenseData& aLicenseData )
{
        aLicenseData.ticket             = strTicket;
        aLicenseData.product    = strProduct;
}
 
static void PrintLicenseInfo( const License& aLicense )
{
        const time_t expirationDate = aLicense.getExpirationDate();
        struct tm *expirationTime = localtime( &expirationDate );
 
        std::cout << "License Info:" << std::endl;
        std::cout << "  DCA is " << ( aLicense.isLicensed() ? "licensed." : 
                "not licensed." ) << std::endl;
        std::cout << "  MaxUsers:" << aLicense.getMaxUsers() << 
                std::endl;
        std::cout << "  MaxSessions:" << aLicense.getMaxSessions() << 
                std::endl;
        std::cout << "  Ticket:" << aLicense.getTicket() << 
                std::endl;
        std::cout << "  Session:" << aLicense.getSession() << 
                std::endl;
        std::cout << "  Last Message:" << aLicense.getLastMessage() << 
                std::endl;
        std::cout << "  Expiration Date:" << asctime( expirationTime ) << 
                std::endl;
}
 
static void PrintToolHeader()
{
        std::cout << "IBM DCA Sample: " << S_ToolName << " (" << S_ToolVersion << ")" << std::endl;
}
 
static void PrintUsage( const char *pSampleName )
{
        std::cout << pSampleName << " usage:" << std::endl;
        std::cout << S_UsageString << std::endl;
}
 
void PrintLocale( const MalwareLocale& aMalwareLocale,
                                  const std::string& strIndent = "" )
{
        std::cout << strIndent << "\tMalwareLocale '" << aMalwareLocale.languageId() <<
                "' (displayName=" << aMalwareLocale.displayName() << ")" << std::endl;
}
 
void EnumLocales( const MalwareLocales& aMalwareLocales )
{
        const DCA_SIZE_TYPE numOfLocales = aMalwareLocales.size();
        if( numOfLocales > 0 ) {
                std::cout << std::endl << "MalwareLocales (size=" << numOfLocales << ")" << std::endl;
                for( DCA_INDEX_TYPE i = 0; i < numOfLocales; ++i ) {
                        const MalwareLocale myMalwareLocale = aMalwareLocales[ i ];
                        PrintLocale( myMalwareLocale, "\t" );
                }
        }
        else std::cout << std::endl;
}
 
void PrintEnum( const MalwareEnum& aMalwareEnum,
                            const std::string& strLocale,
                                const std::string& strIndent = "" )
{
        std::cout << strIndent << "MalwareEnum: '" << aMalwareEnum.name( strLocale )
                << "' (id=" << aMalwareEnum.id() << ")" << std::endl;
}
 
void EnumCategoryEnums( const MalwareCategoriesInfo& aMalwareCategoriesInfo,
                                            const MalwareCategory& aMalwareCategory,
                                                const std::string& strLocale )
{
        const DCA_INDEX_TYPE maxEnumsToDisplay = 5;
 
        DCA_SIZE_TYPE numOfEnums = aMalwareCategory.enumsSize();
        if( numOfEnums > 0 ) {
                const MalwareEnums myMalwareEnums = aMalwareCategoriesInfo.getEnums();
                std::cout << " (enumsSize=" << numOfEnums << ")" << std::endl;
 
                for( DCA_INDEX_TYPE i = 0; i < numOfEnums; i++ ) {
                        // if too many items to display shorten output and display only the last one
                        if( i > maxEnumsToDisplay && numOfEnums > maxEnumsToDisplay ) {
                                // Shorten output... and stop enumeration
                                std::cout << "\t\t ...(" << (numOfEnums - maxEnumsToDisplay - 2) <<
                                        " more)..." << std::endl;
                                // display the last enum item
                                const DCA_ENUM_ID_TYPE myLastEnumId = aMalwareCategory.enumId( numOfEnums - 1 );
                                const MalwareEnum myLastMalwareEnum = myMalwareEnums.byId( myLastEnumId );
                                PrintEnum( myLastMalwareEnum, strLocale, "\t\t" );
                                return;
                        }
                        const DCA_ENUM_ID_TYPE enumId = aMalwareCategory.enumId( i );
                        const MalwareEnum myMalwareEnum = myMalwareEnums.byId( enumId );
                        PrintEnum( myMalwareEnum, strLocale, "\t\t" );
                }
        }
        else std::cout << std::endl;
}
 
void PrintCategory( const MalwareCategory& aMalwareCategory,
                                    const std::string& strLocale,
                                        const std::string& strIndent = "" )
{
        std::cout << strIndent << "MalwareCategory: '" << aMalwareCategory.name( strLocale ) <<
                "' (id=" << aMalwareCategory.id() << ")";
}
 
void EnumCategories( const MalwareCategoriesInfo& aMalwareCategoriesInfo,
                                         const MalwareCategories& aMalwareCategories,
                                         const std::string& strLocale )
{
        const DCA_SIZE_TYPE numOfCategories = aMalwareCategories.size();
 
        if( numOfCategories > 0 ) {
                std::cout << std::endl << "MalwareCategories (size=" << numOfCategories <<
                        ")" << std::endl;
 
                for( DCA_INDEX_TYPE i = 0; i < numOfCategories; ++i ) {
                        const MalwareCategory myMalwareCategory = aMalwareCategories[ i ];
                        PrintCategory( myMalwareCategory, strLocale, "\t" );
                        EnumCategoryEnums( aMalwareCategoriesInfo, myMalwareCategory, strLocale );
                }
        }
        else std::cout << std::endl;
}
 
void EnumEnums( const MalwareEnums& aMalwareEnums,
                            const std::string& strLocale )
{
        const DCA_INDEX_TYPE maxEnumsToDisplay = 8;
        const DCA_SIZE_TYPE numOfEnums = aMalwareEnums.size();
 
        std::cout << std::endl << "MalwareEnums (size=" << numOfEnums <<
                ")" << std::endl;
 
        if( numOfEnums > 0 ) {
 
                for( DCA_INDEX_TYPE i = 0; i < numOfEnums; ++i ) {
                        // if too many items to display shorten output and display only the last one
                        if( i > maxEnumsToDisplay && numOfEnums > maxEnumsToDisplay ) {
                                // Shorten output... and stop enumeration
                                std::cout << "\t ...(" << (numOfEnums - maxEnumsToDisplay - 2) <<
                                        " more)..." << std::endl;
 
                                // display the last one
                                const MalwareEnum myLastMalwareEnum = aMalwareEnums[ numOfEnums - 1 ];
                                PrintEnum( myLastMalwareEnum, strLocale, "\t" );
                                return;
                        }
                        const MalwareEnum myMalwareEnum = aMalwareEnums[i];
                        PrintEnum( myMalwareEnum, strLocale, "\t" );
                }
        }
        else std::cout << std::endl;
}
 
void EnumMalwareCategoriesInfo( const MalwareCategoriesInfo& aMalwareCategoriesInfo,
                                                    const std::string& strLocale )
{
        std::cout << "Enumeration of all available MalwareLocale, MalwareCategory and MalwareEnum objects:"
                << std::endl;
 
        const MalwareLocales myMalwareLocales = aMalwareCategoriesInfo.getLocales();
        EnumLocales( myMalwareLocales );
 
        const MalwareCategories myMalwareCategories = aMalwareCategoriesInfo.getCategories();
        EnumCategories( aMalwareCategoriesInfo, myMalwareCategories, strLocale );
 
        const MalwareEnums myMalwareEnums = aMalwareCategoriesInfo.getEnums();
        EnumEnums( myMalwareEnums, strLocale );
}
 
int main( int argc, char *argv[] )
{
        PrintToolHeader();
 
        int rc = 5;
 
        try {
                if( argc < 4 ) {
                        PrintUsage( argv[0] );
                        return 5;
                }
 
                std::string strRedistFolder = argv[ 1 ];
                const std::string strTicket = argv[ 2 ];
                const std::string strProduct = argv[ 3 ];
                std::string strLocale = "en_US";        // Default locale
 
                if (argc > 4) {
                        strLocale = argv[4];
                }
 
                if( strRedistFolder.empty() ||
                        strTicket.empty() ||
                        strProduct.empty() )
                {
                        PrintUsage( argv[0] );
                        return 5;
                }
 
                // check for trailing fileslash - and add if necessary
                const char c = strRedistFolder[ strRedistFolder.length() - 1 ];
                if( c != '/' && c != '\\' )
                        strRedistFolder += "/";
 
                std::cout << std::endl;
 
                // init the 3rd party libraries
                InitCUrl();
                SetOpenSslCallbacks();
 
                // setup DCA directories
                InitData myInitData;
                SetupInitData( strRedistFolder, myInitData );
 
                // instantiate DCA API
                DcaInstance myDca;
                myDca = DcaInstance::create( myInitData );
 
                // setup license data
                LicenseData myLicenseData;
                SetupLicense( strTicket, strProduct, myLicenseData );
                const License myLicense = myDca.createLicense( myLicenseData );
 
                PrintLicenseInfo( myLicense );
                
                if( myLicense.isLicensed( MalwareClassification::ID ) ) {
                        // initialize the Malware Classification module and create a MalwareCategoriesInfo instance
                        const MalwareClassification myMalwareClassification = MalwareClassification::create( myDca, myLicense );
 
                        // create a Malware categories info for printing out the available locales, categories and enums
                        const MalwareCategoriesInfo myCategoriesInfo = myMalwareClassification.getCategoriesInfo();
 
                        // call enumeration routine
                        EnumMalwareCategoriesInfo( myCategoriesInfo, strLocale );
                        
                        rc = 0;
                }
        }
        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;
}