DiabloHorn

//DiabloHorn - steal stuff from vmdk files
//Mainly used sample code from the VDDK itself.
//http://communities.vmware.com/thread/223740 very helpfull link.
//hosted disk = workstation stuff (reminder)
#include <windows.h>
#include <tchar.h>
#include <process.h>

#include <iostream>
#include <iomanip>
#include <sstream>
#include <string>
#include <vector>
#include <stdexcept>

//most of the vmdk functions
#include "vixDiskLib.h"
//mounting related functions , this needs the driver, so the SDK has to be installed
#include "vixMntapi.h"

#pragma comment(lib,"vixDiskLib")
#pragma comment(lib,"vixMntapi")

using std::cout;
using std::string;
using std::endl;
using std::vector;

#define VIXDISKLIB_VERSION_MAJOR 1
#define VIXDISKLIB_VERSION_MINOR 0

void getFile(const char *,char *);
void usage(char *);

static struct {
        int command;
        VixDiskLibAdapterType adapterType;
        char *diskPath;
        char *parentPath;
        char *metaKey;
        char *metaVal;
        int filler;
        unsigned mbSize;
        VixDiskLibSectorType numSectors;
        VixDiskLibSectorType startSector;
        uint32 openFlags;
        unsigned numThreads;
        Bool success;
        Bool isRemote;
        char *host;
        char *userName;
        char *password;
        int port;
        char *srcPath;
        VixDiskLibConnection connection;
        std::string vmxSpec;
        char *libdir;
        char *ssMoRef;
} appGlobals;

typedef struct {
        VixVolumeHandle volumeHandle;
        VixVolumeInfo* volInfo;
} MountedVolume;

#define THROW_ERROR(vixError) \
        throw VixDiskLibErrWrapper((vixError), __FILE__, __LINE__)

#define CHECK_AND_THROW(vixError)                                    \
        do {                                                              \
        if (VIX_FAILED((vixError))) {                                  \
        throw VixDiskLibErrWrapper((vixError), __FILE__, __LINE__); \
        }                                                              \
        } while (0)

class VixDiskLibErrWrapper
{
public:
        explicit VixDiskLibErrWrapper(VixError errCode, const char* file, int line)
                :
        _errCode(errCode),
                _file(file),
                _line(line)
        {
                char* msg = VixDiskLib_GetErrorText(errCode, NULL);
                _desc = msg;
                VixDiskLib_FreeErrorText(msg);
        }

        VixDiskLibErrWrapper(const char* description, const char* file, int line)
                :
        _errCode(VIX_E_FAIL),
                _desc(description),
                _file(file),
                _line(line)
        {
        }

        string Description() const { return _desc; }
        VixError ErrorCode() const { return _errCode; }
        string File() const { return _file; }
        int Line() const { return _line; }

private:
        VixError _errCode;
        string _desc;
        string _file;
        int _line;
};


