~ubuntu-branches/ubuntu/trusty/arc-gui-clients/trusty

#include <fstream>

#include <string>

#include <map>

#include <stdexcept>

#include <unistd.h>

#include <stdlib.h>

#include <glibmm.h>

#include <unistd.h>

 

#include <arc/ArcLocation.h>

#include <arc/DateTime.h>

#include <arc/delegation/DelegationInterface.h>

#include <arc/User.h>

#include <arc/Utils.h>

#include <arc/UserConfig.h>

#include <arc/client/ClientInterface.h>

#include <arc/credential/VOMSAttribute.h>

#include <arc/credential/VOMSUtil.h>

#include <arc/credential/Credential.h>

#include <QStyle>

#include <QDesktopWidget>

 

#include "proxywindow.h"

 

#undef HAVE_NSS

#include <arc/credential/NSSUtil.h>

#endif

 

VomsListEntry::VomsListEntry()

{

    m_alias = "";

    QStringList vomsPaths;

 

    vomsPaths << QDir::homePath() + "/.arc/vomses";

 

    this->clear();

 

                    strippedFields.append(fields[j].replace("\"", ""));

                }

 

                VomsListEntry* entry = new VomsListEntry();

                entry->setAlias(strippedFields[0]);

                entry->setMachine(strippedFields[1]);

            vomsFile.close();

        }

    }

}

 

VomsListEntry* VomsList::at(int idx)

    return m_vomsList.count();

}

 

 

using namespace ArcCredential;

 

ArcProxyController::ArcProxyController()

    :logger(Arc::Logger::getRootLogger(), "arcproxy"), logCerr(std::cerr)

