summaryrefslogtreecommitdiff
path: root/src/dkimsign.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/dkimsign.cpp')
-rw-r--r--src/dkimsign.cpp607
1 files changed, 322 insertions, 285 deletions
diff --git a/src/dkimsign.cpp b/src/dkimsign.cpp
index 03b03e2..8be3fc6 100644
--- a/src/dkimsign.cpp
+++ b/src/dkimsign.cpp
@@ -21,15 +21,17 @@
*****************************************************************************/
#define _strnicmp strncasecmp
-#define _stricmp strcasecmp
+#define _stricmp strcasecmp
#define LOWORD(l) ((unsigned)(l) & 0xffff)
#define HIWORD(l) ((unsigned)(l) >> 16)
+#include "dkimsign.h"
+
#include <string.h>
+
#include <map>
#include "dkim.h"
-#include "dkimsign.h"
/*****************************************************************************
*
@@ -119,63 +121,67 @@ CDKIMSign::CDKIMSign()
m_EmptyLineCount = 0;
m_pfnHdrCallback = NULL;
-#if ((OPENSSL_VERSION_NUMBER < 0x10100000L) || (LIBRESSL_VERSION_NUMBER > 0 && LIBRESSL_VERSION_NUMBER < 0x20700000L))
- EVP_SignInit(&m_Hdr_sha1ctx,EVP_sha1());
- EVP_SignInit(&m_Hdr_sha256ctx,EVP_sha256());
- EVP_DigestInit(&m_Bdy_sha1ctx,EVP_sha1());
- EVP_DigestInit(&m_Bdy_sha256ctx,EVP_sha256());
+#if ( \
+ (OPENSSL_VERSION_NUMBER < 0x10100000L) \
+ || (LIBRESSL_VERSION_NUMBER > 0 && LIBRESSL_VERSION_NUMBER < 0x20700000L))
+ EVP_SignInit(&m_Hdr_sha1ctx, EVP_sha1());
+ EVP_SignInit(&m_Hdr_sha256ctx, EVP_sha256());
+ EVP_DigestInit(&m_Bdy_sha1ctx, EVP_sha1());
+ EVP_DigestInit(&m_Bdy_sha256ctx, EVP_sha256());
#else
m_Hdr_sha1ctx = EVP_MD_CTX_create();
- EVP_SignInit_ex(m_Hdr_sha1ctx,EVP_sha1(),NULL);
+ EVP_SignInit_ex(m_Hdr_sha1ctx, EVP_sha1(), NULL);
m_Hdr_sha256ctx = EVP_MD_CTX_create();
- EVP_SignInit_ex(m_Hdr_sha256ctx,EVP_sha256(),NULL);
+ EVP_SignInit_ex(m_Hdr_sha256ctx, EVP_sha256(), NULL);
m_Bdy_sha1ctx = EVP_MD_CTX_create();
- EVP_DigestInit_ex(m_Bdy_sha1ctx,EVP_sha1(),NULL);
+ EVP_DigestInit_ex(m_Bdy_sha1ctx, EVP_sha1(), NULL);
m_Bdy_sha256ctx = EVP_MD_CTX_create();
- EVP_DigestInit_ex(m_Bdy_sha256ctx,EVP_sha256(),NULL);
+ EVP_DigestInit_ex(m_Bdy_sha256ctx, EVP_sha256(), NULL);
m_Hdr_ed25519ctx = EVP_MD_CTX_create();
m_Edy_sha256ctx = EVP_MD_CTX_create();
- EVP_DigestInit_ex(m_Edy_sha256ctx,EVP_sha256(),NULL);
+ EVP_DigestInit_ex(m_Edy_sha256ctx, EVP_sha256(), NULL);
#endif
}
CDKIMSign::~CDKIMSign()
{
-#if ((OPENSSL_VERSION_NUMBER < 0x10100000L) || (LIBRESSL_VERSION_NUMBER > 0 && LIBRESSL_VERSION_NUMBER < 0x20700000L))
- EVP_MD_CTX_cleanup(&m_Hdr_sha1ctx);
- EVP_MD_CTX_cleanup(&m_Hdr_sha256ctx);
- EVP_MD_CTX_cleanup(&m_Bdy_sha1ctx);
- EVP_MD_CTX_cleanup(&m_Bdy_sha256ctx);
+#if ( \
+ (OPENSSL_VERSION_NUMBER < 0x10100000L) \
+ || (LIBRESSL_VERSION_NUMBER > 0 && LIBRESSL_VERSION_NUMBER < 0x20700000L))
+ EVP_MD_CTX_cleanup(&m_Hdr_sha1ctx);
+ EVP_MD_CTX_cleanup(&m_Hdr_sha256ctx);
+ EVP_MD_CTX_cleanup(&m_Bdy_sha1ctx);
+ EVP_MD_CTX_cleanup(&m_Bdy_sha256ctx);
#else
- EVP_MD_CTX_free(m_Hdr_sha1ctx);
- EVP_MD_CTX_free(m_Hdr_sha256ctx);
- EVP_MD_CTX_free(m_Hdr_ed25519ctx);
- EVP_MD_CTX_free(m_Bdy_sha1ctx);
- EVP_MD_CTX_free(m_Bdy_sha256ctx);
- EVP_MD_CTX_free(m_Edy_sha256ctx);
+ EVP_MD_CTX_free(m_Hdr_sha1ctx);
+ EVP_MD_CTX_free(m_Hdr_sha256ctx);
+ EVP_MD_CTX_free(m_Hdr_ed25519ctx);
+ EVP_MD_CTX_free(m_Bdy_sha1ctx);
+ EVP_MD_CTX_free(m_Bdy_sha256ctx);
+ EVP_MD_CTX_free(m_Edy_sha256ctx);
#endif
}
////////////////////////////////////////////////////////////////////////////////
-//
+//
// Init - save the options
//
////////////////////////////////////////////////////////////////////////////////
-int CDKIMSign::Init(DKIMSignOptions* pOptions)
+int CDKIMSign::Init(DKIMSignOptions *pOptions)
{
int nRet = CDKIMBase::Init();
m_Canon = pOptions->nCanon;
// as of draft 01, these are the only allowed signing types:
- if ((m_Canon != DKIM_SIGN_SIMPLE_RELAXED) &&
- (m_Canon != DKIM_SIGN_RELAXED) &&
- (m_Canon != DKIM_SIGN_RELAXED_SIMPLE)) {
+ if ((m_Canon != DKIM_SIGN_SIMPLE_RELAXED) && (m_Canon != DKIM_SIGN_RELAXED)
+ && (m_Canon != DKIM_SIGN_RELAXED_SIMPLE))
+ {
m_Canon = DKIM_SIGN_SIMPLE;
}
@@ -203,8 +209,7 @@ int CDKIMSign::Init(DKIMSignOptions* pOptions)
//sRequiredHeaders.assign(pOptions->szRequiredHeaders);
//make sure there is a colon after the last header in the list
- if ((sRequiredHeaders.size() > 0) &&
- sRequiredHeaders.at(sRequiredHeaders.size() - 1) != ':') {
+ if ((sRequiredHeaders.size() > 0) && sRequiredHeaders.at(sRequiredHeaders.size() - 1) != ':') {
sRequiredHeaders.append(":");
}
@@ -222,11 +227,11 @@ int CDKIMSign::Init(DKIMSignOptions* pOptions)
}
////////////////////////////////////////////////////////////////////////////////
-//
+//
// Hash - update the hash
//
////////////////////////////////////////////////////////////////////////////////
-void CDKIMSign::Hash(const char *szBuffer,int nBufLength,bool bHdr)
+void CDKIMSign::Hash(const char *szBuffer, int nBufLength, bool bHdr)
{
/** START DEBUG CODE **
@@ -247,53 +252,56 @@ void CDKIMSign::Hash(const char *szBuffer,int nBufLength,bool bHdr)
** END DEBUG CODE **/
- if (bHdr) { /* Generate signature: b=... */
- if ((m_nHash == DKIM_HASH_SHA1) ||
- (m_nHash == DKIM_HASH_SHA1_AND_SHA256))
-#if ((OPENSSL_VERSION_NUMBER < 0x10100000L) || (LIBRESSL_VERSION_NUMBER > 0 && LIBRESSL_VERSION_NUMBER < 0x20700000L))
- EVP_SignUpdate(&m_Hdr_sha1ctx,szBuffer,nBufLength);
-#else
- EVP_SignUpdate(m_Hdr_sha1ctx,szBuffer,nBufLength);
+ if (bHdr) { /* Generate signature: b=... */
+ if ((m_nHash == DKIM_HASH_SHA1) || (m_nHash == DKIM_HASH_SHA1_AND_SHA256))
+#if ( \
+ (OPENSSL_VERSION_NUMBER < 0x10100000L) \
+ || (LIBRESSL_VERSION_NUMBER > 0 && LIBRESSL_VERSION_NUMBER < 0x20700000L))
+ EVP_SignUpdate(&m_Hdr_sha1ctx, szBuffer, nBufLength);
+#else
+ EVP_SignUpdate(m_Hdr_sha1ctx, szBuffer, nBufLength);
#endif
- if ((m_nHash == DKIM_HASH_SHA256) ||
- (m_nHash == DKIM_HASH_SHA1_AND_SHA256) ||
- (m_nHash == DKIM_HASH_RSA256_AND_ED25519))
-#if ((OPENSSL_VERSION_NUMBER < 0x10100000L) || (LIBRESSL_VERSION_NUMBER > 0 && LIBRESSL_VERSION_NUMBER < 0x20700000L))
- EVP_SignUpdate(&m_Hdr_sha256ctx,szBuffer,nBufLength);
-#else
- EVP_SignUpdate(m_Hdr_sha256ctx,szBuffer,nBufLength);
+ if ((m_nHash == DKIM_HASH_SHA256) || (m_nHash == DKIM_HASH_SHA1_AND_SHA256)
+ || (m_nHash == DKIM_HASH_RSA256_AND_ED25519))
+#if ( \
+ (OPENSSL_VERSION_NUMBER < 0x10100000L) \
+ || (LIBRESSL_VERSION_NUMBER > 0 && LIBRESSL_VERSION_NUMBER < 0x20700000L))
+ EVP_SignUpdate(&m_Hdr_sha256ctx, szBuffer, nBufLength);
+#else
+ EVP_SignUpdate(m_Hdr_sha256ctx, szBuffer, nBufLength);
#endif
#if ((OPENSSL_VERSION_NUMBER > 0x10101000L))
- if ((m_nHash == DKIM_HASH_ED25519) ||
- (m_nHash == DKIM_HASH_RSA256_AND_ED25519)) {
- SigHdrs.append(szBuffer,nBufLength);
+ if ((m_nHash == DKIM_HASH_ED25519) || (m_nHash == DKIM_HASH_RSA256_AND_ED25519)) {
+ SigHdrs.append(szBuffer, nBufLength);
m_SigHdrs += nBufLength;
}
#endif
- } else { /* lets go for body hash values: bh=... (either SHA1 or SHA256) */
- if ((m_nHash == DKIM_HASH_SHA1) ||
- (m_nHash == DKIM_HASH_SHA1_AND_SHA256))
-#if ((OPENSSL_VERSION_NUMBER < 0x10100000L) || (LIBRESSL_VERSION_NUMBER > 0 && LIBRESSL_VERSION_NUMBER < 0x20700000L))
- EVP_DigestUpdate(&m_Bdy_sha1ctx,szBuffer,nBufLength);
-#else
- EVP_DigestUpdate(m_Bdy_sha1ctx,szBuffer,nBufLength);
+ } else { /* lets go for body hash values: bh=... (either SHA1 or SHA256) */
+ if ((m_nHash == DKIM_HASH_SHA1) || (m_nHash == DKIM_HASH_SHA1_AND_SHA256))
+#if ( \
+ (OPENSSL_VERSION_NUMBER < 0x10100000L) \
+ || (LIBRESSL_VERSION_NUMBER > 0 && LIBRESSL_VERSION_NUMBER < 0x20700000L))
+ EVP_DigestUpdate(&m_Bdy_sha1ctx, szBuffer, nBufLength);
+#else
+ EVP_DigestUpdate(m_Bdy_sha1ctx, szBuffer, nBufLength);
#endif
if (m_nHash != DKIM_HASH_SHA1)
-#if ((OPENSSL_VERSION_NUMBER < 0x10100000L) || (LIBRESSL_VERSION_NUMBER > 0 && LIBRESSL_VERSION_NUMBER < 0x20700000L))
- EVP_DigestUpdate(&m_Bdy_sha256ctx,szBuffer,nBufLength);
+#if ( \
+ (OPENSSL_VERSION_NUMBER < 0x10100000L) \
+ || (LIBRESSL_VERSION_NUMBER > 0 && LIBRESSL_VERSION_NUMBER < 0x20700000L))
+ EVP_DigestUpdate(&m_Bdy_sha256ctx, szBuffer, nBufLength);
#else
- EVP_DigestUpdate(m_Bdy_sha256ctx,szBuffer,nBufLength);
+ EVP_DigestUpdate(m_Bdy_sha256ctx, szBuffer, nBufLength);
#endif
#if ((OPENSSL_VERSION_NUMBER > 0x10101000L))
- if ((m_nHash == DKIM_HASH_ED25519) ||
- (m_nHash == DKIM_HASH_RSA256_AND_ED25519))
- EVP_DigestUpdate(m_Edy_sha256ctx,szBuffer,nBufLength);
+ if ((m_nHash == DKIM_HASH_ED25519) || (m_nHash == DKIM_HASH_RSA256_AND_ED25519))
+ EVP_DigestUpdate(m_Edy_sha256ctx, szBuffer, nBufLength);
#endif
}
}
////////////////////////////////////////////////////////////////////////////////
-//
+//
// SignThisTag - return boolean whether or not to sign this tag
//
////////////////////////////////////////////////////////////////////////////////
@@ -301,25 +309,25 @@ bool CDKIMSign::SignThisTag(const string& sTag)
{
bool bRet = true;
- if (_strnicmp(sTag.c_str(),"X-",2) == 0 ||
- _stricmp(sTag.c_str(),"Authentication-Results:") == 0 ||
- _stricmp(sTag.c_str(),"Return-Path:") == 0) {
+ if (_strnicmp(sTag.c_str(), "X-", 2) == 0 || _stricmp(sTag.c_str(), "Authentication-Results:") == 0
+ || _stricmp(sTag.c_str(), "Return-Path:") == 0)
+ {
bRet = false;
}
return bRet;
}
-bool ConvertHeaderToQuotedPrintable(const char* source, char* dest)
+bool ConvertHeaderToQuotedPrintable(const char *source, char *dest)
{
bool bConvert = false;
// do quoted printable
- static unsigned char hexchars[16] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
+ static unsigned char hexchars[16] = {
+ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
- unsigned char *d = (unsigned char*)dest;
- for (const unsigned char *s = (const unsigned char *)source; *s != '\0'; s++)
- {
+ unsigned char *d = (unsigned char *)dest;
+ for (const unsigned char *s = (const unsigned char *)source; *s != '\0'; s++) {
if (*s >= 33 && *s <= 126 && *s != '=' && *s != ':' && *s != ';' && *s != '|') {
*d++ = *s;
} else {
@@ -335,15 +343,19 @@ bool ConvertHeaderToQuotedPrintable(const char* source, char* dest)
}
////////////////////////////////////////////////////////////////////////////////
-//
+//
// GetHeaderParams - Extract any needed header parameters
//
////////////////////////////////////////////////////////////////////////////////
-void CDKIMSign::GetHeaderParams(const string &sHdr)
+void CDKIMSign::GetHeaderParams(const string& sHdr)
{
- if (_strnicmp(sHdr.c_str(),"X",1) == 0) return;
- if (_strnicmp(sHdr.c_str(),"From:",5) == 0) { sFrom.assign(sHdr.c_str() + 5); }
- if (_strnicmp(sHdr.c_str(),"Sender:",7) == 0) { sSender.assign(sHdr.c_str() + 7); }
+ if (_strnicmp(sHdr.c_str(), "X", 1) == 0) return;
+ if (_strnicmp(sHdr.c_str(), "From:", 5) == 0) {
+ sFrom.assign(sHdr.c_str() + 5);
+ }
+ if (_strnicmp(sHdr.c_str(), "Sender:", 7) == 0) {
+ sSender.assign(sHdr.c_str() + 7);
+ }
if (m_nIncludeCopiedHeaders) {
string::size_type pos = sHdr.find(':');
@@ -352,13 +364,16 @@ void CDKIMSign::GetHeaderParams(const string &sHdr)
string sTag, sValue;
char *workBuffer = new char[sHdr.size() * 3 + 1];
- sTag.assign(sHdr.substr(0,pos));
- sValue.assign(sHdr.substr(pos + 1,string::npos));
+ sTag.assign(sHdr.substr(0, pos));
+ sValue.assign(sHdr.substr(pos + 1, string::npos));
- ConvertHeaderToQuotedPrintable(sTag.c_str(),workBuffer);
- if (!m_sCopiedHeaders.empty()) { m_sCopiedHeaders.append("|"); }
- m_sCopiedHeaders.append(workBuffer); m_sCopiedHeaders.append(":");
- ConvertHeaderToQuotedPrintable(sValue.c_str(),workBuffer);
+ ConvertHeaderToQuotedPrintable(sTag.c_str(), workBuffer);
+ if (!m_sCopiedHeaders.empty()) {
+ m_sCopiedHeaders.append("|");
+ }
+ m_sCopiedHeaders.append(workBuffer);
+ m_sCopiedHeaders.append(":");
+ ConvertHeaderToQuotedPrintable(sValue.c_str(), workBuffer);
m_sCopiedHeaders.append(workBuffer);
delete[] workBuffer;
@@ -367,14 +382,14 @@ void CDKIMSign::GetHeaderParams(const string &sHdr)
}
////////////////////////////////////////////////////////////////////////////////
-//
+//
// ProcessHeaders - sign headers and save needed parameters (this is a lie)
//
////////////////////////////////////////////////////////////////////////////////
int CDKIMSign::ProcessHeaders(void)
{
- map<string,list<string>::reverse_iterator> IterMap;
- map<string,list<string>::reverse_iterator>::iterator IterMapIter;
+ map<string, list<string>::reverse_iterator> IterMap;
+ map<string, list<string>::reverse_iterator>::iterator IterMapIter;
list<string>::reverse_iterator riter;
list<string>::iterator iter;
string sTag;
@@ -391,20 +406,20 @@ int CDKIMSign::ProcessHeaders(void)
int nSignThisTag = 1;
// hack off anything past the colon
- sTag.erase(pos + 1,string::npos);
+ sTag.erase(pos + 1, string::npos);
// is this the From: header?
- if (_stricmp(sTag.c_str(),"From:") == 0) {
+ if (_stricmp(sTag.c_str(), "From:") == 0) {
bFromHeaderFound = true;
nSignThisTag = 1;
IsRequiredHeader(sTag); // remove from required header list
}
// is this in the list of headers that must be signed?
- else if (IsRequiredHeader(sTag)) {
+ else if (IsRequiredHeader(sTag))
+ {
nSignThisTag = 1;
- }
- else {
- if(m_pfnHdrCallback) {
+ } else {
+ if (m_pfnHdrCallback) {
nSignThisTag = m_pfnHdrCallback(iter->c_str());
} else {
nSignThisTag = SignThisTag(sTag) ? 1 : 0;
@@ -424,7 +439,7 @@ int CDKIMSign::ProcessHeaders(void)
// walk the list in reverse looking for the last instance of this header
while (riter != HeaderList.rend()) {
- if (_strnicmp(riter->c_str(),sTag.c_str(),sTag.size()) == 0) {
+ if (_strnicmp(riter->c_str(), sTag.c_str(), sTag.size()) == 0) {
ProcessHeader(*riter);
// save the reverse iterator position for this tag
@@ -433,106 +448,102 @@ int CDKIMSign::ProcessHeaders(void)
break;
}
riter++;
- }
+ }
}
}
}
- if(!bFromHeaderFound) {
+ if (!bFromHeaderFound) {
string sFrom("From:");
hParam.append(sFrom);
- IsRequiredHeader(sFrom); // remove from required header list
-// Hash("\r\n",2);
+ IsRequiredHeader(sFrom); // remove from required header list
+ // Hash("\r\n",2);
}
hParam.append(sRequiredHeaders);
-// string::size_type end = sRequiredHeaders.find(':');
-// while (end != string::npos)
-// {
-// Hash("\r\n",2);
-// end = sRequiredHeaders.find(':', end+1);
-// }
+ // string::size_type end = sRequiredHeaders.find(':');
+ // while (end != string::npos)
+ // {
+ // Hash("\r\n",2);
+ // end = sRequiredHeaders.find(':', end+1);
+ // }
// remove the last colon from h=
- if (hParam.at(hParam.size() - 1) == ':')
- hParam.erase(hParam.size() - 1,string::npos);
+ if (hParam.at(hParam.size() - 1) == ':') hParam.erase(hParam.size() - 1, string::npos);
return DKIM_SUCCESS;
}
-void CDKIMSign::ProcessHeader(const string &sHdr)
+void CDKIMSign::ProcessHeader(const string& sHdr)
{
switch (HIWORD(m_Canon)) {
case DKIM_CANON_SIMPLE:
- Hash(sHdr.c_str(),sHdr.size(),true);
- Hash("\r\n",2,true);
+ Hash(sHdr.c_str(), sHdr.size(), true);
+ Hash("\r\n", 2, true);
break;
- case DKIM_CANON_NOWSP: {
+ case DKIM_CANON_NOWSP: {
string sTemp = sHdr;
RemoveSWSP(sTemp);
// convert characters before ':' to lower case
- for (char *s = (char*)sTemp.c_str(); *s != '\0' && *s != ':'; s++) {
- if (*s >= 'A' && *s <= 'Z')
- *s += 'a' - 'A';
+ for (char *s = (char *)sTemp.c_str(); *s != '\0' && *s != ':'; s++) {
+ if (*s >= 'A' && *s <= 'Z') *s += 'a' - 'A';
}
- Hash(sTemp.c_str(),sTemp.size(),true);
- Hash("\r\n",2,true);
- }
- break;
+ Hash(sTemp.c_str(), sTemp.size(), true);
+ Hash("\r\n", 2, true);
+ } break;
- case DKIM_CANON_RELAXED: {
+ case DKIM_CANON_RELAXED: {
string sTemp = RelaxHeader(sHdr);
- Hash(sTemp.c_str(),sTemp.length(),true);
- Hash("\r\n",2,true);
- }
- break;
+ Hash(sTemp.c_str(), sTemp.length(), true);
+ Hash("\r\n", 2, true);
+ } break;
}
}
-int CDKIMSign::ProcessBody(char *szBuffer,int nBufLength,bool bEOF)
+int CDKIMSign::ProcessBody(char *szBuffer, int nBufLength, bool bEOF)
{
- switch(LOWORD(m_Canon)) {
+ switch (LOWORD(m_Canon)) {
case DKIM_CANON_SIMPLE:
if (nBufLength > 0) {
while (m_EmptyLineCount > 0) {
- Hash("\r\n",2,false);
+ Hash("\r\n", 2, false);
m_nBodyLength += 2;
m_EmptyLineCount--;
}
- Hash(szBuffer,nBufLength,false);
- Hash("\r\n",2,false);
+ Hash(szBuffer, nBufLength, false);
+ Hash("\r\n", 2, false);
m_nBodyLength += nBufLength + 2;
} else {
m_EmptyLineCount++;
if (bEOF) {
- Hash("\r\n",2,false);
+ Hash("\r\n", 2, false);
m_nBodyLength += 2;
}
}
break;
case DKIM_CANON_NOWSP:
- RemoveSWSP(szBuffer,nBufLength);
+ RemoveSWSP(szBuffer, nBufLength);
if (nBufLength > 0) {
- Hash(szBuffer,nBufLength,false);
+ Hash(szBuffer, nBufLength, false);
m_nBodyLength += nBufLength;
}
break;
case DKIM_CANON_RELAXED:
- CompressSWSP(szBuffer,nBufLength);
+ CompressSWSP(szBuffer, nBufLength);
if (nBufLength > 0) {
while (m_EmptyLineCount > 0) {
- Hash("\r\n",2,false);
+ Hash("\r\n", 2, false);
m_nBodyLength += 2;
m_EmptyLineCount--;
}
- Hash(szBuffer,nBufLength,false);
+ Hash(szBuffer, nBufLength, false);
m_nBodyLength += nBufLength;
if (!bEOF) {
- Hash("\r\n",2,false);
+ Hash("\r\n", 2, false);
m_nBodyLength += 2;
}
} else
@@ -560,21 +571,18 @@ bool CDKIMSign::ParseFromAddress(void)
// remove '<' and anything before it
pos = sAddress.find('<');
- if(pos != string::npos)
- sAddress.erase(0,pos);
+ if (pos != string::npos) sAddress.erase(0, pos);
// remove '>' and anything after it
pos = sAddress.find('>');
- if (pos != string::npos)
- sAddress.erase(pos,string::npos);
+ if (pos != string::npos) sAddress.erase(pos, string::npos);
// look for '@' symbol
pos = sAddress.find('@');
- if (pos == string::npos)
- return false;
+ if (pos == string::npos) return false;
if (sDomain.empty()) {
- sDomain.assign (sAddress.c_str() + pos + 1);
+ sDomain.assign(sAddress.c_str() + pos + 1);
RemoveSWSP(sDomain);
}
@@ -582,7 +590,7 @@ bool CDKIMSign::ParseFromAddress(void)
}
////////////////////////////////////////////////////////////////////////////////
-//
+//
// InitSig - initialize signature folding algorithm
//
////////////////////////////////////////////////////////////////////////////////
@@ -594,12 +602,12 @@ void CDKIMSign::InitSig(void)
}
////////////////////////////////////////////////////////////////////////////////
-//
+//
// AddTagToSig - add tag and value to signature folding if necessary
// if bFold, fold at cbrk char
//
////////////////////////////////////////////////////////////////////////////////
-void CDKIMSign::AddTagToSig(const char* const Tag,const string &sValue,char cbrk,bool bFold)
+void CDKIMSign::AddTagToSig(const char *const Tag, const string& sValue, char cbrk, bool bFold)
{
int nTagLen = strlen(Tag);
@@ -613,35 +621,35 @@ void CDKIMSign::AddTagToSig(const char* const Tag,const string &sValue,char cbrk
m_sSig.append(sValue);
m_nSigPos += sValue.size();
} else {
- AddFoldedValueToSig(sValue,cbrk);
+ AddFoldedValueToSig(sValue, cbrk);
}
m_sSig.append(";");
m_nSigPos++;
}
////////////////////////////////////////////////////////////////////////////////
-//
+//
// AddTagToSig - add tag and numeric value to signature folding if necessary
//
////////////////////////////////////////////////////////////////////////////////
-void CDKIMSign::AddTagToSig(const char* const Tag,unsigned long nValue)
+void CDKIMSign::AddTagToSig(const char *const Tag, unsigned long nValue)
{
char szValue[64];
- sprintf(szValue,"%lu",nValue);
- AddTagToSig(Tag,szValue,0,false);
+ sprintf(szValue, "%lu", nValue);
+ AddTagToSig(Tag, szValue, 0, false);
}
////////////////////////////////////////////////////////////////////////////////
-//
+//
// AddInterTagSpace - add space or fold here
//
////////////////////////////////////////////////////////////////////////////////
void CDKIMSign::AddInterTagSpace(int nSizeOfNextTag)
{
if (m_nSigPos + nSizeOfNextTag + 1 > OptimalHeaderLineLength) {
-// m_sSig.append("\r\n\t");
- m_sSig.append("\r\n "); /* s/qmail style */
- m_nSigPos = 1;
+ // m_sSig.append("\r\n\t");
+ m_sSig.append("\r\n "); /* s/qmail style */
+ m_nSigPos = 1;
} else {
m_sSig.append(" ");
m_nSigPos++;
@@ -649,12 +657,12 @@ void CDKIMSign::AddInterTagSpace(int nSizeOfNextTag)
}
////////////////////////////////////////////////////////////////////////////////
-//
+//
// AddTagToSig - add value to signature folding if necessary
// if cbrk == 0 fold anywhere, otherwise fold only at cbrk
//
////////////////////////////////////////////////////////////////////////////////
-void CDKIMSign::AddFoldedValueToSig(const string &sValue,char cbrk)
+void CDKIMSign::AddFoldedValueToSig(const string& sValue, char cbrk)
{
string::size_type pos = 0;
@@ -662,15 +670,14 @@ void CDKIMSign::AddFoldedValueToSig(const string &sValue,char cbrk)
// fold anywhere
while (pos < sValue.size()) {
string::size_type len = OptimalHeaderLineLength - m_nSigPos;
- if (len > sValue.size() - pos)
- len = sValue.size() - pos;
- m_sSig.append(sValue.substr(pos,len));
+ if (len > sValue.size() - pos) len = sValue.size() - pos;
+ m_sSig.append(sValue.substr(pos, len));
m_nSigPos += len;
pos += len;
if (pos < sValue.size()) {
-// m_sSig.append("\r\n\t");
- m_sSig.append("\r\n "); /* s/qmail style */
+ // m_sSig.append("\r\n\t");
+ m_sSig.append("\r\n "); /* s/qmail style */
m_nSigPos = 1;
}
}
@@ -683,11 +690,11 @@ void CDKIMSign::AddFoldedValueToSig(const string &sValue,char cbrk)
if (sValue.size() - pos < len) {
brkpos = sValue.size();
} else {
- brkpos = sValue.rfind(cbrk,pos + len);
+ brkpos = sValue.rfind(cbrk, pos + len);
}
if (brkpos == string::npos || brkpos < pos) {
- brkpos = sValue.find(cbrk,pos);
+ brkpos = sValue.find(cbrk, pos);
if (brkpos == string::npos) {
brkpos = sValue.size();
}
@@ -695,14 +702,14 @@ void CDKIMSign::AddFoldedValueToSig(const string &sValue,char cbrk)
len = brkpos - pos + 1;
- m_sSig.append(sValue.substr(pos,len));
+ m_sSig.append(sValue.substr(pos, len));
m_nSigPos += len;
pos += len;
if (pos < sValue.size()) {
-// m_sSig.append("\r\n\t");
- m_sSig.append("\r\n "); /* s/qmail style */
+ // m_sSig.append("\r\n\t");
+ m_sSig.append("\r\n "); /* s/qmail style */
m_nSigPos = 1;
}
}
@@ -710,11 +717,11 @@ void CDKIMSign::AddFoldedValueToSig(const string &sValue,char cbrk)
}
////////////////////////////////////////////////////////////////////////////////
-//
+//
// GetSig - compute hash and return signature header in szSignature
//
////////////////////////////////////////////////////////////////////////////////
-int CDKIMSign::GetSig2(char* szRSAKey,char* szECCKey,char** pszSignature)
+int CDKIMSign::GetSig2(char *szRSAKey, char *szECCKey, char **pszSignature)
{
if (szRSAKey == NULL && szECCKey == NULL) {
return DKIM_BAD_PRIVATE_KEY;
@@ -724,19 +731,18 @@ int CDKIMSign::GetSig2(char* szRSAKey,char* szECCKey,char** pszSignature)
return DKIM_BUFFER_TOO_SMALL;
}
- int nRet = AssembleReturnedSig(szRSAKey,szECCKey);
+ int nRet = AssembleReturnedSig(szRSAKey, szECCKey);
- if (nRet != DKIM_SUCCESS)
- return nRet;
+ if (nRet != DKIM_SUCCESS) return nRet;
- *pszSignature = (char*)m_sReturnedSig.c_str();
+ *pszSignature = (char *)m_sReturnedSig.c_str();
return DKIM_SUCCESS;
}
////////////////////////////////////////////////////////////////////////////////
-//
+//
// IsRequiredHeader - Check if header in required list. If so, delete
// header from list.
//
@@ -748,118 +754,132 @@ bool CDKIMSign::IsRequiredHeader(const string& sTag)
while (end != string::npos) {
// check for a zero-length header
- if(start == end) {
- sRequiredHeaders.erase(start,1);
+ if (start == end) {
+ sRequiredHeaders.erase(start, 1);
} else {
- if (_stricmp(sTag.c_str(),sRequiredHeaders.substr(start,end - start + 1).c_str()) == 0) {
- sRequiredHeaders.erase(start,end - start + 1);
+ if (_stricmp(sTag.c_str(), sRequiredHeaders.substr(start, end - start + 1).c_str()) == 0) {
+ sRequiredHeaders.erase(start, end - start + 1);
return true;
} else {
start = end + 1;
}
}
- end = sRequiredHeaders.find(':',start);
+ end = sRequiredHeaders.find(':', start);
}
return false;
}
////////////////////////////////////////////////////////////////////////////////
-//
+//
// ConstructSignature
//
// Here, we don't construct the 'signature' but rather the DKIM header
// multiply and indidually crafted for each distinct nSigAlg method
-//
+//
// nSigAlg: DKIM_HASH_SHA1, DKIM_HASH_SHA256, DKIM_HASH_ED25519
//
////////////////////////////////////////////////////////////////////////////////
-int CDKIMSign::ConstructSignature(char* szPrivKey,int nSigAlg)
+int CDKIMSign::ConstructSignature(char *szPrivKey, int nSigAlg)
{
string sSignedSig;
- unsigned char* sig;
+ unsigned char *sig;
EVP_PKEY *pkey = 0;
BIO *bio, *b64;
unsigned int siglen;
int size;
int len;
- char* buf;
+ char *buf;
int nSignRet;
/* construct the DKIM-Signature: header and add to hash */
InitSig();
- AddTagToSig("v","1",0,false);
+ AddTagToSig("v", "1", 0, false);
switch (nSigAlg) {
- case DKIM_HASH_SHA1:
- AddTagToSig("a","rsa-sha1",0,false); break;
- case DKIM_HASH_SHA256:
- AddTagToSig("a","rsa-sha256",0,false); break;
- case DKIM_HASH_ED25519:
- AddTagToSig("a","ed25519-sha256",0,false); break;
+ case DKIM_HASH_SHA1: AddTagToSig("a", "rsa-sha1", 0, false); break;
+ case DKIM_HASH_SHA256: AddTagToSig("a", "rsa-sha256", 0, false); break;
+ case DKIM_HASH_ED25519: AddTagToSig("a", "ed25519-sha256", 0, false); break;
}
switch (m_Canon) {
- case DKIM_SIGN_SIMPLE:
- AddTagToSig("c","simple/simple",0,false); break;
- case DKIM_SIGN_SIMPLE_RELAXED:
- AddTagToSig("c","simple/relaxed",0,false); break;
- case DKIM_SIGN_RELAXED:
- AddTagToSig("c","relaxed/relaxed",0,false); break;
- case DKIM_SIGN_RELAXED_SIMPLE:
- AddTagToSig("c","relaxed/simple",0,false); break;
+ case DKIM_SIGN_SIMPLE: AddTagToSig("c", "simple/simple", 0, false); break;
+ case DKIM_SIGN_SIMPLE_RELAXED: AddTagToSig("c", "simple/relaxed", 0, false); break;
+ case DKIM_SIGN_RELAXED: AddTagToSig("c", "relaxed/relaxed", 0, false); break;
+ case DKIM_SIGN_RELAXED_SIMPLE: AddTagToSig("c", "relaxed/simple", 0, false); break;
}
- AddTagToSig("d",sDomain,0,false);
+ AddTagToSig("d", sDomain, 0, false);
if (nSigAlg == DKIM_HASH_ED25519)
- AddTagToSig("s",eSelector,0,false);
+ AddTagToSig("s", eSelector, 0, false);
else
- AddTagToSig("s",sSelector,0,false);
- if (m_IncludeBodyLengthTag) { AddTagToSig("l",m_nBodyLength); }
- if (m_nIncludeTimeStamp != 0) { time_t t; time(&t); AddTagToSig("t",t); }
- if (m_ExpireTime != 0) { AddTagToSig("x",m_ExpireTime); }
- if (!sIdentity.empty()) { AddTagToSig("i",sIdentity,0,false); }
- if (m_nIncludeQueryMethod) { AddTagToSig("q","dns/txt",0,false); }
+ AddTagToSig("s", sSelector, 0, false);
+ if (m_IncludeBodyLengthTag) {
+ AddTagToSig("l", m_nBodyLength);
+ }
+ if (m_nIncludeTimeStamp != 0) {
+ time_t t;
+ time(&t);
+ AddTagToSig("t", t);
+ }
+ if (m_ExpireTime != 0) {
+ AddTagToSig("x", m_ExpireTime);
+ }
+ if (!sIdentity.empty()) {
+ AddTagToSig("i", sIdentity, 0, false);
+ }
+ if (m_nIncludeQueryMethod) {
+ AddTagToSig("q", "dns/txt", 0, false);
+ }
- AddTagToSig("h",hParam,':',true); // copied headers follow the ':'
- if (m_nIncludeCopiedHeaders) { AddTagToSig("z",m_sCopiedHeaders,0,true); }
+ AddTagToSig("h", hParam, ':', true); // copied headers follow the ':'
+ if (m_nIncludeCopiedHeaders) {
+ AddTagToSig("z", m_sCopiedHeaders, 0, true);
+ }
/* Set up context for (body) hash */
-
+
unsigned char Hash[4096];
unsigned int nHashLen = 0;
switch (nSigAlg) {
- case DKIM_HASH_SHA1:
-#if ((OPENSSL_VERSION_NUMBER < 0x10100000L) || (LIBRESSL_VERSION_NUMBER > 0 && LIBRESSL_VERSION_NUMBER < 0x20700000L))
- EVP_DigestFinal(&m_Bdy_sha1ctx,Hash,&nHashLen); break;
+ case DKIM_HASH_SHA1:
+#if ( \
+ (OPENSSL_VERSION_NUMBER < 0x10100000L) \
+ || (LIBRESSL_VERSION_NUMBER > 0 && LIBRESSL_VERSION_NUMBER < 0x20700000L))
+ EVP_DigestFinal(&m_Bdy_sha1ctx, Hash, &nHashLen);
+ break;
#else
- EVP_DigestFinal_ex(m_Bdy_sha1ctx,Hash,&nHashLen); break;
+ EVP_DigestFinal_ex(m_Bdy_sha1ctx, Hash, &nHashLen);
+ break;
#endif
- case DKIM_HASH_SHA256:
-#if ((OPENSSL_VERSION_NUMBER < 0x10100000L) || (LIBRESSL_VERSION_NUMBER > 0 && LIBRESSL_VERSION_NUMBER < 0x20700000L))
- EVP_DigestFinal(&m_Bdy_sha256ctx,Hash,&nHashLen); break;
+ case DKIM_HASH_SHA256:
+#if ( \
+ (OPENSSL_VERSION_NUMBER < 0x10100000L) \
+ || (LIBRESSL_VERSION_NUMBER > 0 && LIBRESSL_VERSION_NUMBER < 0x20700000L))
+ EVP_DigestFinal(&m_Bdy_sha256ctx, Hash, &nHashLen);
+ break;
#else
- EVP_DigestFinal_ex(m_Bdy_sha256ctx,Hash,&nHashLen); break;
+ EVP_DigestFinal_ex(m_Bdy_sha256ctx, Hash, &nHashLen);
+ break;
#endif
-#if (OPENSSL_VERSION_NUMBER > 0x10101000L)
- case DKIM_HASH_ED25519:
- EVP_DigestFinal_ex(m_Edy_sha256ctx,Hash,&nHashLen); break;
+#if (OPENSSL_VERSION_NUMBER > 0x10101000L)
+ case DKIM_HASH_ED25519: EVP_DigestFinal_ex(m_Edy_sha256ctx, Hash, &nHashLen); break;
#endif
}
bio = BIO_new(BIO_s_mem());
- if (!bio) return DKIM_OUT_OF_MEMORY;
-
+ if (!bio) return DKIM_OUT_OF_MEMORY;
+
b64 = BIO_new(BIO_f_base64());
if (!b64) {
BIO_free(bio);
return DKIM_OUT_OF_MEMORY;
}
- BIO_set_flags(b64,BIO_FLAGS_BASE64_NO_NL);
- BIO_push(b64,bio);
- if (BIO_write(b64,Hash,nHashLen) < (int)nHashLen) {
+ BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
+ BIO_push(b64, bio);
+ if (BIO_write(b64, Hash, nHashLen) < (int)nHashLen) {
BIO_free_all(b64);
return DKIM_OUT_OF_MEMORY;
}
@@ -873,17 +893,17 @@ int CDKIMSign::ConstructSignature(char* szPrivKey,int nSigAlg)
return DKIM_OUT_OF_MEMORY;
}
- size = BIO_read(bio,buf,len);
+ size = BIO_read(bio, buf, len);
BIO_free_all(b64);
// this should never happen
if (size >= len) {
- delete[] buf;
- return DKIM_OUT_OF_MEMORY;
+ delete[] buf;
+ return DKIM_OUT_OF_MEMORY;
}
buf[size] = '\0';
- AddTagToSig("bh",buf,0,true);
+ AddTagToSig("bh", buf, 0, true);
delete[] buf;
AddInterTagSpace(3);
@@ -908,35 +928,46 @@ int CDKIMSign::ConstructSignature(char* szPrivKey,int nSigAlg)
/* Update streaming signatures */
switch (nSigAlg) {
- case DKIM_HASH_SHA1:
-#if ((OPENSSL_VERSION_NUMBER < 0x10100000L) || (LIBRESSL_VERSION_NUMBER > 0 && LIBRESSL_VERSION_NUMBER < 0x20700000L))
- EVP_SignUpdate(&m_Hdr_sha1ctx,sTemp.c_str(),sTemp.size()); break;
+ case DKIM_HASH_SHA1:
+#if ( \
+ (OPENSSL_VERSION_NUMBER < 0x10100000L) \
+ || (LIBRESSL_VERSION_NUMBER > 0 && LIBRESSL_VERSION_NUMBER < 0x20700000L))
+ EVP_SignUpdate(&m_Hdr_sha1ctx, sTemp.c_str(), sTemp.size());
+ break;
#else
- EVP_SignUpdate(m_Hdr_sha1ctx,sTemp.c_str(),sTemp.size()); break;
+ EVP_SignUpdate(m_Hdr_sha1ctx, sTemp.c_str(), sTemp.size());
+ break;
#endif
- case DKIM_HASH_SHA256:
-#if ((OPENSSL_VERSION_NUMBER < 0x10100000L) || (LIBRESSL_VERSION_NUMBER > 0 && LIBRESSL_VERSION_NUMBER < 0x20700000L))
- EVP_SignUpdate(&m_Hdr_sha256ctx,sTemp.c_str(),sTemp.size()); break;
+ case DKIM_HASH_SHA256:
+#if ( \
+ (OPENSSL_VERSION_NUMBER < 0x10100000L) \
+ || (LIBRESSL_VERSION_NUMBER > 0 && LIBRESSL_VERSION_NUMBER < 0x20700000L))
+ EVP_SignUpdate(&m_Hdr_sha256ctx, sTemp.c_str(), sTemp.size());
+ break;
#else
- EVP_SignUpdate(m_Hdr_sha256ctx,sTemp.c_str(),sTemp.size()); break;
+ EVP_SignUpdate(m_Hdr_sha256ctx, sTemp.c_str(), sTemp.size());
+ break;
#endif
#if ((OPENSSL_VERSION_NUMBER > 0x10101000L))
- case DKIM_HASH_ED25519:
- SigHdrs.append(sTemp.c_str(),sTemp.size());
- m_SigHdrs += sTemp.size(); break;
+ case DKIM_HASH_ED25519:
+ SigHdrs.append(sTemp.c_str(), sTemp.size());
+ m_SigHdrs += sTemp.size();
+ break;
#endif
}
bio = BIO_new_mem_buf(szPrivKey, -1);
if (bio == NULL) return DKIM_OUT_OF_MEMORY;
- pkey = PEM_read_bio_PrivateKey(bio,NULL,NULL,NULL); // FIXME - done
+ pkey = PEM_read_bio_PrivateKey(bio, NULL, NULL, NULL); // FIXME - done
BIO_free(bio);
- if (!pkey) { return DKIM_BAD_PRIVATE_KEY; }
+ if (!pkey) {
+ return DKIM_BAD_PRIVATE_KEY;
+ }
siglen = EVP_PKEY_size(pkey);
- sig = (unsigned char*) OPENSSL_malloc(siglen);
+ sig = (unsigned char *)OPENSSL_malloc(siglen);
if (sig == NULL) {
EVP_PKEY_free(pkey);
return DKIM_OUT_OF_MEMORY;
@@ -945,41 +976,50 @@ int CDKIMSign::ConstructSignature(char* szPrivKey,int nSigAlg)
/* Finish streaming signature and potentially go for Ed25519 signatures */
size_t sig_len;
- unsigned char* SignMsg;
+ unsigned char *SignMsg;
switch (nSigAlg) {
- case DKIM_HASH_SHA1:
-#if ((OPENSSL_VERSION_NUMBER < 0x10100000L) || (LIBRESSL_VERSION_NUMBER > 0 && LIBRESSL_VERSION_NUMBER < 0x20700000L))
- nSignRet = EVP_SignFinal(&m_Hdr_sha1ctx,sig,&siglen,pkey); break;
+ case DKIM_HASH_SHA1:
+#if ( \
+ (OPENSSL_VERSION_NUMBER < 0x10100000L) \
+ || (LIBRESSL_VERSION_NUMBER > 0 && LIBRESSL_VERSION_NUMBER < 0x20700000L))
+ nSignRet = EVP_SignFinal(&m_Hdr_sha1ctx, sig, &siglen, pkey);
+ break;
#else
- nSignRet = EVP_SignFinal(m_Hdr_sha1ctx,sig,&siglen,pkey); break;
+ nSignRet = EVP_SignFinal(m_Hdr_sha1ctx, sig, &siglen, pkey);
+ break;
#endif
- case DKIM_HASH_SHA256:
-#if ((OPENSSL_VERSION_NUMBER < 0x10100000L) || (LIBRESSL_VERSION_NUMBER > 0 && LIBRESSL_VERSION_NUMBER < 0x20700000L))
- nSignRet = EVP_SignFinal(&m_Hdr_sha256ctx,sig,&siglen,pkey); break;
+ case DKIM_HASH_SHA256:
+#if ( \
+ (OPENSSL_VERSION_NUMBER < 0x10100000L) \
+ || (LIBRESSL_VERSION_NUMBER > 0 && LIBRESSL_VERSION_NUMBER < 0x20700000L))
+ nSignRet = EVP_SignFinal(&m_Hdr_sha256ctx, sig, &siglen, pkey);
+ break;
#else
- nSignRet = EVP_SignFinal(m_Hdr_sha256ctx,sig,&siglen,pkey); break;
+ nSignRet = EVP_SignFinal(m_Hdr_sha256ctx, sig, &siglen, pkey);
+ break;
#endif
-#if (OPENSSL_VERSION_NUMBER > 0x10101000L)
- case DKIM_HASH_ED25519:
- EVP_DigestSignInit(m_Hdr_ed25519ctx,NULL,NULL,NULL,pkey);
- SignMsg = (unsigned char*) SigHdrs.c_str();
- EVP_DigestSign(m_Hdr_ed25519ctx,NULL,&sig_len,SignMsg,m_SigHdrs);
- sig = (unsigned char*) OPENSSL_malloc(sig_len);
- nSignRet = EVP_DigestSign(m_Hdr_ed25519ctx,sig,&sig_len,SignMsg,m_SigHdrs);
- siglen = (unsigned int) sig_len; break;
+#if (OPENSSL_VERSION_NUMBER > 0x10101000L)
+ case DKIM_HASH_ED25519:
+ EVP_DigestSignInit(m_Hdr_ed25519ctx, NULL, NULL, NULL, pkey);
+ SignMsg = (unsigned char *)SigHdrs.c_str();
+ EVP_DigestSign(m_Hdr_ed25519ctx, NULL, &sig_len, SignMsg, m_SigHdrs);
+ sig = (unsigned char *)OPENSSL_malloc(sig_len);
+ nSignRet = EVP_DigestSign(m_Hdr_ed25519ctx, sig, &sig_len, SignMsg, m_SigHdrs);
+ siglen = (unsigned int)sig_len;
+ break;
#endif
}
EVP_PKEY_free(pkey);
if (!nSignRet) {
OPENSSL_free(sig);
- return DKIM_BAD_PRIVATE_KEY; // key too small
+ return DKIM_BAD_PRIVATE_KEY; // key too small
}
bio = BIO_new(BIO_s_mem());
if (!bio) {
- return DKIM_OUT_OF_MEMORY;
+ return DKIM_OUT_OF_MEMORY;
}
b64 = BIO_new(BIO_f_base64());
@@ -988,10 +1028,10 @@ int CDKIMSign::ConstructSignature(char* szPrivKey,int nSigAlg)
return DKIM_OUT_OF_MEMORY;
}
- BIO_set_flags(b64,BIO_FLAGS_BASE64_NO_NL);
- BIO_push(b64,bio);
+ BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
+ BIO_push(b64, bio);
- if (BIO_write(b64,sig,siglen) < (int) siglen) {
+ if (BIO_write(b64, sig, siglen) < (int)siglen) {
OPENSSL_free(sig);
BIO_free_all(b64);
return DKIM_OUT_OF_MEMORY;
@@ -1007,35 +1047,34 @@ int CDKIMSign::ConstructSignature(char* szPrivKey,int nSigAlg)
return DKIM_OUT_OF_MEMORY;
}
- size = BIO_read(bio,buf,len);
+ size = BIO_read(bio, buf, len);
BIO_free_all(b64);
// this should never happen
if (size >= len) {
delete[] buf;
- return DKIM_OUT_OF_MEMORY;
+ return DKIM_OUT_OF_MEMORY;
}
buf[size] = '\0';
- AddFoldedValueToSig(buf,0);
+ AddFoldedValueToSig(buf, 0);
delete[] buf;
return DKIM_SUCCESS;
}
////////////////////////////////////////////////////////////////////////////////
-//
+//
// AssembleReturnSig
//
-// calls ConstructSignature
+// calls ConstructSignature
// for all different hashes and signature key files
//
////////////////////////////////////////////////////////////////////////////////
-int CDKIMSign::AssembleReturnedSig(char* szRSAKey,char* szECCKey)
+int CDKIMSign::AssembleReturnedSig(char *szRSAKey, char *szECCKey)
{
int nRet;
- if (m_bReturnedSigAssembled)
- return DKIM_SUCCESS;
+ if (m_bReturnedSigAssembled) return DKIM_SUCCESS;
ProcessFinal();
@@ -1045,30 +1084,28 @@ int CDKIMSign::AssembleReturnedSig(char* szRSAKey,char* szECCKey)
string ed25519Sig, sha256Sig, sha1Sig;
- if ((m_nHash == DKIM_HASH_ED25519) ||
- (m_nHash == DKIM_HASH_RSA256_AND_ED25519)) {
- nRet = ConstructSignature(szECCKey,DKIM_HASH_ED25519);
+ if ((m_nHash == DKIM_HASH_ED25519) || (m_nHash == DKIM_HASH_RSA256_AND_ED25519)) {
+ nRet = ConstructSignature(szECCKey, DKIM_HASH_ED25519);
if (nRet == DKIM_SUCCESS) {
ed25519Sig.assign(m_sSig);
} else {
return nRet;
- }
+ }
}
- if ((m_nHash == DKIM_HASH_SHA256) ||
- (m_nHash == DKIM_HASH_SHA1_AND_SHA256) ||
- (m_nHash == DKIM_HASH_RSA256_AND_ED25519)) {
- nRet = ConstructSignature(szRSAKey,DKIM_HASH_SHA256);
+ if ((m_nHash == DKIM_HASH_SHA256) || (m_nHash == DKIM_HASH_SHA1_AND_SHA256)
+ || (m_nHash == DKIM_HASH_RSA256_AND_ED25519))
+ {
+ nRet = ConstructSignature(szRSAKey, DKIM_HASH_SHA256);
if (nRet == DKIM_SUCCESS) {
sha256Sig.assign(m_sSig);
} else {
return nRet;
- }
+ }
}
- if ((m_nHash == DKIM_HASH_SHA1) ||
- (m_nHash == DKIM_HASH_SHA1_AND_SHA256)) {
- nRet = ConstructSignature(szRSAKey,DKIM_HASH_SHA1);
+ if ((m_nHash == DKIM_HASH_SHA1) || (m_nHash == DKIM_HASH_SHA1_AND_SHA256)) {
+ nRet = ConstructSignature(szRSAKey, DKIM_HASH_SHA1);
if (nRet == DKIM_SUCCESS) {
sha1Sig.assign(m_sSig);
} else {
@@ -1076,11 +1113,11 @@ int CDKIMSign::AssembleReturnedSig(char* szRSAKey,char* szECCKey)
}
}
-// fclose(fpdebug);
-// fpdebug = NULL;
+ // fclose(fpdebug);
+ // fpdebug = NULL;
if (!ed25519Sig.empty()) {
-/* if (!m_sReturnedSig.empty()) {
+ /* if (!m_sReturnedSig.empty()) {
m_sReturnedSig.append("\r\n");
}
*/
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-23 11:24:53 +0000