998 obsolete DMA driver interfaces should be removed

[illumos-gate.git] / usr / src / lib / libkmsagent / common / KMSAgentPKIKeyOpenSSL.cpp

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
 */

/**
 * \file KMSAgentPKIKeyOpenSSL.cpp
 */

#include <stdio.h>
#include <openssl/bio.h>
#include <openssl/pem.h>
#include <openssl/rsa.h>

#include "SYSCommon.h"
#include "KMSAgentPKIimpl.h"

typedef struct PKeyControl
{
    EVP_PKEY*   pPKey;
} PKeyControl;

void * InitializePKeyImpl()
{
    PKeyControl *pPKeyControl = 
       (PKeyControl *) malloc(sizeof(PKeyControl));

    if ( pPKeyControl != NULL )
    {
        pPKeyControl->pPKey = NULL;
    }

    return pPKeyControl;
}

void FinalizePKeyImpl( void * i_pPKeyImpl )
{
    if ( i_pPKeyImpl != NULL )
    {
        free(i_pPKeyImpl);
    }
}

#ifdef KMSUSERPKCS12
void *GetPKey(void *i_pPKeyImpl) {
        PKeyControl* pPKeyControl = (PKeyControl*) i_pPKeyImpl;
        return ((void *)pPKeyControl->pPKey);
}

void SetPKey(void *i_pPKeyImpl, void *pKey) {
        PKeyControl* pPKeyControl = (PKeyControl*) i_pPKeyImpl;
        pPKeyControl->pPKey = (EVP_PKEY *)pKey;
        return;
}
#endif

/**
 * export the private key to a memory BIO, if error, return NULL
 */
BIO* SavePrivateKeyToMemoryBIO(PKeyControl* const i_pPKeyControl,
                               const char * const i_pPassphrase)
{
   BIO *pMemBio = NULL;
   const EVP_CIPHER *pCipher = NULL;
   int iReturn;

   // set cipher, if passphrase is not empty
   if(i_pPassphrase != NULL)
   {
      pCipher= EVP_des_ede3_cbc(); //NULL means no password protection
   }

   // create memory BIO
   pMemBio = BIO_new(BIO_s_mem());

   if(pMemBio == NULL)
   {
      //fixme: log -- no memory
      return NULL;
   }

  iReturn = PEM_write_bio_PrivateKey
     (pMemBio, 
      i_pPKeyControl->pPKey,
      pCipher, 
      NULL,0,NULL, (char*) i_pPassphrase);

   if(!iReturn) // return 0: means error occurs
   {
      //fixme: log -- could not export private key
      BIO_free(pMemBio);
      return NULL;
   }

   return pMemBio;
}

bool SavePrivateKeyToBuffer(
   void * const          i_pPKeyImpl,
   unsigned char * const i_pcBuffer, 
   int                   i_iBufferLength, 
   int * const           o_pActualLength,
   const char * const    i_pPassphrase, 
   int                   i_iFormat)
{
    PKeyControl* pPKeyControl = (PKeyControl*) i_pPKeyImpl;

    FATAL_ASSERT( pPKeyControl && 
        i_pcBuffer && 
        i_iBufferLength > 0 && 
        o_pActualLength );

    BIO *pMemBio = NULL;
        char *pData = NULL;
        int iLength;

        // create memory BIO
        pMemBio = SavePrivateKeyToMemoryBIO( pPKeyControl, i_pPassphrase );

        if(pMemBio == NULL)
        {
                //fixme: log -- no memory
                return false;
        }

        iLength = BIO_get_mem_data(pMemBio, &pData);

    // If the output buffer is a string, it needs to be NULL terminated
    // So always append a NULL to the output
    if(iLength + 1 > i_iBufferLength)
        {
                //fixme: log -- buffer too small
                BIO_free(pMemBio);
                return false;
        }
        // copy the data to given buffer
        memcpy(i_pcBuffer, pData, iLength);
    // NULL terminate the string
    i_pcBuffer[iLength] = '\0';
        *o_pActualLength = iLength;

        // free memory
        BIO_free(pMemBio);

        return true;
}

/**
 * import the private key from a BIO, if error, return NULL
 */
bool LoadPrivateKeyFromBIO(PKeyControl* const io_pPKeyControl,
                           BIO *i_pBio, 
                           char *i_pPassphrase ) 
{
    if (io_pPKeyControl == NULL)
    {
        return false;
    }
    
    EVP_PKEY *pKey = NULL;

        if(i_pBio == NULL) 
    {
        return false;
    }

    if ( io_pPKeyControl != NULL && io_pPKeyControl->pPKey != NULL )
    {
        return false; // do not allow overwrite
    }

        pKey=PEM_read_bio_PrivateKey(i_pBio,NULL,NULL,i_pPassphrase);
        if (pKey == NULL)
        {
                // fixme: log: invalid private key format or passphrase
                return false;
        }

    io_pPKeyControl->pPKey = pKey;

        return true;
}

bool LoadPrivateKeyFromBuffer(
   void * const        i_pPKeyImpl,
   unsigned char *     i_pcBuffer,
   int                 i_iLength, 
   const char * const  i_pPassphrase, 
   int                 i_iFormat)
{ 
    PKeyControl* const pPKeyControl = (PKeyControl*) i_pPKeyImpl;

    FATAL_ASSERT( i_pPKeyImpl && i_pcBuffer );

    bool bReturn;
        BIO *pMemBio;
        // create a mem bio from the given buffer
        // Note that BIO_new_mem_buf() creates a BIO which never 
        // destroy the memory attached to it.
        pMemBio = BIO_new_mem_buf(i_pcBuffer, i_iLength);
        if (pMemBio == NULL)
        {
                //fixme: log -- no memory
                return false;
        }
        bReturn = LoadPrivateKeyFromBIO( pPKeyControl, 
                    pMemBio, (char *)i_pPassphrase );

        BIO_free(pMemBio);

        return bReturn;
}