/*
        All the stuff is done here - ugly needs fixing
        No input validation or error checking on cmd line passed arguments
*/
int main(int argc,char *argv[]){
        VixDiskLibConnectParams vxConParams = {0};
        VixDiskLibHandle diskHandle;
        VixDiskLibHandle diskHandles[1];
        VixDiskSetHandle diskSetHandle = NULL;
        size_t numVolumes = 0;
        size_t i = 0;
        VixVolumeHandle *volumeHandles = NULL;
        VixVolumeInfo *volInfo = NULL;
        std::vector<MountedVolume> mountedVolumes;
        appGlobals.openFlags = VIXDISKLIB_FLAG_OPEN_READ_ONLY;

        if(argc != 4){
                usage(argv[0]);
        }
        appGlobals.diskPath = argv[1];

        try{
                //always needed
                VixError vixError = VixDiskLib_Init(VIXDISKLIB_VERSION_MAJOR,VIXDISKLIB_VERSION_MINOR,NULL,NULL,NULL,appGlobals.libdir);
                CHECK_AND_THROW(vixError);
                vixError = VixMntapi_Init(VIXDISKLIB_VERSION_MAJOR,VIXDISKLIB_VERSION_MINOR,NULL,NULL,NULL,NULL,NULL);
                CHECK_AND_THROW(vixError);
                vixError = VixDiskLib_Connect(&vxConParams,&appGlobals.connection);
                CHECK_AND_THROW(vixError);

                //open the disks you want to mount.
                vixError = VixDiskLib_Open(appGlobals.connection,appGlobals.diskPath,appGlobals.openFlags,&diskHandle);
                CHECK_AND_THROW(vixError);
                diskHandles[0] = diskHandle;
                //open them all at ones
                vixError = VixMntapi_OpenDiskSet(diskHandles,1,appGlobals.openFlags,&diskSetHandle);
                CHECK_AND_THROW(vixError);
                vixError = VixMntapi_GetVolumeHandles(diskSetHandle,&numVolumes,&volumeHandles);
                CHECK_AND_THROW(vixError);
                printf("Num Volumes %d\n", numVolumes);

                volInfo = NULL;
                for (i = 0; i < numVolumes; ++i) {
                        MountedVolume newVolume = {0, 0};

                        vixError = VixMntapi_MountVolume(volumeHandles[i], TRUE);
                        CHECK_AND_THROW(vixError);

                        vixError = VixMntapi_GetVolumeInfo(volumeHandles[i], &newVolume.volInfo);
                        CHECK_AND_THROW(vixError);

                        printf("\nMounted Volume %d, Type %d, isMounted %d, symLink %s, numGuestMountPoints %d (%s)\n\n",
                                i, newVolume.volInfo->type, newVolume.volInfo->isMounted,
                                newVolume.volInfo->symbolicLink == NULL ? "<null>" : newVolume.volInfo->symbolicLink,
                                newVolume.volInfo->numGuestMountPoints,
                                (newVolume.volInfo->numGuestMountPoints == 1) ? (newVolume.volInfo->inGuestMountPoints[0]) : "<null>" );

                        string bootPath = newVolume.volInfo->symbolicLink;
                        bootPath += argv[3];
                        bootPath += argv[2];
                        cout << bootPath.c_str() << endl;
                        getFile(bootPath.c_str(),argv[2]);

                        VixMntapi_FreeVolumeInfo(newVolume.volInfo);
                }

                //cleanup stuff

                std::vector<MountedVolume>::const_iterator iter = mountedVolumes.begin();
                for (; iter != mountedVolumes.end(); ++iter) {
                        VixMntapi_FreeVolumeInfo((*iter).volInfo);
                        VixMntapi_DismountVolume((*iter).volumeHandle, TRUE);
                }
                if (volumeHandles) {
                        VixMntapi_FreeVolumeHandles(volumeHandles);
                }
                if (appGlobals.connection != NULL) {
                        VixDiskLib_Disconnect(appGlobals.connection);
                }

                VixDiskLib_Exit();
                free(vxConParams.vmxSpec);
        }catch(const VixDiskLibErrWrapper& e) {
                cout << "Error: [" << e.File() << ":" << e.Line() << "]  " <<
                        std::hex << e.ErrorCode() << " " << e.Description() << "\n";
        }
        return 0;
}

/*
        Overwrites existing files...so be carefull :)
        Drops files in the current directory
*/
void getFile(const char *oFile,char *nFile){
        if(CopyFile(oFile,nFile,FALSE)){
                cout << "copy succeeded\n";
        }else{
                cout << GetLastError() << endl;
        }
}

/*
        Usual print usage stuff
*/
void usage(char *appName){
        cout << "DiabloHorn - alpha poc" << endl;
        cout << "Steal stuff from vmdk files" << endl;
        cout << appName << " <vmdk> <filetosteal> <pathoftostealfile>" << endl;
        cout << "Ex: " << appName << " c:\\stuf.vmdk boot.ini \"\"";
        exit(0);
}