removed top level directory

1 files changed, 0 insertions, 1443 deletions

diff --git a/sqmail-4.3.07/src/dkimverify.cpp b/sqmail-4.3.07/src/dkimverify.cpp
deleted file mode 100644
index c9f1003..0000000
--- a/sqmail-4.3.07/src/dkimverify.cpp
+++ /dev/null
@@ -1,1443 +0,0 @@
-/*****************************************************************************
-*
-*  Licensed under the Apache License, Version 2.0 (the "License"); 
-*  you may not use this file except in compliance with the License. 
-*  You may obtain a copy of the License at 
-*
-*      http://www.apache.org/licenses/LICENSE-2.0 
-*
-*  This code incorporates intellectual property owned by Yahoo! and licensed 
-*  pursuant to the Yahoo! DomainKeys Patent License Agreement.
-*
-*  Unless required by applicable law or agreed to in writing, software 
-*  distributed under the License is distributed on an "AS IS" BASIS, 
-*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-*  See the License for the specific language governing permissions and 
-*  limitations under the License.
-*
-*  Changes done by ¢feh@fehcom.de obeying the above license
-*
-*****************************************************************************/
-#include <string.h>
-#include <ctype.h>
-#include <assert.h>
-#include <vector>
-#include <algorithm>
-#include "dkim.h"
-#include "dkimverify.h"
-#include "dnsgettxt.h"
-extern "C" { 
-#include "dns.h"
-#include "stralloc.h"
-}
-
-/*****************************************************************************
-*
-* Verifying DKIM Ed25519 signatures:
-*
-* The received DKIM header includes two cryptographic relevant informations:
-*
-* a) The 'body hash' => bh=[sha1|sha256]
-* b) The signature   =>  b=[RSA-SHA1|RSA-SHA256|PureEd25519]
-*
-* Several DKIM headers (=signatures) may be present in the email. 
-* Here, it is limited to max. Shall we really evaluate all?
-*
-* Caution: Using hybrid signatures, calling the destructor will core dump 
-*          given EVP_MD_CTX_free() upon the next call of EVP_DigestInit.
-*          Using the destructor with EVP_MD_CTX_reset() however works.
-*
-*****************************************************************************/
-
-#define _strnicmp strncasecmp
-#define _stricmp strcasecmp
-#define MAX_SIGNATURES  10  // maximum number of DKIM signatures to process/message
-#define FDLOG stderr  /* writing to another FD requires a method */
-
-string SigHdr;
-size_t m_SigHdr;
-
-extern "C" int stralloc_copys(stralloc *,char const *);
-
-int dig_ascii(char *digascii,unsigned const char *digest,const int len)
-{
-  static const char hextab[] = "0123456789abcdef";
-  int j;
-
-  for (j = 0; j < len; j++) {
-    digascii[2 * j] = hextab[(unsigned char)digest[j] >> 4];
-    digascii[2 * j + 1] = hextab[(unsigned char)digest[j] & 0x0f];
-  }
-  digascii[2 * len] = '\0';
-
-  return (2 * j);  // 2*len
-}
-
-
-int _DNSGetTXT(const char *szFQDN,char *Buffer,int nBufLen)
-{
-   stralloc out = {0};
-   stralloc sa = {0};
-   Buffer[0] = '\0';  // need to be initialized
-   
-   if (!stralloc_copys(&sa,szFQDN)) return -1;
-   
-   DNS_INIT
-   
-   switch (dns_txt(&out,&sa)) {
-     case -1: return -1;
-     case  0: return 0;
-   } 
-
-   if (nBufLen < out.len) 
-     return -2;
-
-   if (!stralloc_0(&out)) return -1;
-   memcpy(Buffer,out.s,out.len);  // Return-by-value; sigh
-
-   return out.len;
-}
-
-int _DKIM_ReportResult(const char* ResFile,const char* result,const char* reason)
-{
-  int len = 0;
-
-  FILE* out = fopen(ResFile,"wb+");
-  if (out == NULL) return -1;
-
-  if (result) {
-    len = strlen(result);
-    fwrite(result,1,len,out);
-    fwrite("\r",1,1,out);
-  }
-
-  if (reason) {
-    fwrite(reason,1,strlen(reason),out);
-    fwrite("\r",1,1,out);
-  }
-  fclose(out);
-
-  return len;
-}
-
-const char* DKIM_ErrorResult(const int res)
-{
-  const char* errormsg = "";
-
-  switch (res) {
-    case DKIM_FAIL:
-      errormsg = " (verify error: message is suspicious)";
-      break;
-    case DKIM_BAD_SYNTAX:
-      errormsg = " (signature error: could not parse or has bad tags/values)";
-      break;
-    case DKIM_SIGNATURE_BAD:
-      errormsg = " (signature error: RSA/ED25519 verify failed)";
-      break;
-    case DKIM_SIGNATURE_BAD_BUT_TESTING:
-      errormsg = " (signature error: RSA/ED25519 verify failed but testing)";
-      break;
-    case DKIM_SIGNATURE_EXPIRED:
-      errormsg = " (signature error: signature x= value expired)";
-      break;
-    case DKIM_SELECTOR_INVALID:
-      errormsg = " (signature error: selector doesn't parse or contains invalid values)";
-      break;
-    case DKIM_SELECTOR_GRANULARITY_MISMATCH:
-      errormsg = " (signature error: selector g= doesn't match i=)";
-      break;
-    case DKIM_SELECTOR_KEY_REVOKED:
-      errormsg = " (signature error: revoked p= empty)";
-      break;
-    case DKIM_SELECTOR_DOMAIN_NAME_TOO_LONG:
-      errormsg = " (dns error: selector domain name too long to request)";
-      break;
-    case DKIM_SELECTOR_DNS_TEMP_FAILURE:
-      errormsg = " (dns error: temporary dns failure requesting selector)";
-      break;
-    case DKIM_SELECTOR_DNS_PERM_FAILURE:
-      errormsg = " (dns error: permanent dns failure requesting selector)";
-      break;
-    case DKIM_SELECTOR_PUBLIC_KEY_INVALID:
-      errormsg = " (signature error: selector p= value invalid or wrong format)";
-      break;
-    case DKIM_NO_SIGNATURES:
-      errormsg = " (process error: no signatures)";
-      break;
-    case DKIM_NO_VALID_SIGNATURES:
-      errormsg = " (process error: no valid signatures)";
-      break;
-    case DKIM_BODY_HASH_MISMATCH:
-      errormsg = " (signature verify error: message body does not hash to bh= value)";
-      break;
-    case DKIM_SELECTOR_ALGORITHM_MISMATCH:
-      errormsg = " (signature error: selector h= doesn't match signature a=)";
-      break;
-    case DKIM_STAT_INCOMPAT:
-      errormsg = " (signature error: incompatible v= value)";
-      break;
-    case DKIM_UNSIGNED_FROM:
-      errormsg = " (signature error: not all message's From headers in signature)";
-      break;
-    case DKIM_OUT_OF_MEMORY:
-      errormsg = " (internal error: memory allocation failed)";
-      break;
-    case DKIM_INVALID_CONTEXT:
-      errormsg = " (internal error: DKIMContext structure invalid for this operation)";
-      break;
-    case DKIM_NO_SENDER:
-      errormsg = " (signing error: Could not find From: or Sender: header in message)";
-      break;
-    case DKIM_BAD_PRIVATE_KEY:
-      errormsg = " (signing error: Could not parse private key)";
-      break;
-    case DKIM_BUFFER_TOO_SMALL:
-      errormsg = " (signing error: Buffer passed in is not large enough)";
-      break;
-  }
-
-  return errormsg;
-}
-
-SignatureInfo::SignatureInfo(bool s)
-{
-  VerifiedBodyCount = 0;
-  UnverifiedBodyCount = 0;
-
-#if ((OPENSSL_VERSION_NUMBER < 0x10100000L) || (LIBRESSL_VERSION_NUMBER > 0 && LIBRESSL_VERSION_NUMBER < 0x20700000L))
-  EVP_MD_CTX_init(&m_Hdr_ctx);
-  EVP_MD_CTX_init(&m_Bdy_ctx);
-#else
-  m_Hdr_ctx = EVP_MD_CTX_new();
-  m_Bdy_ctx = EVP_MD_CTX_new();
-#endif
-#if (OPENSSL_VERSION_NUMBER > 0x10101000L)
-  m_Msg_ctx = EVP_MD_CTX_new();
-#endif
-  m_pSelector = NULL;
-  Status = DKIM_SUCCESS;
-  m_nHash = 0;
-  EmptyLineCount = 0;
-  m_SaveCanonicalizedData = s;
-}
-
-SignatureInfo::~SignatureInfo()
-{
-#if ((OPENSSL_VERSION_NUMBER < 0x10100000L) || (LIBRESSL_VERSION_NUMBER > 0 && LIBRESSL_VERSION_NUMBER < 0x20700000L))
-  EVP_MD_CTX_cleanup(&m_Hdr_ctx);
-  EVP_MD_CTX_cleanup(&m_Bdy_ctx);
-#else
-  /** FIXME: No free but reset ! **/
-  EVP_MD_CTX_reset(m_Hdr_ctx);  
-  EVP_MD_CTX_reset(m_Bdy_ctx);
-#endif
-#if (OPENSSL_VERSION_NUMBER > 0x10101000L)
-  EVP_MD_CTX_reset(m_Msg_ctx);
-#endif
-}
-
-inline bool isswsp(char ch)
-{
-  return (ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n');
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// 
-// Parse a DKIM tag-list.  Returns true for success
-//
-////////////////////////////////////////////////////////////////////////////////
-bool ParseTagValueList(char *tagvaluelist,const char *wanted[],char *values[])
-{
-  char *s = tagvaluelist;
-
-  for (;;) {
-    // skip whitespace
-    while (isswsp(*s))
-      s++;
-
-    // if at the end of the string, return success.  Note: this allows a list with no entries
-    if (*s == '\0')
-      return true;
-
-    // get tag name
-    if (!isalpha(*s))
-      return false;
-
-    char *tag = s;
-    do {
-      s++;
-    } while (isalnum(*s) || *s == '-');
-
-    char *endtag = s;
-
-    // skip whitespace before equals
-    while (isswsp(*s))
-      s++;
-
-    // next character must be equals
-    if (*s != '=')
-      return false;
-    s++;
-
-    // null-terminate tag name
-    *endtag = '\0';
-
-    // skip whitespace after equals
-    while (isswsp(*s))
-      s++;
-
-    // get tag value
-    char *value = s;
-
-    while (*s != ';' && ((*s == '\t' || *s == '\r' || *s == '\n') || (*s >= ' ' && *s <= '~')))
-      s++;
-
-    char *e = s;
-
-    // make sure the next character is the null terminator (which means we're done) or a semicolon (not done)
-    bool done = false;
-    if (*s == '\0')
-      done = true;
-    else {
-      if (*s != ';')
-        return false;
-      s++;
-    }
-
-    // skip backwards past any trailing whitespace
-    while (e > value && isswsp(e[-1]))
-      e--;
-
-    // null-terminate tag value
-    *e = '\0';
-
-    // check to see if we want this tag
-    for (unsigned i = 0; wanted[i] != NULL; i++) {
-      if (strcmp(wanted[i],tag) == 0) {
-        // return failure if we already have a value for this tag (duplicates not allowed)
-        if (values[i] != NULL)
-          return false;
-        values[i] = value;
-        break;
-      }
-    }
-
-    if (done)
-      return true;
-  }
-}
-////////////////////////////////////////////////////////////////////////////////
-//
-// Convert hex char to value (0-15)
-//
-////////////////////////////////////////////////////////////////////////////////
-char Tohex(char ch)
-{
-  if (ch >= '0' && ch <= '9')
-    return (ch - '0');
-  else if (ch >= 'A' && ch <= 'F')
-    return (ch - 'A' + 10);
-  else if (ch >= 'a' && ch <= 'f')
-    return (ch - 'a' + 10);
-  else {
-    assert(0);
-    return 0;
-  }
-}
-////////////////////////////////////////////////////////////////////////////////
-// 
-// Decode quoted printable string in-place
-//
-////////////////////////////////////////////////////////////////////////////////
-void DecodeQuotedPrintable(char* ptr)
-{
-  char *s = ptr;
-  while (*s != '\0' && *s != '=')
-    s++;
-
-  if (*s == '\0')
-    return;
-
-  char *d = s;
-  do {
-    if (*s == '=' && isxdigit(s[1]) && isxdigit(s[2])) {
-      *d++ = (Tohex(s[1]) << 4) | Tohex(s[2]);
-      s += 3;
-    } else {
-      *d++ = *s++;
-    }
-  } while (*s != '\0');
-  *d = '\0';
-}
-////////////////////////////////////////////////////////////////////////////////
-// 
-// Decode base64 string in-place, returns number of bytes output
-//
-////////////////////////////////////////////////////////////////////////////////
-unsigned DecodeBase64(char *ptr)
-{
-  static const char base64_table[256] = {
-    -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-    -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,62,-1,-1,-1,63,52,53,54,55,56,57,58,59,60,61,-1,-1,-1,-1,-1,-1,
-    -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,-1,-1,-1,-1,-1,
-    -1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,-1,-1,-1,-1,-1,
-    -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-    -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-    -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-    -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
-
-  unsigned char* s = (unsigned char* )ptr;
-  unsigned char* d = (unsigned char* )ptr;
-  unsigned b64accum = 0;
-  unsigned char b64shift = 0;
-
-  while (*s != '\0') {
-    unsigned char value = base64_table[*s++];
-    if ((signed char) value >= 0) {
-      b64accum = (b64accum << 6) | value;
-      b64shift += 6;
-      if (b64shift >= 8) {
-        b64shift -= 8;
-        *d++ = (b64accum >> b64shift);
-      }
-    }
-  }
-
-  return (char* )d-ptr;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// 
-// Match a string with a pattern (used for g= value)
-// Supports a single, optional "*" wildcard character.
-//
-////////////////////////////////////////////////////////////////////////////////
-bool WildcardMatch(const char *p, const char *s)
-{
-  // special case: An empty "g=" value never matches any addresses
-  if (*p == '\0')
-    return false;
-
-  const char* wildcard = strchr(p,'*');
-  if (wildcard == NULL) {
-    return strcmp(s, p) == 0;
-  } else {
-    unsigned beforewildcardlen = wildcard - p;
-    unsigned afterwildcardlen = strlen(wildcard + 1);
-    unsigned slen = strlen(s);
-    return (slen >= beforewildcardlen + afterwildcardlen) && 
-      (strncmp(s,p,beforewildcardlen) == 0) && strcmp(s + slen - afterwildcardlen,wildcard + 1) == 0;
-  }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// 
-// Parse addresses from a string.  Returns true if at least one address found
-//
-////////////////////////////////////////////////////////////////////////////////
-bool ParseAddresses(string str,vector<string> &Addresses)
-{
-  char* s = (char* )str.c_str();
-
-  while (*s != '\0') {
-    char* start = s;
-    char* from = s;
-    char* to = s;
-    char* lt = NULL;  // pointer to less than character (<) which starts the address if found
-
-    while (*from != '\0') {
-      if (*from == '(') {
-        // skip over comment
-        from++;
-        for (int depth = 1; depth != 0; from++) {
-          if (*from == '\0')
-            break;
-          else if (*from == '(')
-            depth++;
-          else if (*from == ')')
-            depth--;
-          else if (*from == '\\' && from[1] != '\0')
-            from++;
-        }
-      }
-      else if (*from == ')') {
-        // ignore closing parenthesis outside of comment
-        from++;
-      } else if (*from == ',' || *from == ';') {
-        // comma/semicolon ends the address
-        from++;
-        break;
-      }
-      else if (*from == ' ' || *from == '\t' || *from == '\r' || *from == '\n') {
-        // ignore whitespace
-        from++;
-      } else if (*from == '"') {
-        // copy the contents of a quoted string
-        from++;
-        while (*from != '\0') {
-          if (*from == '"') {
-            from++;
-            break;
-          } else if (*from == '\\' && from[1] != '\0')
-            *to++ = *from++;
-          *to++ = *from++;
-        }
-      } else if (*from == '\\' && from[1] != '\0') {
-        // copy quoted-pair
-        *to++ = *from++;
-        *to++ = *from++;
-      } else {
-        // copy any other char
-        *to = *from++;
-        // save pointer to '<' for later...
-        if (*to == '<')
-          lt = to;
-        to++;
-      }
-    }
-
-    *to = '\0';
-
-    // if there's < > get what's inside
-    if (lt != NULL) {
-      start = lt+1;
-      char *gt = strchr(start, '>');
-      if (gt != NULL)
-        *gt = '\0';
-    } else {
-      // look for and strip group name
-      char *colon = strchr(start, ':');
-      if (colon != NULL) {
-        char *at = strchr(start, '@');
-        if (at == NULL || colon < at)
-          start = colon+1;
-      }
-    }
-
-    if (*start != '\0' && strchr(start, '@') != NULL) {
-      Addresses.push_back(start);   // save address
-    }
-
-    s = from;
-  }
-
-  return !Addresses.empty();
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-CDKIMVerify::CDKIMVerify()
-{
-  m_pfnSelectorCallback = NULL;
-//  m_pfnPracticesCallback = NULL;
-  m_HonorBodyLengthTag = false;
-  m_CheckPractices = false;
-// Kai:
-//  m_SubjectIsRequired = true;
-  m_SubjectIsRequired = false;
-  m_SaveCanonicalizedData = false;
-  m_AllowUnsignedFromHeaders = false;
-}
-
-CDKIMVerify::~CDKIMVerify() {} // Destructor
-
-////////////////////////////////////////////////////////////////////////////////
-// 
-// Init - save the options
-//
-////////////////////////////////////////////////////////////////////////////////
-int CDKIMVerify::Init(DKIMVerifyOptions* pOptions)
-{
-  int nRet = CDKIMBase::Init();
-
-  m_pfnSelectorCallback = pOptions->pfnSelectorCallback;
-  // m_pfnPracticesCallback = pOptions->pfnPracticesCallback;
-
-  m_HonorBodyLengthTag = pOptions->nHonorBodyLengthTag != 0;
-  m_CheckPractices = pOptions->nCheckPractices != 0;
-// Kai:
-//  m_SubjectIsRequired = pOptions->nSubjectRequired == 0;
-  m_SubjectIsRequired = pOptions->nSubjectRequired == 1;
-  m_SaveCanonicalizedData = pOptions->nSaveCanonicalizedData != 0;
-  m_AllowUnsignedFromHeaders = pOptions->nAllowUnsignedFromHeaders != 0;
-
-  return nRet;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// 
-// GetResults - return the pass/fail/neutral verification result
-//
-////////////////////////////////////////////////////////////////////////////////
-int CDKIMVerify::GetResults(void)
-{
-  // char mdi[128];
-  // char digi[128];
-   
-  ProcessFinal();
-
-  unsigned char *SignMsg;
-  unsigned SuccessCount = 0;
-  int TestingFailures = 0;
-  int RealFailures = 0;
-  int res = 0;
-
-  list<string> SuccessfulDomains;  // can contain duplicates
-
-  for (list<SignatureInfo>::iterator i = Signatures.begin(); i != Signatures.end(); ++i) {
-    if (i->Status == DKIM_SUCCESS) {
-      if (!i->BodyHashData.empty()) {  // FIRST: Get the body hash
-        unsigned char md[EVP_MAX_MD_SIZE];
-        unsigned len = 0;
-
-#if ((OPENSSL_VERSION_NUMBER < 0x10100000L) || (LIBRESSL_VERSION_NUMBER > 0 && LIBRESSL_VERSION_NUMBER < 0x20700000L))
-        res = EVP_DigestFinal(&i->m_Bdy_ctx,md,&len);
-#else
-        res = EVP_DigestFinal_ex(i->m_Bdy_ctx,md,&len);  
-        EVP_MD_CTX_reset(i->m_Bdy_ctx);
-#endif
-        // dig_ascii(digi,md,32);
-        // dig_ascii(mdi,(unsigned const char *)i->BodyHashData.data(),32);
-
-        if (!res || len != i->BodyHashData.length() || memcmp(i->BodyHashData.data(),md,len) != 0) {
-          // body hash mismatch
-
-          // if the selector is in testing mode...
-          if (i->m_pSelector->Testing) {
-            i->Status = DKIM_SIGNATURE_BAD_BUT_TESTING;  // todo: make a new error code for this?
-            TestingFailures++;
-          } else {
-            i->Status = DKIM_BODY_HASH_MISMATCH;
-            RealFailures++;
-          }
-          continue;  // next signature
-        }
-      } else {
-        // hash CRLF separating the body from the signature
-        i->Hash("\r\n",2);
-      }
-
-      // SECOND: Fetch the signature
-
-      string sSignedSig = i->Header;
-      string sSigValue = sSignedSig.substr(sSignedSig.find(':') + 1);
-
-      static const char* tags[] = {"b",NULL};
-      char* values[sizeof(tags)/sizeof(tags[0])] = {NULL};
-
-      char* pSigValue = (char* ) sSigValue.c_str();   // our signature
-      if (ParseTagValueList(pSigValue,tags,values) && values[0] != NULL) {
-        sSignedSig.erase(15 + values[0] - pSigValue,strlen(values[0]));
-      }
-
-      if (i->HeaderCanonicalization == DKIM_CANON_RELAXED) {
-        sSignedSig = RelaxHeader(sSignedSig);
-      }
-      else if (i->HeaderCanonicalization == DKIM_CANON_NOWSP) {
-        RemoveSWSP(sSignedSig);
-        // convert "DKIM-Signature" to lower case
-        sSignedSig.replace(0,14,"dkim-signature",14);
-      }
-
-      i->Hash(sSignedSig.c_str(),sSignedSig.length());   // include generated DKIM signature header 
-      assert(i->m_pSelector != NULL);
-
-      if (EVP_PKEY_base_id(i->m_pSelector->PublicKey) != EVP_PKEY_ED25519) 
-#if ((OPENSSL_VERSION_NUMBER < 0x10100000L) || (LIBRESSL_VERSION_NUMBER > 0 && LIBRESSL_VERSION_NUMBER < 0x20700000L))
-        res = EVP_VerifyFinal(&i->m_Hdr_ctx,(unsigned char *)i->SignatureData.data(),i->SignatureData.length(),i->m_pSelector->PublicKey);
-#else
-        res = EVP_VerifyFinal(i->m_Hdr_ctx,(unsigned char *)i->SignatureData.data(),i->SignatureData.length(),i->m_pSelector->PublicKey);
-#endif
-#if (OPENSSL_VERSION_NUMBER > 0x10101000L)
-      else if (EVP_PKEY_base_id(i->m_pSelector->PublicKey) == EVP_PKEY_ED25519) {
-        EVP_DigestVerifyInit(i->m_Msg_ctx,NULL,NULL,NULL,i->m_pSelector->PublicKey);  // late initialization
-
-        SignMsg = (unsigned char *) SigHdr.data();
-        res = EVP_DigestVerify(i->m_Msg_ctx,(unsigned char *)i->SignatureData.data(),(size_t)i->SignatureData.length(),
-                               SignMsg,m_SigHdr);
-      }
-#endif
-
-      if (res == 1) {
-        if (i->UnverifiedBodyCount == 0)
-          i->Status = DKIM_SUCCESS;
-        else
-          i->Status = DKIM_SUCCESS_BUT_EXTRA;
-        SuccessCount++;
-        SuccessfulDomains.push_back(i->Domain);
-      } else {
-        // if the selector is in testing mode...
-        if (i->m_pSelector->Testing) {
-          i->Status = DKIM_SIGNATURE_BAD_BUT_TESTING;
-          TestingFailures++;
-        } else {
-          i->Status = DKIM_SIGNATURE_BAD;
-          RealFailures++;
-        }
-      }
-    } else if (i->Status == DKIM_SELECTOR_GRANULARITY_MISMATCH || 
-               i->Status == DKIM_SELECTOR_ALGORITHM_MISMATCH || 
-               i->Status == DKIM_SELECTOR_KEY_REVOKED) {
-      // treat these as failures
-      // todo: maybe see if the selector is in testing mode?
-      RealFailures++;
-    }
-  }    // loop over signature infos done
-
-
-  // get the From address's domain if we might need it
-  string sFromDomain;
-  if (SuccessCount > 0 || m_CheckPractices) {
-    for (list<string>::iterator i = HeaderList.begin(); i != HeaderList.end(); ++i) {
-      if (_strnicmp(i->c_str(),"From",4) == 0) {
-        // skip over whitespace between the header name and :
-        const char* s = i->c_str() + 4;
-        while (*s == ' ' || *s == '\t')
-          s++;
-        if (*s == ':') {
-          vector<string> Addresses;
-          if (ParseAddresses(s + 1, Addresses)) {
-            unsigned atpos = Addresses[0].find('@');
-            sFromDomain = Addresses[0].substr(atpos + 1);
-            break;
-          }
-        }
-      }
-    }
-  }
- 
-  // if a signature from the From domain verified successfully, return success now
-  // without checking the author domain signing practices
-  if (SuccessCount > 0 && !sFromDomain.empty()) {
-    for (list<string>::iterator i = SuccessfulDomains.begin(); i != SuccessfulDomains.end(); ++i) {
-      // see if the successful domain is the same as or a parent of the From domain
-      if (i->length() > sFromDomain.length())
-        continue;
-      if (_stricmp(i->c_str(),sFromDomain.c_str() + sFromDomain.length() - i->length()) != 0)
-        continue;
-      if (i->length() == sFromDomain.length() || sFromDomain.c_str()[sFromDomain.length() - i->length() - 1] == '.') {
-        return SuccessCount == Signatures.size() ? DKIM_SUCCESS : DKIM_PARTIAL_SUCCESS;
-      }
-    }
-  }
-
-  /* Removed obsolete ADSP check */
-
-  // return neutral for everything else
-  return DKIM_NEUTRAL;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// 
-// Hash - update the hash or update the Ed25519 signature input
-//
-////////////////////////////////////////////////////////////////////////////////
-void SignatureInfo::Hash(const char* szBuffer,unsigned nBufLength,bool IsBody)
-{
-#if 0
-  /** START DEBUG CODE **/
-  if(nBufLength == 2 && szBuffer[0] == '\r' && szBuffer[1] == '\n')
-  {
-    printf("[CRLF]\n");
-  } else {
-    char* szDbg = new char[nBufLength+1];
-    strncpy(szDbg, szBuffer, nBufLength);
-    szDbg[nBufLength] = '\0';
-    printf("[%s]\n", szDbg);
-  }
-  /** END DEBUG CODE **/
-#endif
-
-  if (IsBody && BodyLength != (unsigned) -1) {    // trick: 2's complement 
-    VerifiedBodyCount += nBufLength;
-    if (VerifiedBodyCount > BodyLength) {
-      nBufLength = BodyLength - (VerifiedBodyCount - nBufLength);
-      UnverifiedBodyCount += VerifiedBodyCount - BodyLength;
-      VerifiedBodyCount = BodyLength;
-      if (nBufLength == 0) return;
-    }
-  }
-
-  if (IsBody && !BodyHashData.empty()) {
-#if ((OPENSSL_VERSION_NUMBER < 0x10100000L) || (LIBRESSL_VERSION_NUMBER > 0 && LIBRESSL_VERSION_NUMBER < 0x20700000L))
-    EVP_DigestUpdate(&m_Bdy_ctx,szBuffer,nBufLength);
-  } else {
-    EVP_VerifyUpdate(&m_Hdr_ctx,szBuffer,nBufLength);
-#else
-    EVP_DigestUpdate(m_Bdy_ctx,szBuffer,nBufLength);
-  } else {
-    EVP_VerifyUpdate(m_Hdr_ctx,szBuffer,nBufLength);
-#endif
-#if (OPENSSL_VERSION_NUMBER > 0x10101000L)
-    SigHdr.append(szBuffer,nBufLength);
-    m_SigHdr += nBufLength;
-#endif
-  }
-
-  if (m_SaveCanonicalizedData) {
-    CanonicalizedData.append(szBuffer,nBufLength);
-  }
-}
-
-
-////////////////////////////////////////////////////////////////////////////////
-// 
-// ProcessHeaders - Look for DKIM-Signatures and start processing them
-//                  look for DKIM-Signature header(s)
-//
-////////////////////////////////////////////////////////////////////////////////
-int CDKIMVerify::ProcessHeaders(void)
-{
-  for (list<string>::iterator i = HeaderList.begin(); i != HeaderList.end(); ++i) {
-    if (strlen(i->c_str()) < 14) continue; // too short
-    if (_strnicmp(i->c_str(),"DKIM-Signature",14) == 0) {
-      // skip over whitespace between the header name and :
-      const char *s = i->c_str() + 14;
-      while (*s == ' ' || *s == '\t')
-        s++;
-      if (*s == ':') {
-        // found
-        SignatureInfo sig(m_SaveCanonicalizedData);
-        sig.Status = ParseDKIMSignature(*i,sig);
-        Signatures.push_back(sig);    // save signature
-
-        if (Signatures.size() >= MAX_SIGNATURES)
-          break;
-      }
-    }
-  }
-
-  if (Signatures.empty())
-    return DKIM_NO_SIGNATURES;
-
-  bool ValidSigFound = false;
-
-  for (list<SignatureInfo>::iterator s = Signatures.begin(); s != Signatures.end(); ++s) {
-    SignatureInfo &sig = *s;
-    if (sig.Status != DKIM_SUCCESS) continue;
-    SelectorInfo &sel = GetSelector(sig.Selector,sig.Domain);
-    sig.m_pSelector = &sel;
-
-    if (sel.Status != DKIM_SUCCESS) {
-      sig.Status = sel.Status;
-    } else {
-      // check the granularity
-      if (!WildcardMatch(sel.Granularity.c_str(),sig.IdentityLocalPart.c_str()))
-        sig.Status = DKIM_SELECTOR_GRANULARITY_MISMATCH;    // this error causes the signature to fail
-
-      // check the hash algorithm
-      if ((sig.m_nHash == DKIM_HASH_SHA1 && !sel.AllowSHA1) || 
-          (sig.m_nHash == DKIM_HASH_SHA256 && !sel.AllowSHA256))
-        sig.Status = DKIM_SELECTOR_ALGORITHM_MISMATCH;      // causes signature to fail
-
-      // check for same domain
-      if (sel.SameDomain && _stricmp(sig.Domain.c_str(),sig.IdentityDomain.c_str()) != 0)
-        sig.Status = DKIM_BAD_SYNTAX;
-    }
-
-    if (sig.Status != DKIM_SUCCESS) continue;
-
-    // initialize the hashes
-    if (sig.m_nHash == DKIM_HASH_SHA1) {
-#if ((OPENSSL_VERSION_NUMBER < 0x10100000L) || (LIBRESSL_VERSION_NUMBER > 0 && LIBRESSL_VERSION_NUMBER < 0x20700000L))
-      EVP_VerifyInit(&sig.m_Hdr_ctx,EVP_sha1());
-      EVP_DigestInit(&sig.m_Bdy_ctx,EVP_sha1());
-#else
-      EVP_VerifyInit_ex(sig.m_Hdr_ctx,EVP_sha1(),NULL);
-      EVP_DigestInit_ex(sig.m_Bdy_ctx,EVP_sha1(),NULL);
-#endif
-    }
-    if (sig.m_nHash == DKIM_HASH_SHA256) {
-#if ((OPENSSL_VERSION_NUMBER < 0x10100000L) || (LIBRESSL_VERSION_NUMBER > 0 && LIBRESSL_VERSION_NUMBER < 0x20700000L))
-      EVP_VerifyInit(&sig.m_Hdr_ctx,EVP_sha256());
-      EVP_DigestInit(&sig.m_Bdy_ctx,EVP_sha256());
-#else
-      EVP_VerifyInit_ex(sig.m_Hdr_ctx,EVP_sha256(),NULL);
-      EVP_DigestInit_ex(sig.m_Bdy_ctx,EVP_sha256(),NULL);
-#endif
-#if (OPENSSL_VERSION_NUMBER > 0x10101000L) 
-      SigHdr.assign("");
-      m_SigHdr = 0;
-    }
-#endif
-
-    // compute the hash of the header
-    vector<list<string>::reverse_iterator> used;
-
-    for (vector<string>::iterator x = sig.SignedHeaders.begin(); x != sig.SignedHeaders.end(); ++x) {
-      list<string>::reverse_iterator i;
-      for (i = HeaderList.rbegin(); i != HeaderList.rend(); ++i) {
-        if (_strnicmp(i->c_str(),x->c_str(),x->length()) == 0) {
-          // skip over whitespace between the header name and :
-          const char* s = i->c_str()+x->length();
-          while (*s == ' ' || *s == '\t')
-            s++;
-          if (*s == ':' && find(used.begin(),used.end(),i) == used.end())
-            break;
-        }
-      }
-
-      if (i != HeaderList.rend()) {
-        used.push_back(i);
-
-        // hash this header
-        if (sig.HeaderCanonicalization == DKIM_CANON_SIMPLE) {
-          sig.Hash(i->c_str(),i->length());
-        } else if (sig.HeaderCanonicalization == DKIM_CANON_RELAXED) {
-          string sTemp = RelaxHeader(*i);
-          sig.Hash(sTemp.c_str(),sTemp.length());
-        } else if (sig.HeaderCanonicalization == DKIM_CANON_NOWSP) {
-          string sTemp = *i;
-          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';
-          }
-          sig.Hash(sTemp.c_str(),sTemp.length());
-        }
-        sig.Hash("\r\n",2);
-      }
-    }
-
-    if (sig.BodyHashData.empty()) {
-      // hash CRLF separating headers from body
-      sig.Hash("\r\n",2);
-    }
-
-    if (!m_AllowUnsignedFromHeaders) {
-      // make sure the message has no unsigned From headers
-      list<string>::reverse_iterator i;
-      for (i = HeaderList.rbegin(); i != HeaderList.rend(); ++i) {
-        if (_strnicmp(i->c_str(),"From",4) == 0) {
-          // skip over whitespace between the header name and :
-          const char *s = i->c_str() + 4;
-          while (*s == ' ' || *s == '\t')
-            s++;
-          if (*s == ':') {
-            if (find(used.begin(),used.end(),i) == used.end()) {
-              // this From header was not signed
-              break;
-            }
-          }
-        }
-      }
-      if (i != HeaderList.rend()) {
-        // treat signature as invalid
-        sig.Status = DKIM_UNSIGNED_FROM;
-        continue;
-      }
-    }
-
-    ValidSigFound = true;
-  }
-
-  if (!ValidSigFound)
-    return DKIM_NO_VALID_SIGNATURES;
-
-  return DKIM_SUCCESS;
-}
-
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// Strictly parse an unsigned integer.  Don't allow spaces, negative sign,
-// 0x prefix, etc.  Values greater than 2^32-1 are capped at 2^32-1
-//
-////////////////////////////////////////////////////////////////////////////////
-bool ParseUnsigned(const char *s, unsigned *result)
-{
-  unsigned temp = 0, last = 0;
-  bool overflowed = false;
-
-  do {
-    if (*s < '0' || *s > '9')
-      return false;        // returns false for an initial '\0'
-
-    temp = temp * 10 + (*s - '0');
-    if (temp < last)
-      overflowed = true;
-    last = temp;
-
-    s++;
-  } while (*s != '\0');
-
-  *result = overflowed ? -1 : temp;
-  return true;
-}
-
-
-////////////////////////////////////////////////////////////////////////////////
-// 
-// ParseDKIMSignature - Parse a DKIM-Signature header field
-//
-////////////////////////////////////////////////////////////////////////////////
-int CDKIMVerify::ParseDKIMSignature(const string& sHeader,SignatureInfo &sig)
-{
-  // for strtok_r()
-  char *saveptr;
-
-  // save header for later
-  sig.Header = sHeader;
-
-  string sValue = sHeader.substr(sHeader.find(':') + 1);
-
-  static const char *tags[] = {"v","a","b","d","h","s","c","i","l","q","t","x","bh",NULL};
-  char *values[sizeof(tags)/sizeof(tags[0])] = {NULL};
-
-  if (!ParseTagValueList((char*) sValue.c_str(),tags,values))
-    return DKIM_BAD_SYNTAX;
-
-  // check signature version
-  if (values[0] == NULL) return DKIM_BAD_SYNTAX;
-  
-  // signature MUST have a=, b=, d=, h=, s=
-  if (values[1] == NULL || values[2] == NULL || values[3] == NULL || values[4] == NULL || values[5] == NULL)
-    return DKIM_BAD_SYNTAX;
-
-  // algorithm ('a=') can be "rsa-sha1" or "rsa-sha256" or "ed25519"
-  if (strcmp(values[1],"rsa-sha1") == 0) {
-    sig.m_nHash = DKIM_HASH_SHA1;
-  } else if (strcmp(values[1],"rsa-sha256") == 0) {
-    sig.m_nHash = DKIM_HASH_SHA256;
-#if (OPENSSL_VERSION_NUMBER > 0x10101000L) 
-  } else if (strcmp(values[1],"ed25519-sha256") == 0) {
-    sig.m_nHash = DKIM_HASH_SHA256;
-#endif
-  } else {
-    return DKIM_BAD_SYNTAX;    // todo: maybe create a new error code for unknown algorithm
-  }
-
-  // make sure the signature data is not empty: b=[...]
-  unsigned SigDataLen = DecodeBase64(values[2]);
-
-  if (SigDataLen == 0)
-    return DKIM_BAD_SYNTAX;
-
-  sig.SignatureData.assign(values[2],SigDataLen);
-
-  // check for body hash in DKIM header: bh=[...];
-  unsigned BodyHashLen = DecodeBase64(values[12]);
-  if (BodyHashLen == 0) return DKIM_BAD_SYNTAX;
-  sig.BodyHashData.assign(values[12],BodyHashLen);
-
-  // domain must not be empty
-  if (*values[3] == '\0')
-    return DKIM_BAD_SYNTAX;
-  sig.Domain = values[3];
-
-  // signed headers must not be empty (more verification is done later)
-  if (*values[4] == '\0')
-    return DKIM_BAD_SYNTAX;
-
-  // selector must not be empty
-  if (*values[5] == '\0')
-    return DKIM_BAD_SYNTAX;
-  sig.Selector = values[5];
-
-  // canonicalization
-  if (values[6] == NULL) {
-    sig.HeaderCanonicalization = sig.BodyCanonicalization = DKIM_CANON_SIMPLE;
-  } else {
-    char* slash = strchr(values[6],'/');
-    if (slash != NULL)
-      *slash = '\0';
-
-    if (strcmp(values[6],"simple") == 0)
-      sig.HeaderCanonicalization = DKIM_CANON_SIMPLE;
-    else if (strcmp(values[6],"relaxed") == 0)
-      sig.HeaderCanonicalization = DKIM_CANON_RELAXED;
-    else
-      return DKIM_BAD_SYNTAX;
-
-    if (slash == NULL || strcmp(slash + 1,"simple") == 0)
-      sig.BodyCanonicalization = DKIM_CANON_SIMPLE;
-    else if (strcmp(slash + 1,"relaxed") == 0)
-      sig.BodyCanonicalization = DKIM_CANON_RELAXED;
-    else
-      return DKIM_BAD_SYNTAX;
-  }
-
-  // identity
-  if (values[7] == NULL) {
-    sig.IdentityLocalPart.erase();
-    sig.IdentityDomain = sig.Domain;
-  } else {
-    // quoted-printable decode the value
-    DecodeQuotedPrintable(values[7]);
-
-    // must have a '@' separating the local part from the domain
-    char* at = strchr(values[7],'@');
-    if (at == NULL)
-      return DKIM_BAD_SYNTAX;
-    *at = '\0';
-
-    char* ilocalpart = values[7];
-    char* idomain = at + 1;
-
-    // i= domain must be the same as or a subdomain of the d= domain
-    int idomainlen = strlen(idomain);
-    int ddomainlen = strlen(values[3]);
-
-    // todo: maybe create a new error code for invalid identity domain
-    if (idomainlen < ddomainlen)
-      return DKIM_BAD_SYNTAX;
-    if (_stricmp(idomain + idomainlen - ddomainlen,values[3]) != 0)
-      return DKIM_BAD_SYNTAX;
-    if (idomainlen > ddomainlen && idomain[idomainlen - ddomainlen - 1] != '.')
-      return DKIM_BAD_SYNTAX;
-
-    sig.IdentityLocalPart = ilocalpart;
-    sig.IdentityDomain = idomain;
-  }
-
-  // body count
-  if (values[8] == NULL || !m_HonorBodyLengthTag) {
-    sig.BodyLength = (unsigned) -1;
-  } else {
-    if (!ParseUnsigned(values[8],&sig.BodyLength))
-      return DKIM_BAD_SYNTAX;
-  }
-
-  // query methods
-  if (values[9] != NULL) {
-    // make sure "dns" is in the list
-    bool HasDNS = false;
-    char* s = strtok_r(values[9],":",&saveptr);
-    while (s != NULL) {
-      if (strncmp(s,"dns",3) == 0 && (s[3] == '\0' || s[3] == '/')) {
-        HasDNS = true;
-        break;
-      }
-      s = strtok_r(NULL,": \t",&saveptr);  /* FIXME */
-//      s = strtok_r(NULL,":   ",&saveptr);  /* FIXME */
-    }
-    if (!HasDNS)
-      return DKIM_BAD_SYNTAX;    // todo: maybe create a new error code for unknown query method
-  }
-
-  // signature time
-  unsigned SignedTime = -1;
-  if (values[10] != NULL) {
-    if (!ParseUnsigned(values[10],&SignedTime))
-      return DKIM_BAD_SYNTAX;
-  }
-
-  // expiration time
-  if (values[11] == NULL) {
-    sig.ExpireTime = (unsigned) -1;   // common trick; feh
-  } else {
-    if (!ParseUnsigned(values[11],&sig.ExpireTime))
-      return DKIM_BAD_SYNTAX;
-
-    if (sig.ExpireTime != (unsigned) -1) {
-      // the value of x= MUST be greater than the value of t= if both are present
-      if (SignedTime != (unsigned) -1 && sig.ExpireTime <= SignedTime)
-        return DKIM_BAD_SYNTAX;
-
-      // todo: if possible, use the received date/time instead of the current time
-      unsigned curtime = time(NULL);
-      if (curtime > sig.ExpireTime)
-        return DKIM_SIGNATURE_EXPIRED;
-    }
-  }
-
-  // parse the signed headers list
-  bool HasFrom = false, HasSubject = false;
-  RemoveSWSP(values[4]);      // header names shouldn't have spaces in them so this should be ok...
-  char* s = strtok_r(values[4],":",&saveptr);
-  while (s != NULL) {
-    if (_stricmp(s,"From") == 0)
-      HasFrom = true;
-    else if (_stricmp(s,"Subject") == 0)
-      HasSubject = true;
-
-    sig.SignedHeaders.push_back(s);
-    s = strtok_r(NULL,":",&saveptr);
-  }
-
-  if (!HasFrom)
-    return DKIM_BAD_SYNTAX;    // todo: maybe create a new error code for h= missing From
-  if (m_SubjectIsRequired && !HasSubject)
-    return DKIM_BAD_SYNTAX;    // todo: maybe create a new error code for h= missing Subject
-
-  return DKIM_SUCCESS;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// 
-// ProcessBody - Process message body data
-//
-////////////////////////////////////////////////////////////////////////////////
-int CDKIMVerify::ProcessBody(char* szBuffer,int nBufLength,bool bEOF)
-{
-  bool MoreBodyNeeded = false;
-
-  for (list<SignatureInfo>::iterator i = Signatures.begin(); i != Signatures.end(); ++i) {
-    if (i->Status == DKIM_SUCCESS) {
-      if (i->BodyCanonicalization == DKIM_CANON_SIMPLE) {
-        if (nBufLength > 0) {
-          while (i->EmptyLineCount > 0) {
-            i->Hash("\r\n",2,true);
-            i->EmptyLineCount--;
-          }
-          i->Hash(szBuffer,nBufLength,true);
-          i->Hash("\r\n",2,true);
-        } else {
-          i->EmptyLineCount++;
-          if (bEOF)
-            i->Hash("\r\n",2,true);
-        }
-      } else if (i->BodyCanonicalization == DKIM_CANON_RELAXED) {
-        CompressSWSP(szBuffer, nBufLength);
-        if (nBufLength > 0) {
-          while (i->EmptyLineCount > 0) {
-            i->Hash("\r\n",2,true);
-            i->EmptyLineCount--;
-          }
-          i->Hash(szBuffer,nBufLength,true);
-          if (!bEOF)
-            i->Hash("\r\n",2,true);
-        } else i->EmptyLineCount++;
-      } else if (i->BodyCanonicalization == DKIM_CANON_NOWSP) {
-        RemoveSWSP(szBuffer,nBufLength);
-        i->Hash(szBuffer,nBufLength,true);
-      }
-
-      if (i->UnverifiedBodyCount == 0)
-        MoreBodyNeeded = true;
-    }
-  }
-
-  if (!MoreBodyNeeded)
-    return DKIM_FINISHED_BODY;
-
-  return DKIM_SUCCESS;
-}
-
-SelectorInfo::SelectorInfo(const string &sSelector,const string &sDomain) : Domain(sDomain),Selector(sSelector)
-{
-  AllowSHA1 = true;
-  AllowSHA256 = true;
-  PublicKey = NULL;
-  Testing = false;
-  SameDomain = false;
-  Status = DKIM_SUCCESS;
-}
-
-SelectorInfo::~SelectorInfo()
-{
-  if (PublicKey != NULL) {
-    EVP_PKEY_free(PublicKey);
-  }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// 
-// Parse - Parse a DKIM selector from DNS data
-//
-////////////////////////////////////////////////////////////////////////////////
-int SelectorInfo::Parse(char* Buffer)
-{
-  // for strtok_r()
-  char *saveptr;
-  char *PubKeyBase64; /*- public key Base64 encoded */
-  char ed25519PubKey[61];
-
-  static const char *tags[] = {"v","g","h","k","p","s","t","n",NULL}; // 0, 1, 2, 3, 4
-  char *values[sizeof(tags)/sizeof(tags[0])] = {NULL};
-
-  ParseTagValueList(Buffer,tags,values);
-   
-  //  return DKIM_SELECTOR_INVALID;
-  if (values[0] != NULL) {
-    // make sure the version is "DKIM1"
-    if (strcmp(values[0],"DKIM1") != 0)
-      return DKIM_SELECTOR_INVALID;    // todo: maybe create a new error code for unsupported selector version
-
-    // make sure v= is the first tag in the response  // todo: maybe don't enforce this, it seems unnecessary
-    for (unsigned j = 1; j < sizeof(values)/sizeof(values[0]); j++) {
-      if (values[j] != NULL && values[j] < values[0]) {
-        return DKIM_SELECTOR_INVALID;
-      }
-    }
-  }
-
-  // selector MUST have p= tag
-  if (values[4] == NULL)
-    return DKIM_SELECTOR_INVALID;
-
-  PubKeyBase64 = values[4]; // gotcha
-
-  // granularity -- [g= ... ]
-  if (values[1] == NULL)
-    Granularity = "*";
-  else
-    Granularity = values[1];
-
-  // hash algorithm -- [h=sha1|sha256] (not required)
-  if (values[2] == NULL) {
-    AllowSHA1 = true;
-    AllowSHA256 = true;
-  } else {
-    // MUST include "sha1" or "sha256"
-    char* s = strtok_r(values[2],":",&saveptr);
-    while (s != NULL) {
-      if (strcmp(s,"sha1") == 0)
-        { AllowSHA1 = true; AllowSHA256 = false; }
-      else if (strcmp(s,"sha256") == 0)
-        { AllowSHA256 = true; AllowSHA1 = false; }
-      s = strtok_r(NULL,":",&saveptr);
-    }
-    if (!(AllowSHA1 || AllowSHA256))
-      return DKIM_SELECTOR_INVALID;  // todo: maybe create a new error code for unsupported hash algorithm
-  }
-
-  // key type -- [k=rsa|ed25519]  (not required)
-  if (values[3] != NULL) {
-    // key type MUST be "rsa" or "ed25519"
-    if (strcmp(values[3],"rsa") != 0 && strcmp(values[3],"ed25519") != 0) // none of either
-      return DKIM_SELECTOR_INVALID;
-    if (strcmp(values[3],"ed25519") == 0) { 
-      AllowSHA1 = false; 
-      AllowSHA256 = true; 
-      strcpy(ed25519PubKey,"MCowBQYDK2VwAyEA");
-      /*
-       * rfc8463
-       * since Ed25519 public keys are 256 bits long,
-       * the base64-encoded key is only 44 octets
-       */
-      if (strlen(values[4]) > 44)
-        return DKIM_SELECTOR_PUBLIC_KEY_INVALID;
-      strcat(ed25519PubKey,values[4]);
-      PubKeyBase64 = ed25519PubKey;
-    } 
-  }
-
-  // service type -- [s= ...] (not required)
-  if (values[5] != NULL) {
-    // make sure "*" or "email" is in the list
-    bool ServiceTypeMatch = false;
-    char* s = strtok_r(values[5],":",&saveptr);
-    while (s != NULL) {
-      if (strcmp(s, "*") == 0 || strcmp(s,"email") == 0) {
-        ServiceTypeMatch = true;
-        break;
-      }
-      s = strtok_r(NULL,":",&saveptr);
-    }
-    if (!ServiceTypeMatch)
-      return DKIM_SELECTOR_INVALID;
-  }
-
-  // flags -- [t= ...] (not required)
-  if (values[6] != NULL) {
-    char *s = strtok_r(values[6],":",&saveptr);
-    while (s != NULL) {
-      if (strcmp(s,"y") == 0) {
-        Testing = true;
-      } else if (strcmp(s,"s") == 0) {
-        SameDomain = true;
-      }
-      s = strtok_r(NULL,":",&saveptr);
-    }
-  }
-
-  // public key data
-  unsigned PublicKeyLen = DecodeBase64(PubKeyBase64);
-
-  if (PublicKeyLen == 0) {
-    return DKIM_SELECTOR_KEY_REVOKED;  // this error causes the signature to fail
-  } else {
-    const unsigned char *PublicKeyData = (unsigned char* )PubKeyBase64;  // 0-terminated
-
-    EVP_PKEY *pkey = d2i_PUBKEY(NULL,&PublicKeyData,PublicKeyLen);  /* retrieve and return PubKey from data */
-
-    if (pkey == NULL)
-      return DKIM_SELECTOR_PUBLIC_KEY_INVALID;
-
-    // make sure public key is the correct type (we only support rsa & ed25519)
-#if ((OPENSSL_VERSION_NUMBER < 0x10101000L) || (LIBRESSL_VERSION_NUMBER > 0 && LIBRESSL_VERSION_NUMBER < 0x20700000L))
-    if (pkey->type == EVP_PKEY_RSA || pkey->type == EVP_PKEY_RSA2) {
-#else
-    if ((EVP_PKEY_base_id(pkey) == EVP_PKEY_RSA)  || 
-        (EVP_PKEY_base_id(pkey) == EVP_PKEY_RSA2) ||
-        (EVP_PKEY_base_id(pkey) == EVP_PKEY_ED25519)) {
-#endif
-      PublicKey = pkey;
-    } else {
-      EVP_PKEY_free(pkey);
-      return DKIM_SELECTOR_PUBLIC_KEY_INVALID;
-    }
-  }
-
-  return DKIM_SUCCESS;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// 
-// GetSelector - Get a DKIM selector for a domain
-//
-////////////////////////////////////////////////////////////////////////////////
-SelectorInfo& CDKIMVerify::GetSelector(const string &sSelector,const string &sDomain)
-{
-  // see if we already have this selector
-  for (list<SelectorInfo>::iterator i = Selectors.begin(); i != Selectors.end(); ++i) {
-    if (_stricmp(i->Selector.c_str(),sSelector.c_str()) == 0 && _stricmp(i->Domain.c_str(),sDomain.c_str()) == 0) {
-      return *i;
-    }
-  }
-
-  Selectors.push_back(SelectorInfo(sSelector,sDomain));
-  SelectorInfo& sel = Selectors.back();
-
-  string sFQDN = sSelector;
-  sFQDN += "._domainkey.";
-  sFQDN += sDomain;
-
-  int BufLen = 1024; 
-  char Buffer[BufLen];
-
-  int DNSResult;
-
-  if (m_pfnSelectorCallback) { 
-    DNSResult = m_pfnSelectorCallback(sFQDN.c_str(),Buffer,BufLen);
-  } else
-    DNSResult = _DNSGetTXT(sFQDN.c_str(),Buffer,BufLen);
-
-//  Buffer++; BufLen--;
-
-  switch (DNSResult) {
-    case -1: case -2: case -3: case -5: sel.Status = DKIM_SELECTOR_DNS_TEMP_FAILURE; break;
-    case 0: case -6: sel.Status = DKIM_SELECTOR_DNS_PERM_FAILURE; break;
-    default: sel.Status = sel.Parse(Buffer);
- }
-
-  return sel;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// 
-// GetDetails - Get DKIM verification details (per signature)
-//
-////////////////////////////////////////////////////////////////////////////////
-int CDKIMVerify::GetDetails(int* nSigCount,DKIMVerifyDetails** pDetails)
-{
-  Details.clear();
-
-  for (list < SignatureInfo>::iterator i = Signatures.begin(); i != Signatures.end(); ++i) {
-    DKIMVerifyDetails d;
-    d.szSignature = (char* )i->Header.c_str();
-    d.szSignatureDomain = (char* )i->Domain.c_str();
-    d.szIdentityDomain = (char* )i->IdentityDomain.c_str();
-    d.szCanonicalizedData = (char* )i->CanonicalizedData.c_str();
-    d.nResult = i->Status;
-    Details.push_back(d);
-  }
-
-  *nSigCount = Details.size();
-  *pDetails = (*nSigCount != 0) ? &Details[0] : NULL;
-
-  return DKIM_SUCCESS;
-}