crypto_setup.cpp

Go to the documentation of this file.

/*
**  ClanLib SDK
**  Copyright (c) 1997-2005 The ClanLib Team
**
**  This software is provided 'as-is', without any express or implied
**  warranty.  In no event will the authors be held liable for any damages
**  arising from the use of this software.
**
**  Permission is granted to anyone to use this software for any purpose,
**  including commercial applications, and to alter it and redistribute it
**  freely, subject to the following restrictions:
**
**  1. The origin of this software must not be misrepresented; you must not
**     claim that you wrote the original software. If you use this software
**     in a product, an acknowledgment in the product documentation would be
**     appreciated but is not required.
**  2. Altered source versions must be plainly marked as such, and must not be
**     misrepresented as being the original software.
**  3. This notice may not be removed or altered from any source distribution.
**
**  Note: Some of the libraries ClanLib link to may have additional
**  requirements or restrictions.
**
**  File Author(s):
**
**    Magnus Norddahl
*/

#include "precomp.h"
#include "crypto_setup.h"
#include "exception.h"
#include "string_help.h"
#include "certificate.h"
#include "private_key.h"
#include <prerr.h>
#include <nspr.h>
#include <nss.h>
#include <pk11func.h>
#include <ssl.h>

// CL_CryptoSetup Construction:

CL_CryptoSetup::CL_CryptoSetup(const CL_String &config_dir, bool read_write)
{
        if (instance != 0)
                throw CL_Exception(TEXT("Only one instance of CL_CryptoSetup allowed!"));
                
        PR_Init(PR_SYSTEM_THREAD, PR_PRIORITY_NORMAL, 1);
        PK11_SetPasswordFunc(&CL_CryptoSetup::pk11_password_func);
        
        CL_StringA config_dir_local8 = CL_StringHelp::text_to_local8(config_dir);
        
        SECStatus result = SECFailure;
        if (read_write)
                result = NSS_InitReadWrite(config_dir_local8.c_str());
        else
                result = NSS_Init(config_dir_local8.c_str());
        if (result == SECFailure)
                throw CL_Exception(TEXT("NSS_Init failed!"));
                
        // SSL_OptionSetDefault(option, on);
        result = NSS_SetDomesticPolicy();
        if (result == SECFailure)
                throw CL_Exception(TEXT("NSS_SetDomesticPolicy failed!"));
        // result = SSL_CipherPrefSetDefault(PRInt32 cipher, PRBool enabled);

        instance = this;
}

CL_CryptoSetup::~CL_CryptoSetup()
{
        instance = 0;
}

// CL_CryptoSetup Attributes:

// CL_CryptoSetup Operations:

void CL_CryptoSetup::config_server_sid_cache(
        int max_cache_entries,
        unsigned int timeout,
        unsigned int ssl3_timeout,
        const CL_String &directory)
{
        SECStatus result = SSL_ConfigServerSessionIDCache(
                max_cache_entries,
                timeout,
                ssl3_timeout,
                directory.empty() ? 0 : directory.c_str());
        if (result == SECFailure)
                throw CL_Exception(TEXT("SSL_ConfigServerSessionIDCache failed!"));
}
        
CL_Certificate CL_CryptoSetup::find_cert_from_nickname(
        const CL_String &nickname,
        PK11PasswordHandler *pw_handler)
{
        CL_StringA nickname_local8 = CL_StringHelp::text_to_local8(nickname);
        CERTCertificate *cert = PK11_FindCertFromNickname((char *) nickname_local8.c_str(), pw_handler);
        if (cert == 0)
                throw CL_Exception(TEXT("No PK11 certificate found for nickname ") + nickname);
        return CL_Certificate(cert);
}
        
CL_Certificate CL_CryptoSetup::find_cert_from_nickname(
        const CL_String &nickname,
        const CL_String &password)
{
        PK11PasswordHandler_Password pw_handler(password);
        return find_cert_from_nickname(nickname, &pw_handler);
}
        
CL_PrivateKey CL_CryptoSetup::find_key_by_any_cert(
        const CL_Certificate &cert,
        PK11PasswordHandler *pw_handler)
{
        SECKEYPrivateKey *key = PK11_FindKeyByAnyCert(cert.cert, pw_handler);
        if (key == 0)
                throw CL_Exception(TEXT("No private key found for certificate"));
        return CL_PrivateKey(key);
}

// CL_CryptoSetup Implementation:

CL_CryptoSetup *CL_CryptoSetup::instance = 0;

char *CL_CryptoSetup::pk11_password_func(PK11SlotInfo *slot, PRBool retry, void *arg)
{
        PK11PasswordHandler *handler = (PK11PasswordHandler *) arg;
        return 0;
}

---