/**
 * export the public key to a memory BIO, if error, return NULL
 */
BIO* SavePublicKeyToMemoryBIO(PKeyControl* const i_pPublicKeyControl )
{
   BIO *pMemBio = NULL;

   int iReturn;

   // create memory BIO
   pMemBio = BIO_new(BIO_s_mem());

   if(pMemBio == NULL)
   {
      //fixme: log -- no memory
      return NULL;
   }
   
   iReturn = PEM_write_bio_PUBKEY(pMemBio,       
                        i_pPublicKeyControl->pPKey );

   if(!iReturn) // return 0: means error occurs
   {
      //fixme: log -- could not export private key
      BIO_free(pMemBio);
      return NULL;
   }

   return pMemBio;
}

bool SavePublicKeyToBuffer(
   void * const          i_pPKeyImpl,
   unsigned char * const i_pcBuffer, 
   int                   i_iBufferLength, 
   int * const           o_pActualLength,
   int                   i_iFormat)
{
    PKeyControl* pPublicKeyControl = (PKeyControl*) i_pPKeyImpl;

    FATAL_ASSERT( pPublicKeyControl && 
        i_pcBuffer && 
        i_iBufferLength > 0 && 
        o_pActualLength );

    BIO *pMemBio = NULL;
        char *pData = NULL;
        int iLength;

        // create memory BIO
        pMemBio = SavePublicKeyToMemoryBIO( pPublicKeyControl );

        if(pMemBio == NULL)
        {
                return false;
        }

        iLength = BIO_get_mem_data(pMemBio, &pData);

    // If the output buffer is a string, it needs to be NULL terminated
    // So always append a NULL to the output
    if(iLength + 1 > i_iBufferLength)
        {
                BIO_free(pMemBio);
                return false;
        }
        // copy the data to given buffer
        memcpy(i_pcBuffer, pData, iLength);
    // NULL terminate the string
    i_pcBuffer[iLength] = '\0';
        *o_pActualLength = iLength;

        // free memory
        BIO_free(pMemBio);

        return true;
}

/**
 * import the public key from a BIO, if error, return NULL
 */
bool LoadPublicKeyFromBIO(PKeyControl* const io_pPublicKeyControl,
                           BIO *i_pBio ) 
{
        EVP_PKEY *pKey = NULL;

    if(io_pPublicKeyControl == NULL) 
    {
        return false;
    }
    
    if(i_pBio == NULL) 
    {
        return false;
    }

    if ( io_pPublicKeyControl != NULL && io_pPublicKeyControl->pPKey != NULL )
    {
        return false; // do not allow overwrite
    }

    pKey = PEM_read_bio_PUBKEY(i_pBio, NULL, NULL, NULL);
    if (pKey == NULL)
    {
        // fixme: log: invalid public key format or passphrase
        return false;
    }

    io_pPublicKeyControl->pPKey = pKey;

        return true;
}

bool LoadPublicKeyFromBuffer(
   void * const        i_pPublicKeyImpl,
   unsigned char *     i_pcBuffer,
   int                 i_iLength, 
   int                 i_iFormat)
{ 
    PKeyControl* const pPublicKeyControl = (PKeyControl*) i_pPublicKeyImpl;

    FATAL_ASSERT( i_pPublicKeyImpl && i_pcBuffer );

    bool bReturn;
        BIO *pMemBio;
        // create a mem bio from the given buffer
        // Note that BIO_new_mem_buf() creates a BIO which never 
        // destroy the memory attached to it.
        pMemBio = BIO_new_mem_buf(i_pcBuffer, i_iLength);
        if (pMemBio == NULL)
        {
                //fixme: log -- no memory
                return false;
        }
        bReturn = LoadPublicKeyFromBIO( pPublicKeyControl, 
                    pMemBio );

        BIO_free(pMemBio);

        return bReturn;
}

bool PublicKeyEncrypt (int i_iLength,
                       const unsigned char * const i_pcPlainText,
                       unsigned char * const o_pcCypherText,
                       int * const o_pActualLength,
                       void * pPKeyControl )
{
    FATAL_ASSERT( i_pcPlainText );
    FATAL_ASSERT( o_pcCypherText );
    FATAL_ASSERT( o_pActualLength );
    FATAL_ASSERT( pPKeyControl );
    
    PKeyControl *pKeyControl = (PKeyControl *)pPKeyControl;
    EVP_PKEY * pEVP_PKEY = pKeyControl->pPKey;
    RSA * pRSAPublicKey = pEVP_PKEY->pkey.rsa;

//#if defined(DEBUG)
//    RSA_print_fp(stdout, pRSAPublicKey, 0);
//    printf("PublicKeyEncrypt(): RSA_size()=%d, cyphertextLen=%d\n", 
//            RSA_size(pRSAPublicKey),
//            i_iLength);
//#endif
    
    *o_pActualLength = RSA_public_encrypt(i_iLength,
                                          i_pcPlainText, 
                                          o_pcCypherText, 
                                          pRSAPublicKey,
                                          RSA_PKCS1_PADDING);

    if ( *o_pActualLength < 0 )
    {
        return false;     
    }
    else
    {
        return true;
    }
}