UtlCryptoKey.h

Go to the documentation of this file.

//  
// Copyright (C) 2008 SIPfoundry Inc. 
// Licensed by SIPfoundry under the LGPL license. 
//  
// Copyright (C) 2008 SIPez LLC. 
// Licensed to SIPfoundry under a Contributor Agreement. 
//  
// Copyright (C) 2008 Mutualink, Inc. 
// Licensed to SIPfoundry under a Contributor Agreement. 
//  
// $$ 

#ifndef _UtlCryptoKey_h_
#define _UtlCryptoKey_h_

#include "utl/UtlString.h"
#include "utl/UtlCryptoData.h"

// EXTERNAL FUNCTIONS
// EXTERNAL VARIABLES
// CONSTANTS
// TYPEDEFS
typedef struct rsa_st        RSA;
typedef struct evp_cipher_st EVP_CIPHER;
typedef struct env_md_st     EVP_MD;

// DEFINES
// MACROS
// STATIC VARIABLE INITIALIZATIONS


class UtlCryptoKey
{
/* //////////////////////////////// PUBLIC //////////////////////////////// */
public:

   enum KeyType
   {
      KEY_INVALID,    
      KEY_SYMMETRIC,  
      KEY_PRIVATE,    
      KEY_PUBLIC,     
      NUM_KEY_TYPES   
   };

/* =============================== CREATORS =============================== */


   UtlCryptoKey();

   virtual ~UtlCryptoKey();

   // Key loading & retrieval

   virtual int generateKey() = 0;
   virtual int importFromFile(const char* pFilename);
   virtual int loadBinaryKey(const unsigned char* pSrc,
                             int srcLen);

   virtual UtlCryptoData* getBinaryKey() const;

   // Encryption & decryption

   virtual int getMaxEncryptedSize(int srcLen) const = 0;

   virtual int encrypt(const unsigned char* pSrc,
                       int srcLen,
                       unsigned char* pDest,
                       int* pDestLen) const = 0;
   virtual UtlCryptoData* encrypt(const unsigned char* pSrc,
                                  int srcLen) const;
   virtual int getMaxDecryptedSize(int srcLen) const = 0;


   virtual int decrypt(const unsigned char* pSrc,
                       int srcLen,
                       unsigned char* pDest,
                       int* pDestLen) const = 0;
   virtual UtlCryptoData* decrypt(const unsigned char* pSrc,
                                  int srcLen) const;
   virtual int getMaxSignatureSize(int srcLen) const;

   virtual int sign(const unsigned char* pSrc,
                    int srcLen,
                    unsigned char* pDest,
                    int* pDestLen) const;
   virtual UtlCryptoData* sign(const unsigned char* pSrc,
                               int srcLen) const;
   virtual int verify(const unsigned char* pSrc,
                      int srcLen,
                      const unsigned char* pSig,
                      int sigLen) const;

   /* ============================== ACCESSORS =============================== */


   inline bool isValid() const;
   inline bool isPrivate() const;
   inline bool isPublic() const;
   inline bool isSymmetric() const;
   inline KeyType getKeyType() const;
   inline unsigned long getLastError() const;

   virtual UtlString output() const;

   // STATICS

   static int getDigestAlgType();

   static int getMaxDigestSize(int srcLen);

   static int computeDigest(const unsigned char* pSrc,
                            int srcLen,
                            unsigned char* pDest,
                            int* pDestLen);
   static UtlCryptoData* computeDigest(const unsigned char* pSrc,
                                       int srcLen);
   static int getMaxBase64EncodedSize(int srcLen);

   static int base64Encode(const unsigned char* pSrc,
                           int srcLen,
                           unsigned char* pDest,
                           int* pDestLen);
   static UtlString base64Encode(const unsigned char* pSrc,
                                 int srcLen);
   static int getMaxBase64DecodedSize(int srcLen);

   static int base64Decode(const unsigned char* pSrc,
                           int srcLen,
                           unsigned char* pDest,
                           int* pDestLen);
   static int base64Decode(const UtlString& pSrc,
                           unsigned char* pDest,
                           int* pDestLen);
   static UtlCryptoData* base64Decode(const unsigned char* pSrc,
                                      int srcLen);
   static UtlCryptoData* base64Decode(const UtlString& pSrc);
protected:

   inline KeyType  setKeyType(KeyType type);
   unsigned long   setLastError(unsigned long err) const;
   virtual void    clearKey();
   
   static int getBase64Idx(unsigned char c);

   static bool isBase64(unsigned char c);

   static const char sBase64Chars[]; 

private:

   KeyType mKeyType;               
   mutable unsigned long mLastErr; 

   // STATICS
   static const EVP_MD* spMdAlg;  
};


/* ============================ INLINE METHODS ============================ */

bool UtlCryptoKey::isValid() const
{
   return mKeyType != KEY_INVALID;
}

bool UtlCryptoKey::isPrivate() const
{
   return mKeyType == KEY_PRIVATE;
}

bool UtlCryptoKey::isPublic() const
{
   return mKeyType == KEY_PUBLIC;
}

bool UtlCryptoKey::isSymmetric() const
{
   return mKeyType == KEY_SYMMETRIC;
}

UtlCryptoKey::KeyType UtlCryptoKey::getKeyType() const
{
   return mKeyType;
}

unsigned long UtlCryptoKey::getLastError() const
{
   return mLastErr;
}

UtlCryptoKey::KeyType UtlCryptoKey::setKeyType(KeyType type)
{
   mKeyType=type;
   return type;
}


#endif // Include guard