{

    setlocale(LC_ALL, "");

 

 

 

    // This ensure command line args overwrite all other options

 

    m_proxyWindow = 0;

    m_application = 0;

 

void ArcProxyController::setUseGSIProxy(bool flag)

{

}

 

bool ArcProxyController::getUseGSIProxy()

{

 

ArcProxyController::TCertStatus ArcProxyController::checkCert()

{

    Arc::ArcLocation::Init("");

 

                            Arc::initializeCredentialsType(Arc::initializeCredentialsType::TryCredentials));

    if (!usercfg) {

        return CS_INVALID_CONFIG;

    // Check for needed credentials objects

    // Can proxy be used for? Could not find it in documentation.

    // Key and certificate not needed if only printing proxy information

        return CS_NOT_FOUND;

    }

        // For external communication CAs are needed

        if(usercfg.CACertificatesDirectory().empty()) {

            logger.msg(Arc::ERROR, "Failed to find CA certificates");

    return m_uiReturnStatus;

}

 

{

    this->showProxyUI();

}

 

 

int ArcProxyController::initialize()

{

    logCerr.setFormat(Arc::ShortFormat);

 

    Arc::ArcLocation::Init("");

 

#ifdef HAVE_NSS

    //Using nss db dominate other option

        std::string nssdb_path = get_nssdb_path();

        if(nssdb_path.empty()) {

            std::cout << Arc::IString("The nss db can not be detected under firefox profile") << std::endl;

        res = AuthN::nssInit(configdir);

        std::cout<< Arc::IString("nss db to be accesses: %s\n", configdir.c_str());

 

        //The nss db under firefox profile seems to not be protected by any passphrase by default

        bool ascii = true;

        const char* trusts = "p,p,p";

        proxy_cred_str.append(proxy_privk_str).append(eec_cert_str);

        write_proxy_file(proxy_path, proxy_cred_str);

 

        return EXIT_SUCCESS;

    }

#endif

 

    // If debug is specified as argument, it should be set before loading the configuration.

 

 

    // Set default, predefined or guessed credentials. Also check if they exist.

                            Arc::initializeCredentialsType(Arc::initializeCredentialsType::TryCredentials));

    if (!usercfg) {

        logger.msg(Arc::ERROR, "Failed configuration initialization.");

    // Check for needed credentials objects

    // Can proxy be used for? Could not find it in documentation.

    // Key and certificate not needed if only printing proxy information

        logger.msg(Arc::ERROR, "Failed to find certificate and/or private key or files have improper permissions or ownership.");

        logger.msg(Arc::ERROR, "You may try to increase verbosity to get more information.");

        return EXIT_FAILURE;

    }

        // For external communication CAs are needed

        if(usercfg.CACertificatesDirectory().empty()) {

            logger.msg(Arc::ERROR, "Failed to find CA certificates");

    // By running credentials initialization once more all set values

    // won't change. But proxy will get default value if not set.

    {

                               Arc::initializeCredentialsType(Arc::initializeCredentialsType::NotTryCredentials));

    }

    // Get back all paths

 

        Arc::Logger::getRootLogger().setThreshold(Arc::string_to_level(usercfg.Verbosity()));

 

}

 

QString ArcProxyController::getIdentity()

{

    QString identity;

 

 

    identity = cred.GetDN().c_str();

    return identity;

    out << "validityPeriod=" << seconds;

    constraintString = out.str();

 

}

 

ArcProxyController::TProxyStatus ArcProxyController::checkProxy()

{

    const Arc::Time now;

 

        return PS_PATH_EMPTY;

    }

        return PS_NOT_FOUND;

    }

 

 

    if (holder.GetEndTime() < now)

    {

int ArcProxyController::printInformation()

{

    const Arc::Time now;

    std::vector<Arc::VOMSACInfo> voms_attributes;

    bool res = false;

 

        logger.msg(Arc::ERROR, "Cannot find the path of the proxy file, "

                   "please setup environment X509_USER_PROXY, "

                   "or proxypath in a configuration file");

        return EXIT_FAILURE;

    }

        logger.msg(Arc::ERROR, "Cannot find file at %s for getting the proxy. "

        return EXIT_FAILURE;

    }

 

    std::cout << Arc::IString("Subject: %s", holder.GetDN()) << std::endl;

    std::cout << Arc::IString("Issuer: %s", holder.GetIssuerName()) << std::endl;

    std::cout << Arc::IString("Identity: %s", holder.GetIdentityName()) << std::endl;

        std::cout << Arc::IString("Time left for proxy: Proxy not valid yet") << std::endl;

    else

        std::cout << Arc::IString("Time left for proxy: %s", (holder.GetEndTime() - now).istr()) << std::endl;

    std::cout << Arc::IString("Proxy type: %s", certTypeToString(holder.GetType())) << std::endl;

 

    Arc::VOMSTrustList voms_trust_dn;

    voms_trust_dn.AddRegex(".*");

    // Not printing error message because parseVOMSAC will print everything itself

    //if (!res) logger.msg(Arc::ERROR, "VOMS attribute parsing failed");

    for(int n = 0; n<voms_attributes.size(); ++n) {

 

int ArcProxyController::removeProxy()

{

        logger.msg(Arc::ERROR, "Cannot find the path of the proxy file, "

                   "please setup environment X509_USER_PROXY, "

                   "or proxypath in a configuration file");

        return EXIT_FAILURE;

        return EXIT_FAILURE;

    }

        return EXIT_FAILURE;

    }

    return EXIT_SUCCESS;

 

int ArcProxyController::generateProxy()

{

 

    const Arc::Time now;

 

            logger.msg(Arc::ERROR, "Cannot find the user certificate path, "

                       "please setup environment X509_USER_CERT, "

                       "or certificatepath in a configuration file");

            logger.msg(Arc::ERROR, "Cannot find the user private key path, "

                       "please setup environment X509_USER_KEY, "

                       "or keypath in a configuration file");

        return EXIT_FAILURE;

    }

 

    std::map<std::string, std::string> constraints;

        std::string::size_type pos = it->find('=');

        if (pos != std::string::npos)

            constraints[it->substr(0, pos)] = it->substr(pos + 1);

    // TODO: Is default validityPeriod since now or since validityStart?

    Arc::Time validityStart = now; // now by default

    Arc::Period validityPeriod(12*60*60);

        //For myproxy PUT operation, the proxy should be 7 days according to the default

        //definition in myproxy implementation.

        validityPeriod = 7*24*60*60;

    //information about the existence of stored credentials

    //on the myproxy server.

    try {

                throw std::invalid_argument("URL of MyProxy server is missing");

 

                std::string cert_dn = proxy_cred.GetIdentityName();

            }

                throw std::invalid_argument("Username to MyProxy server is missing");

 

            std::string respinfo;

 

            //if(usercfg.CertificatePath().empty()) usercfg.CertificatePath(cert_path);

            //if(usercfg.KeyPath().empty()) usercfg.KeyPath(key_path);

            else {

            }

 

            std::map<std::string,std::string> myproxyopt;

            if(!cstore.Info(myproxyopt,respinfo))

                throw std::invalid_argument("Failed to get info from MyProxy service");

 

    //information about the existence of stored credentials

    //on the myproxy server.

    try {

                throw std::invalid_argument("URL of MyProxy server is missing");

 

                std::string cert_dn = proxy_cred.GetIdentityName();

            }

                throw std::invalid_argument("Username to MyProxy server is missing");

 

            std::string prompt1 = "MyProxy server";

                throw std::invalid_argument("Error entering passphrase");

            newpassphrase = newpassword;

 

            else {

            }

 

            std::map<std::string,std::string> myproxyopt;

            myproxyopt["password"] = passphrase;

            myproxyopt["newpassword"] = newpassphrase;

            if(!cstore.ChangePassword(myproxyopt))

    //information about the existence of stored credentials

    //on the myproxy server.

    try {

                throw std::invalid_argument("URL of MyProxy server is missing");

 

                std::string cert_dn = proxy_cred.GetIdentityName();

            }

                throw std::invalid_argument("Username to MyProxy server is missing");

 

            std::string prompt1 = "MyProxy server";

 

            std::string respinfo;

 

            else {

            }

 

            std::map<std::string,std::string> myproxyopt;

            myproxyopt["password"] = passphrase;

            if(!cstore.Destroy(myproxyopt))

                throw std::invalid_argument("Failed to destroy credential on MyProxy service");

    //For "GET" command, certificate and key are not needed, and

    //anonymous GSSAPI is used (GSS_C_ANON_FLAG)

    try {

                throw std::invalid_argument("URL of MyProxy server is missing");

 

                std::string cert_dn = proxy_cred.GetIdentityName();

            }

                throw std::invalid_argument("Username to MyProxy server is missing");

 

            std::string prompt1 = "MyProxy server";

            char password[256];

 

            std::string passphrase = password;

                int res = input_password(password, 256, false, prompt1, "", logger);

                if (!res)

                    throw std::invalid_argument("Error entering passphrase");

 

            std::string proxy_cred_str_pem;

 

            usercfg_tmp.CACertificatesDirectory(usercfg.CACertificatesDirectory());

 

            std::map<std::string,std::string> myproxyopt;

            myproxyopt["password"] = passphrase;

            myproxyopt["lifetime"] = myproxy_period;

            if(!cstore.Retrieve(myproxyopt,proxy_cred_str_pem))

                throw std::invalid_argument("Failed to retrieve proxy from MyProxy service");

 

            //Assign proxy_path to cert_path and key_path,

            //so the later voms functionality can use the proxy_path

            //to create proxy with voms AC extension. In this

            //case, "--cert" and "--key" is not needed.

 

            return EXIT_SUCCESS;

        }

        proxy_period.SetPeriod(proxy_period.GetPeriod() + 300);

    }

 

    //Create proxy or voms proxy

    try {

        if (signer.GetIdentityName().empty()) {

            std::cerr << Arc::IString("Proxy generation failed: No valid certificate found.") << std::endl;

            return EXIT_FAILURE;

        }

        EVP_PKEY* pkey = signer.GetPrivKey();

        if(!pkey) {

            std::cerr << Arc::IString("Proxy generation failed: No valid private key found.") << std::endl;

            return EXIT_FAILURE;

        }

        if(pkey) EVP_PKEY_free(pkey);

        std::cout << Arc::IString("Your identity: %s", signer.GetIdentityName()) << std::endl;

        if (now > signer.GetEndTime()) {

            std::cerr << Arc::IString("Proxy generation failed: Certificate has expired.") << std::endl;

        signer.OutputCertificate(signing_cert);

        signer.OutputCertificateChain(signing_cert_chain);

 

 

            //Generate a temporary self-signed proxy certificate

            //to contact the voms server

            if (!signer.SignRequest(&cred_request, proxy_cert))

                throw std::runtime_error("Failed to sign proxy");

            proxy_cert.append(private_key).append(signing_cert).append(signing_cert_chain);

 

            //Parse the voms server and command from command line

            std::multimap<std::string, std::string> server_command_map;

                size_t p;

                std::string voms_server;

                std::string command;

 

            //Parse the 'vomses' file to find configure lines corresponding to

            //the information from the command line

                logger.msg(Arc::ERROR, "$X509_VOMS_FILE, and $X509_VOMSES are not set;\nUser has not specify the location for vomses information;\nThere is also not vomses location information in user's configuration file;\nCannot find vomses in default locations: ~/.arc/vomses, ~/.voms/vomses, $ARC_LOCATION/etc/vomses, $ARC_LOCATION/etc/grid-security/vomses, $PWD/vomses, /etc/vomses, /etc/grid-security/vomses, and the location at the corresponding sub-directory");

                return EXIT_FAILURE;

            }

            //'vomses/extra/myprivatevo', 'vomses/mypublicvo'

            std::vector<std::string> vomses_files;

            //If the location is a file

            //If the locaton is a directory, all the files and directories will be scanned

            //to find the vomses information. The scanning will not stop until all of the

            //files and directories are all scanned.

            else {

                std::vector<std::string> files;

                if(!files.empty())vomses_files.insert(vomses_files.end(), files.begin(), files.end());

                files.clear();

            }

            ArcCredential::AC **aclist = NULL;

            std::string acorder;

            Arc::MCCConfig cfg;

 

            for (std::map<std::string, std::vector<std::vector<std::string> > >::iterator it = matched_voms_line.begin();

                 it != matched_voms_line.end(); it++) {

                    }

 

                    std::string ordering;

                    }

                    logger.msg(Arc::VERBOSE, "Try to get attribute from VOMS server with order: %s", ordering);

                    send_msg.append("<order>").append(ordering).append("</order>");

                    send_msg.append("<lifetime>").append(voms_period).append("</lifetime></voms>");

                    logger.msg(Arc::VERBOSE, "Message sent to VOMS server %s is: %s", voms_name, send_msg);

 

                    std::string ret_str;

                    Arc::XMLNode(ret_str).Exchange(node);

                    if((!node) || ((bool)(node["error"]))) {

                        if((bool)(node["error"])) {

                        //logger.msg(Arc::INFO, "The attribute information from voms server: %s is list as following:\n%s",

                        //           voms_server, decodedac);

                        std::cout << Arc::IString("The attribute information from VOMS server: %s is list as following:", voms_server) << std::endl << decodedac << std::endl;

                        return EXIT_SUCCESS;

                    }

 

                    Arc::addVOMSAC(aclist, acorder, decodedac);

                    succeeded = true; break;

                }//end of the scanning of multiple vomses lines with the same name

                cred_request.AddExtension("order", acorder);

        }

 

            if(!policy.empty()) {

                cred_request.SetProxyPolicy("rfc", "anylanguage", policy, -1);

            } else if(CERT_IS_LIMITED_PROXY(signer.GetType())) {

        proxy_cert.append(private_key).append(signing_cert).append(signing_cert_chain);

 

        //If myproxy command is "Put", then the proxy path is set to /tmp/myproxy-proxy.uid.pid

                                              + Arc::tostring(user.get_uid()) + Arc::tostring((int)(getpid())));

 

        Arc::Time left = proxy_cred.GetEndTime();

        std::cout << Arc::IString("Proxy generation succeeded") << std::endl;

        std::cout << Arc::IString("Your proxy is valid until: %s", left.str(Arc::UserTime)) << std::endl;

    //Delegate the former self-delegated credential to

    //myproxy server

    try {

                throw std::invalid_argument("URL of MyProxy server is missing");

                std::string cert_dn = proxy_cred.GetIdentityName();

            }

                throw std::invalid_argument("Username to MyProxy server is missing");

 

            std::string prompt1 = "MyProxy server";

            std::string prompt2 = "MyProxy server";

            char password[256];

            std::string passphrase;

                int res = input_password(password, 256, true, prompt1, prompt2, logger);

                if (!res)

                    throw std::invalid_argument("Error entering passphrase");

            }

 

            std::string proxy_cred_str_pem;

            if(!proxy_cred_file)

            std::getline(proxy_cred_file,proxy_cred_str_pem,'\0');

            if(proxy_cred_str_pem.empty())

            proxy_cred_file.close();

 

 

            std::map<std::string,std::string> myproxyopt;

            myproxyopt["password"] = passphrase;

            myproxyopt["lifetime"] = myproxy_period;

            }

            if(!cstore.Store(myproxyopt,proxy_cred_str_pem,true,proxy_start,proxy_period))

                throw std::invalid_argument("Failed to delegate proxy to MyProxy service");

 

 

            std::cout << Arc::IString("Succeeded to put a proxy onto MyProxy server") << std::endl;

 

    } catch (std::exception& err) {

        logger.msg(Arc::ERROR, err.what());

        tls_process_error(logger);

        return EXIT_FAILURE;

    }

 

    return EXIT_SUCCESS;

}