src/client/Client.h

Go to the documentation of this file.

/*
 * FADE - Secure Overlay Cloud Storage with File Assured Deletion
 * Copyright (C) 2010  Yang Tang
 *
 * 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 program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef FADE_CLIENT_H
#define FADE_CLIENT_H

#include <string>
#include <vector>
#include "LocalStorage.h"
#include "S3Storage.h"
#include "ClientConfig.h"
#include "../common/Common.h"

#ifdef FADE_EVAL
#include <sys/timeb.h>
#endif /* FADE_EVAL */

using namespace std;

static const int SECRET_LENGTH = 64;

class Client
{
        int sockfd;
        string path;
        vector<pair<string, int> > ephemerizerAddress;
        vector<Storage *> storages;
        string secretFile;
        unsigned char secret[SECRET_LENGTH];
        int ssss_threshold;
        int ssss_number;
        string cpabe_pubkey_file;
        string cpabe_privkey_file;
        Client()
                : ssss_threshold(1), ssss_number(1)
        {
        }
        ~Client()
        {
                for (vector<Storage *>::const_iterator it = storages.begin(); it != storages.end(); ++it)
                {
                        delete *it;
                }
        }
        void closeSocket() const;
        void encrypt(const string &filename, const unsigned char *key) const;
        void decrypt(const string &filename, const unsigned char *key) const;
        bool checkHMAC(const string &filename) const;
        void getFile(const string &filename, const string& ext) const;
        void putFile(const string &filename, const string& ext) const;
public:
        static Client *instance();

        string getPath() const
        {
                return path;
        }

        void setPath(const string &path)
        {
                this->path = path;
        }

        void addEphemerizerAddress(const string &address)
        {
                size_t colon = address.find(':');
                ephemerizerAddress.push_back(make_pair(address.substr(0, colon), atoi(address.substr(colon + 1).c_str())));
        }

        void addLocalStorage(const char *dir)
        {
                storages.push_back(new LocalStorage(dir));
        }

        void addS3Storage(const char *bucket)
        {
                storages.push_back(new S3Storage(bucket));
        }

        void setSecretFile(const string &secretFile)
        {
                this->secretFile = secretFile;
        }

        void setThreshold(int threshold)
        {
                ssss_threshold = threshold;
        }

        void setNumber(int number)
        {
                ssss_number = number;
        }

        string getCpabePublicKeyFile() const
        {
                return cpabe_pubkey_file;
        }

        void setCpabePublicKeyFile(const string &filename)
        {
                cpabe_pubkey_file = filename;
        }

        string getCpabePrivateKeyFile() const
        {
                return cpabe_privkey_file;
        }

        void setCpabePrivateKeyFile(const string &filename)
        {
                cpabe_privkey_file = filename;
        }

        bool upload(const string &filename, char *policyName);

        bool download(const string &filename);

        bool renew(const string &filename, const char *newPolicyName);

        bool revoke(const char *policyName);

        bool generateSecret();

        void readConfig(const char *filename)
        {
                ClientConfig::parse(filename);
        }

        void readSecret();

        unsigned int interact(const unsigned char *request, unsigned int requestLength, unsigned char *response, unsigned int responseLength, int keyManagerID = 0);
#ifdef FADE_EVAL
        timeb allStartTime, allEndTime;
        timeb fileStartTime, fileEndTime;
        timeb metaStartTime, metaEndTime;
        timeb metaStartTime2, metaEndTime2;
#endif /* FADE_EVAL */
};

#endif /* FADE_CLIENT_H */

---