Mixe for Privacy and Anonymity in the Internet: CAASymCipher.cpp Source File

00001 /*
00002 Copyright (c) 2000, The JAP-Team 
00003 All rights reserved.
00004 Redistribution and use in source and binary forms, with or without modification, 
00005 are permitted provided that the following conditions are met:
00006 
00007   - Redistributions of source code must retain the above copyright notice, 
00008     this list of conditions and the following disclaimer.
00009 
00010   - Redistributions in binary form must reproduce the above copyright notice, 
00011     this list of conditions and the following disclaimer in the documentation and/or 
00012     other materials provided with the distribution.
00013 
00014   - Neither the name of the University of Technology Dresden, Germany nor the names of its contributors 
00015     may be used to endorse or promote products derived from this software without specific 
00016     prior written permission. 
00017 
00018   
00019 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS 
00020 OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY 
00021 AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS
00022 BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
00023 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, 
00024 OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER 
00025 IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 
00026 OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
00027 */
00028 
00029 #include "StdAfx.h"
00030 #include "CAASymCipher.hpp"
00031 #include "CABase64.hpp"
00032 #include "CAUtil.hpp"
00033 #include "xml/DOM_Output.hpp"
00034 CAASymCipher::CAASymCipher()
00035   {
00036     m_pRSA=NULL;
00037   }
00038 
00039 CAASymCipher::~CAASymCipher()
00040   {
00041     destroy();
00042   }
00043 
00044 SINT32 CAASymCipher::destroy()
00045   {
00046     RSA_free(m_pRSA);
00047     m_pRSA=NULL;
00048     return E_SUCCESS;
00049   }
00050 
00051 inline void setRSAFlags(RSA* pRSA)
00052   {
00053     if(pRSA==NULL)
00054       return;
00055     pRSA->flags|=RSA_FLAG_THREAD_SAFE;
00056     #ifdef RSA_FLAG_NO_BLINDING
00057       pRSA->flags|=RSA_FLAG_NO_BLINDING;
00058     #endif
00059 #if OPENSSL_VERSION_NUMBER  > 0x0090707fL
00060     pRSA->flags|=RSA_FLAG_NO_EXP_CONSTTIME;
00061 #endif
00062   }
00063 
00071 SINT32 CAASymCipher::decrypt(const UINT8* from,UINT8* to)
00072   {
00073     if(RSA_private_decrypt(RSA_SIZE,from,to,m_pRSA,RSA_NO_PADDING)==-1)
00074       return E_UNKNOWN;
00075     else
00076       return E_SUCCESS;
00077   }
00078 
00086 SINT32 CAASymCipher::decryptOAEP(const UINT8* from,UINT8* to,UINT32* len)
00087   {
00088     SINT32 ret=RSA_private_decrypt(RSA_SIZE,from,to,m_pRSA,RSA_PKCS1_OAEP_PADDING);
00089     if(ret<0)
00090       return E_UNKNOWN;
00091     *len=ret;
00092     return E_SUCCESS;
00093   }
00094   
00103 SINT32 CAASymCipher::encryptOAEP(const UINT8* from,UINT32 fromlen,UINT8* to,UINT32* len)
00104   {
00105     SINT32 ret=RSA_public_encrypt(fromlen,from,to,m_pRSA,RSA_PKCS1_OAEP_PADDING);
00106     if(ret<0)
00107       return E_UNKNOWN;
00108     *len=ret;
00109     return E_SUCCESS;
00110   }
00111 
00121 SINT32 CAASymCipher::encryptPKCS1(const UINT8* from,UINT32 fromlen,UINT8* to,UINT32* len)
00122   {
00123     SINT32 ret=RSA_public_encrypt(fromlen,from,to,m_pRSA,RSA_PKCS1_PADDING);
00124     if(ret<0)
00125       return E_UNKNOWN;
00126     *len=ret;
00127     return E_SUCCESS;
00128   }
00129 
00137 SINT32 CAASymCipher::encrypt(const UINT8* from,UINT8* to)
00138   {
00139     if(RSA_public_encrypt(RSA_SIZE,from,to,m_pRSA,RSA_NO_PADDING)==-1)
00140       return E_UNKNOWN;
00141     else
00142       return E_SUCCESS;
00143   }
00144 
00150 SINT32 CAASymCipher::generateKeyPair(UINT32 size)
00151   {
00152     RSA_free(m_pRSA);
00153     m_pRSA=RSA_generate_key(size,65537,NULL,NULL);
00154     setRSAFlags(m_pRSA);
00155     if(m_pRSA==NULL)
00156       return E_UNKNOWN;
00157     else
00158       return E_SUCCESS;
00159   }
00160 
00176   /*
00177 SINT32 CAASymCipher::getPublicKey(UINT8* buff,UINT32 *len)
00178   {
00179     if(m_pRSA==NULL||buff==NULL)
00180       return E_UNKNOWN;
00181     SINT32 keySize=getPublicKeySize();
00182     if(keySize<=0||(*len)<(UINT32)keySize)
00183       return E_UNKNOWN;
00184     UINT32 aktIndex=0;
00185     UINT16 size=htons(BN_num_bytes(m_pRSA->n));
00186     memcpy(buff,&size,sizeof(size));
00187     aktIndex+=sizeof(size);
00188     BN_bn2bin(m_pRSA->n,buff+aktIndex);
00189     aktIndex+=BN_num_bytes(m_pRSA->n);
00190     size=htons(BN_num_bytes(m_pRSA->e));
00191     memcpy(buff+aktIndex,&size,sizeof(size));
00192     aktIndex+=sizeof(size);
00193     BN_bn2bin(m_pRSA->e,buff+aktIndex);
00194     aktIndex+=BN_num_bytes(m_pRSA->e);
00195     *len=aktIndex;
00196     return E_SUCCESS;
00197   }*/
00198 
00205 /*SINT32 CAASymCipher::getPublicKeySize()
00206   {
00207     if(m_pRSA==NULL||m_pRSA->n==NULL||m_pRSA->e==NULL)
00208       return E_UNKNOWN;
00209     return (SINT32)BN_num_bytes(m_pRSA->n)+BN_num_bytes(m_pRSA->e)+4;
00210   }*/
00211 
00219 /*SINT32 CAASymCipher::setPublicKey(UINT8* key,UINT32* len)
00220   {
00221     UINT32 aktIndex;
00222     UINT32 availBytes;
00223     UINT16 size;
00224 
00225     if(key==NULL||len==NULL||(*len)<6) //the need at least 6 bytes: 4 for the sizes and 1 for n and 1 for e
00226       goto _ERROR;
00227     availBytes=(*len);
00228     RSA_free(m_pRSA);
00229     m_pRSA=RSA_new();
00230     if(m_pRSA==NULL)
00231       goto _ERROR;
00232     memcpy(&size,key,2);
00233     size=ntohs(size);
00234     availBytes-=2;
00235     if(size>availBytes-3) //the need at least 3 bytes for the exponent...
00236       goto _ERROR;
00237     aktIndex=2;
00238     availBytes-=size;
00239     m_pRSA->n=BN_new();
00240     if(m_pRSA->n==NULL)
00241       goto _ERROR;
00242     BN_bin2bn(key+aktIndex,size,m_pRSA->n);
00243     aktIndex+=size;
00244     memcpy(&size,key+aktIndex,2);
00245     size=ntohs(size);
00246     availBytes-=2;
00247     aktIndex+=2;
00248     if(size>availBytes) 
00249       goto _ERROR;
00250     m_pRSA->e=BN_new();
00251     BN_bin2bn(key+aktIndex,size,m_pRSA->e);
00252     aktIndex+=size;
00253     (*len)=aktIndex;
00254     m_pRSA->flags|=RSA_FLAG_THREAD_SAFE;
00255     #ifdef RSA_FLAG_NO_BLINDING
00256       m_pRSA->flags|=RSA_FLAG_NO_BLINDING;
00257     #endif
00258     return E_SUCCESS;
00259 _ERROR:
00260     RSA_free(m_pRSA);
00261     m_pRSA=NULL;
00262     return E_UNKNOWN;
00263   }
00264 */
00265 
00266 #ifndef ONLY_LOCAL_PROXY
00267 
00287 SINT32 CAASymCipher::getPublicKeyAsXML(UINT8* buff,UINT32 *len)
00288   {
00289     if(m_pRSA==NULL||buff==NULL)
00290       return E_UNKNOWN;
00291     XERCES_CPP_NAMESPACE::DOMDocument* pDoc=createDOMDocument();
00292     DOMElement* elemRoot=NULL;
00293     getPublicKeyAsDOMElement(elemRoot,pDoc);
00294     DOM_Output::dumpToMem(elemRoot,buff,len);
00295     if (pDoc != NULL)
00296     {
00297       pDoc->release();
00298       pDoc = NULL;
00299     }
00300     return E_SUCCESS;
00301   }
00302 
00303 SINT32 CAASymCipher::getPublicKeyAsDOMElement(DOMElement* & elemRoot,XERCES_CPP_NAMESPACE::DOMDocument* docOwner)
00304   {
00305     if(m_pRSA==NULL)
00306       return E_UNKNOWN;
00307     elemRoot=createDOMElement(docOwner,"RSAKeyValue");
00308     
00309     DOMElement* nodeModulus=createDOMElement(docOwner,"Modulus");
00310     elemRoot->appendChild(nodeModulus);
00311     UINT8 tmpBuff[256];
00312     UINT32 size=256;
00313     BN_bn2bin(m_pRSA->n,tmpBuff);
00314     CABase64::encode(tmpBuff,BN_num_bytes(m_pRSA->n),tmpBuff,&size);
00315     tmpBuff[size]=0;
00316     DOMText* tmpTextNode=createDOMText(docOwner,(const char* const)tmpBuff);
00317     nodeModulus->appendChild(tmpTextNode);
00318 
00319     DOMElement* nodeExponent=createDOMElement(docOwner,"Exponent");
00320     BN_bn2bin(m_pRSA->e,tmpBuff);
00321     size=256;
00322     CABase64::encode(tmpBuff,BN_num_bytes(m_pRSA->e),tmpBuff,&size);
00323     tmpBuff[size]=0;
00324     
00325     tmpTextNode=createDOMText(docOwner,(const char* const)tmpBuff);
00326     nodeExponent->appendChild(tmpTextNode);
00327 
00328     elemRoot->appendChild(nodeExponent);
00329     return E_SUCCESS;
00330   }
00331 
00340 SINT32 CAASymCipher::setPublicKeyAsXML(const UINT8* key,UINT32 len)
00341   {
00342     if(key==NULL)
00343       return E_UNKNOWN;
00344 
00345     XERCES_CPP_NAMESPACE::DOMDocument* doc=parseDOMDocument(key,len);
00346     if(doc == NULL)
00347     {
00348       return E_UNKNOWN;
00349     }
00350     DOMElement* root=doc->getDocumentElement();
00351     if(root == NULL)
00352     {
00353       return E_UNKNOWN;
00354     }
00355     return setPublicKeyAsDOMNode(root);
00356   }   
00357 
00358 #endif //ONLY_LOCAL_PROXY
00359 
00360 SINT32 CAASymCipher::setPublicKeyAsDOMNode(DOMNode* node)
00361   { 
00362     DOMNode* root=node;
00363     while(root!=NULL)
00364       { 
00365         if(equals(root->getNodeName(),"RSAKeyValue"))
00366           {
00367             RSA* tmpRSA=RSA_new();
00368             UINT32 decLen=4096;
00369             UINT8 decBuff[4096];
00370             DOMNode* child=root->getFirstChild();
00371             while(child!=NULL)
00372               {
00373                 if(equals(child->getNodeName(),"Modulus"))
00374                   {
00375                     if(tmpRSA->n!=NULL)
00376                       BN_free(tmpRSA->n);
00377                     UINT8* tmpStr=new UINT8[4096];
00378                     UINT32 tmpStrLen=4096;
00379                     getDOMElementValue(child,tmpStr,&tmpStrLen);
00380                     decLen=4096;
00381                     CABase64::decode(tmpStr,tmpStrLen,decBuff,&decLen);
00382                     delete []tmpStr;
00383                     tmpStr = NULL;
00384                     tmpRSA->n=BN_bin2bn(decBuff,decLen,NULL);
00385                   }
00386                 else if(equals(child->getNodeName(),"Exponent"))
00387                   {
00388                     if(tmpRSA->e!=NULL)
00389                       BN_free(tmpRSA->e);
00390                     UINT8* tmpStr=new UINT8[4096];
00391                     UINT32 tmpStrLen=4096;
00392                     getDOMElementValue(child,tmpStr,&tmpStrLen);
00393                     decLen=4096;
00394                     CABase64::decode(tmpStr,tmpStrLen,decBuff,&decLen);
00395                     delete []tmpStr;
00396                     tmpStr = NULL;
00397                     tmpRSA->e=BN_bin2bn(decBuff,decLen,NULL);
00398                   }
00399                 child=child->getNextSibling();
00400               }
00401             if(tmpRSA->n!=NULL&&tmpRSA->e!=NULL)
00402               {
00403                 if(m_pRSA!=NULL)
00404                   RSA_free(m_pRSA);
00405                 m_pRSA=tmpRSA;
00406                 setRSAFlags(m_pRSA);
00407                 return E_SUCCESS;
00408               }
00409             RSA_free(tmpRSA);
00410             return E_UNKNOWN;
00411           }
00412         root=root->getNextSibling();    
00413       }
00414     return E_UNKNOWN;
00415   }
00416 
00417 #ifndef ONLY_LOCAL_PROXY
00418 
00423 SINT32 CAASymCipher::setPublicKey(const CACertificate* pCert)
00424   {
00425     if(pCert==NULL)
00426       return E_UNKNOWN;
00427     EVP_PKEY* pubkey=X509_get_pubkey(pCert->m_pCert);
00428     if(pubkey==NULL||(pubkey->type!=EVP_PKEY_RSA&&pubkey->type!=EVP_PKEY_RSA2))
00429       return E_UNKNOWN;
00430     RSA* r=pubkey->pkey.rsa;
00431     if(RSA_size(r)!=128)
00432       return E_UNKNOWN;
00433     if(m_pRSA!=NULL)
00434       RSA_free(m_pRSA);
00435     m_pRSA=r;
00436     setRSAFlags(m_pRSA);
00437     return E_SUCCESS;
00438   }
00439 #endif //ONLY_LOCAL_PROXY
00440 
00441 SINT32 CAASymCipher::setPublicKey(const UINT8* m,UINT32 mlen,const UINT8* e,UINT32 elen)
00442   {
00443     RSA* tmpRSA=RSA_new();
00444     UINT32 decLen=4096;
00445     UINT8 decBuff[4096];
00446     CABase64::decode(m,mlen,decBuff,&decLen);
00447     tmpRSA->n=BN_bin2bn(decBuff,decLen,NULL);
00448     decLen=4096;
00449     CABase64::decode(e,elen,decBuff,&decLen);
00450     tmpRSA->e=BN_bin2bn(decBuff,decLen,NULL);
00451     if(tmpRSA->n!=NULL&&tmpRSA->e!=NULL)
00452       {
00453         if(m_pRSA!=NULL)
00454           RSA_free(m_pRSA);
00455         m_pRSA=tmpRSA;
00456         setRSAFlags(m_pRSA);
00457         return E_SUCCESS;
00458       }
00459     RSA_free(tmpRSA);
00460     return E_UNKNOWN;
00461   }
00462 
00463 #ifdef INTEL_IPP_CRYPTO
00464 IppStatus __STDCALL myIppBitSupplier(Ipp32u* pData, int nBits,void* pEbsParams)
00465   {
00466     getRandom((UINT8*)pData,(nBits+7)/8);
00467     return ippStsNoErr;
00468   }
00469 #endif
00470 
00471 SINT32 CAASymCipher::testSpeed()
00472   {
00473     const UINT32 runs=10000;
00474     UINT8* inBuff=new UINT8[128];
00475     UINT8* outBuff=new UINT8[128];
00476     getRandom(inBuff,128);
00477     inBuff[0]&=0x7F;
00478 #ifdef INTEL_IPP_CRYPTO
00479     int size=0;
00480     ippsRSAGetSize(1024, 512, IppRSAprivate, &size);
00481     IppsRSAState* pCtx=(IppsRSAState*)new UINT8[size];
00482     IppStatus ret=ippsRSAInit(1024, 512, IppRSAprivate,pCtx);
00483     if(ret!=ippStsNoErr)
00484       {
00485         printf("Error in RSA init!\n");
00486         return E_UNKNOWN;
00487       }
00488     ippsBigNumGetSize(1, &size);
00489     IppsBigNumState* pE = (IppsBigNumState*)( new UINT8 [size] );
00490     ippsBigNumInit(1, pE);
00491     UINT32 pEValue[]= {0x010001};
00492     ret=ippsSet_BN(IppsBigNumPOS, 1, pEValue, pE);
00493     if(ret!=ippStsNoErr)
00494       {
00495         printf("Error in setBN(e)!\n");
00496         return E_UNKNOWN;
00497       }
00498     ippsRSAGenerate(pE,1024,512,1024,pCtx, myIppBitSupplier, NULL);
00499     if(ret!=ippStsNoErr)
00500       {
00501         printf("Error in RSA generate key!\n");
00502         return E_UNKNOWN;
00503       }
00504 
00505     ippsBigNumGetSize(32, &size);
00506     IppsBigNumState* pY = (IppsBigNumState*)( new UINT8 [size] );
00507     ippsBigNumInit(32, pY);
00508 
00509     IppsBigNumState* pX = (IppsBigNumState*)( new UINT8 [size] );
00510     ippsBigNumInit(32, pX);
00511     UINT32* pXValue=new UINT32[32];
00512     memcpy(pXValue,inBuff,128);
00513     pXValue[0]&=0x7FFFFFFF;
00514     ippsSet_BN(IppsBigNumPOS, 32, pXValue, pX);
00515 
00516 #else
00517     CAASymCipher* pCipher=new CAASymCipher();
00518     pCipher->generateKeyPair(1024);
00519     UINT32 iLen=128;
00520     pCipher->encryptOAEP(inBuff,86,inBuff,&iLen);
00521 #endif
00522     UINT64 start,end;
00523     getcurrentTimeMillis(start);
00524     for(UINT32 i=0;i<runs;i++)
00525       {
00526 #ifdef INTEL_IPP_CRYPTO
00527         IppStatus ret=ippsRSADecrypt(pX,pY,pCtx);
00528         if(ret!=ippStsNoErr)
00529         {
00530           printf("Error in RSADEcrypt %i!\n",ret);
00531           return E_UNKNOWN;
00532         }
00533 #else
00534         pCipher->decryptOAEP(inBuff,outBuff,&iLen);
00535 //        pCipher->decrypt(inBuff,outBuff);
00536 #endif
00537       }
00538     getcurrentTimeMillis(end);
00539     UINT32 d=diff64(end,start);
00540     printf("CAASymCiper::testSpeed() takes %u ms for %u decrypts!\n",d,runs);
00541     return E_SUCCESS;
00542   }