mh5hash.c

Go to the documentation of this file.

/*******************************************************************************
 * Copyright © 2014 The DTVKit Open Software Foundation Ltd (www.dtvkit.org)
 * Copyright © 2010 Ocean Blue Software Ltd
 *
 * This file is part of a DTVKit Software Component
 * You are permitted to copy, modify or distribute this file subject to the terms
 * of the DTVKit 1.0 Licence which can be found in licence.txt or at www.dtvkit.org
 * 
 * THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
 * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
 * 
 * If you or your organisation is not a member of DTVKit then you have access
 * to this source code outside of the terms of the licence agreement
 * and you are expected to delete this and any associated files immediately.
 * Further information on DTVKit, membership and terms can be found at www.dtvkit.org
 *******************************************************************************/
/*---includes for this file--------------------------------------------------*/
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <openssl/evp.h>

#include "mh5hash.h"
#include "mh5base.h"
#include "mh5memory.h"
#include "mh5fileorm.h"
#include "mh5sig.h"
#include "stb_os.h"

/*---constant definitions for this file--------------------------------------*/

#define GET_16BITS_FROM_ARRAY(X, Y) ((X[Y] << 8) | X[Y + 1])


/*---local typedef structs for this file-------------------------------------*/
typedef enum
{
   HASH_FILE_RELOAD,
   HASH_FILE_WAITING_FOR_HASH,
   HASH_FILE_WAITING_FOR_SIG,
   HASH_FILE_WAITING_FOR_HASH_AND_SIG,
   HASH_FILE_WAITING_FOR_CERT,
   HASH_FILE_VERIFYING,
   HASH_FILE_VERIFIED,
   HASH_FILE_FAILED
} HashFileState_t;

typedef enum
{
   REQ_OK,
   REQ_FAILED,
   REQ_PENDING
} RequestState_t;

typedef struct sHashDigest
{
   U8BIT type;
   U8BIT nameLength;
   U8BIT *name;
   U8BIT digestLength;
   U8BIT *digest;
   struct sHashDigest *next;
} HashDigest;

typedef struct sHashfileData
{
   U8BIT *url;
   MHEG5String hashData;
   HashFileState_t state;
   MHEG5Bool sameAsPrevious;
   U32BIT signatureIndex;
   MHEG5String signature;
   U16BIT digestCount;
   MHEG5String digestPathname;
   HashDigest *digestList;
   struct sHashfileData *next;
   struct sHashfileData *previous;
} HashfileData;


/*---local (static) variable declarations for this file----------------------*/
static void (*VerificationCallback)(void) = NULL;
static HashfileData *hashfileList = NULL;
static U8BIT noFile;  /*dummy pointer to indicate a failed load*/

/*---local function definitions----------------------------------------------*/

/*---global function definitions---------------------------------------------*/
static U8BIT* GetHashfileUrl(const U8BIT *url);
static MHEG5Bool     ReloadHashfile(HashfileData *hashfile);
static MHEG5Bool     LoadHashfile(U8BIT *url);
static void          HashLoadFailCallback( void *userData );
static void          HashLoadedCallback( void *userData, S_CONTENT *content );
static void          FreeDigestList(HashDigest *listStart);
static MHEG5Bool     ParseHashfile(HashfileData *hashfile);
static HashfileData* FindHashInfo(U8BIT *url);
static HashDigest* FindDigestForUrl(U8BIT *url, HashfileData *hashfile);
static MHEG5Bool     CheckUrlPath(U8BIT *url, HashfileData *hashfile);
static MHEG5Bool     CheckHashes(U8BIT *content, U32BIT contentLength, HashDigest *digest);
static U8BIT* GetNextSigUrl(HashfileData *hashfile);
static void          SigLoadedCallback( void *userData, S_CONTENT *content );
static void          SigLoadFailCallback( void *userData );
static void          VerifyHashfile(HashfileData *hashfile);
static MHEG5Bool     LoadNextSignatureFile(HashfileData *hashfile);
static void          CertCallback(void);
static MHEG5ContentVerification_t GetFailureStatus(HashfileData *hashFile);
static MHEG5ContentVerification_t VerifyUrl(U8BIT *url, U8BIT *content, U32BIT length, HashfileData *hashFile);


/***********************
 * FUNCTION DEFINITIONS *
 ***********************/

void MHEG5SetVerificationCallback(void (*callback)(void))
{
   VerificationCallback = callback;
   MHEG5SetSigVerifyCallback(CertCallback);
}

void MHEG5ResetVerification(void)
{
   HashfileData *listEntry;
   HashfileData *nextEntry;
   MHEG5String *hashData;

   listEntry = hashfileList;
   hashfileList = NULL;

   while (listEntry)
   {
      /*save the pointer to the next entry*/
      nextEntry = listEntry->next;

      /*free any asociated data*/
      if (listEntry->url != NULL)
      {
         MHEG5freeMem(listEntry->url);
      }

      hashData = &listEntry->hashData;

      if (hashData->data != &noFile && hashData->data != NULL)
      {
         MHEG5freeMem(hashData->data);
      }

      FreeDigestList(listEntry->digestList);
      listEntry->digestList = NULL;
      /*free memory of the entry*/
      MHEG5freeMem(listEntry);

      /*go to the next entry*/
      listEntry = nextEntry;
   }
}

MHEG5ContentVerification_t MHEG5IsContentVerified(U8BIT *url, U8BIT *content,
   U32BIT length)
{
   HashfileData *hashFile = NULL;
   MHEG5ContentVerification_t status;
   MHEG5Bool success;
   U8BIT *hashfileUrl;

   hashfileUrl = GetHashfileUrl(url);
   if (hashfileUrl == NULL)
   {
      return CONTENT_NOT_VERIFIED_NEW;
   }

   hashFile = FindHashInfo(hashfileUrl);
   if (hashFile != NULL)
   {
      switch (hashFile->state)
      {
         case HASH_FILE_RELOAD:
            success = ReloadHashfile(hashFile);
            if (success == MHEG5TRUE)
            {
               status = CONTENT_VERIFICATION_PENDING;
            }
            else
            {
               status = GetFailureStatus(hashFile);
            }
            break;

         case HASH_FILE_WAITING_FOR_HASH:
         case HASH_FILE_WAITING_FOR_SIG:
         case HASH_FILE_WAITING_FOR_HASH_AND_SIG:
         case HASH_FILE_WAITING_FOR_CERT:
         case HASH_FILE_VERIFYING:

            status = CONTENT_VERIFICATION_PENDING;
            break;

         case HASH_FILE_VERIFIED:
            status = VerifyUrl(url, content, length, hashFile);
            break;
         case HASH_FILE_FAILED:
            status = GetFailureStatus(hashFile);
            break;
         default:
            status = CONTENT_NOT_VERIFIED_NEW;
            assert(0);
      }

      /*finished with the url string*/
      MHEG5freeMem(hashfileUrl);
   }
   else
   {
      success = LoadHashfile(hashfileUrl);
      if (success)
      {
         status = CONTENT_VERIFICATION_PENDING;
      }
      else
      {
         /*finished with the url string*/
         MHEG5freeMem(hashfileUrl);

         status = CONTENT_NOT_VERIFIED_NEW;
      }
   }

   return status;
}

static MHEG5ContentVerification_t GetFailureStatus(HashfileData *hashFile)
{
   MHEG5ContentVerification_t status;
   if (hashFile->sameAsPrevious)
   {
      status = CONTENT_NOT_VERIFIED_SAME;
   }
   else
   {
      status = CONTENT_NOT_VERIFIED_NEW;
   }
   return status;
}

static MHEG5ContentVerification_t VerifyUrl(U8BIT *url, U8BIT *content, U32BIT length, HashfileData *hashFile)
{
   MHEG5Bool success;
   HashDigest *digest;
   MHEG5ContentVerification_t status;

   success = MHEG5FALSE;
   status = GetFailureStatus(hashFile); /*default to failure*/

   if (hashFile->digestCount == 0)
   {
      success = CheckUrlPath(url, hashFile);
      if (success)
      {
         status = CONTENT_VERIFIED_UNSIGNED;
      }
   }
   else
   {
      digest = FindDigestForUrl(url, hashFile);
      if (digest != NULL)
      {
         success = CheckHashes(content, length, digest);
      }
      if (success)
      {
         status = CONTENT_VERIFIED_SIGNED;
      }
   }

   return status;
}

static HashfileData* FindHashInfo(U8BIT *url)
{
   HashfileData *listEntry;
   int differ;

   /*look through the list of loaded files for the provided url*/
   listEntry = hashfileList;

   while (listEntry != NULL)
   {
      differ = strcmp((char *)url, (char *)listEntry->url);
      if (!differ)
      {
         break;
      }
      else
      {
         listEntry = listEntry->next;
      }
   }

   return listEntry;
}

static U8BIT* GetHashfileUrl(const U8BIT *url)
{
   U32BIT length;
   U8BIT *slash;
   U8BIT *hashfileUrl;
   U8BIT *hashfileName = (U8BIT *)"auth.hash";
   U32BIT hashfileNameLen = strlen((char *)hashfileName);

   slash = (U8BIT *)strrchr((char *)url, '/');
   assert(slash != NULL);
   length = slash - url + 1;

   hashfileUrl = MHEG5getMem(length + hashfileNameLen + 1);
   if (hashfileUrl != NULL)
   {
      memcpy(hashfileUrl, url, length);
      memcpy(hashfileUrl + length, hashfileName, hashfileNameLen);
      hashfileUrl[length + hashfileNameLen] = '\0';
   }
   return hashfileUrl;
}

static MHEG5Bool ReloadHashfile(HashfileData *hashfile)
{
   MHEG5String hashName;
   MHEG5Bool success;

   assert(hashfile);
   hashName.data = hashfile->url;
   hashName.len = strlen((char *)hashfile->url);

   hashfile->state = HASH_FILE_WAITING_FOR_HASH_AND_SIG;
   (void)MHEG5FileOrmGet( hashName, FRP_HASH | FRP_CACHE_DEFAULT,
      (void *)hashfile, HashLoadedCallback, HashLoadFailCallback );
   hashfile->signatureIndex = 0;
   success = LoadNextSignatureFile(hashfile);
   if (!success)
   {
      if (hashfile->hashData.data == &noFile)
      {
         hashfile->sameAsPrevious = MHEG5TRUE;
      }
      else
      {
         hashfile->hashData.data = &noFile;
         hashfile->sameAsPrevious = MHEG5FALSE;
      }
      hashfile->state = HASH_FILE_FAILED;
   }
   return success;
}

static MHEG5Bool LoadHashfile(U8BIT *url)
{
   HashfileData *listEntry;
   MHEG5String hashName;
   MHEG5Bool success;

   success = MHEG5FALSE;


   listEntry = MHEG5getMem(sizeof(HashfileData));
   if (listEntry != NULL)
   {
      listEntry->url = url;
      listEntry->hashData.len = 0;
      listEntry->hashData.data = NULL;
      listEntry->state = HASH_FILE_WAITING_FOR_HASH;
      listEntry->digestCount = 0;
      listEntry->sameAsPrevious = MHEG5FALSE;

      listEntry->signatureIndex = 0;
      listEntry->signature.len = 0;
      listEntry->signature.data = NULL;

      listEntry->digestList = NULL;

      /*put the new entry at the start of the list*/
      listEntry->next = hashfileList;
      listEntry->previous = NULL;
      hashfileList = listEntry;
      hashfileList->previous = listEntry;

      /*request the file*/
      hashName.data = url;
      hashName.len = strlen((char *)url);

      listEntry->state = HASH_FILE_WAITING_FOR_HASH_AND_SIG;
      (void)MHEG5FileOrmGet( hashName, FRP_HASH | FRP_CACHE_DEFAULT,
         (void *)listEntry, HashLoadedCallback, HashLoadFailCallback);

      success = LoadNextSignatureFile(listEntry);
   }

   return success;
}

static void HashLoadedCallback( void *userData, S_CONTENT *content )
{
   HashfileData *cacheHandle;
   HashfileData *listEntry;
   MHEG5String *currentFile;
   MHEG5String fileBuffer;
   MHEG5Bool success;
   MHEG5Bool call;
   int differ;

   cacheHandle = (HashfileData *)userData;
   listEntry = hashfileList;

   call = MHEG5FALSE;

   while (listEntry != NULL)
   {
      if (listEntry == cacheHandle)
      {
         break;
      }
      listEntry = listEntry->next;
   }

   if (listEntry != NULL)
   {
      currentFile = &cacheHandle->hashData;

      /*copy the data into a buffer*/
      fileBuffer.data = MHEG5getMem(content->size);
      if (fileBuffer.data != NULL)
      {
         memcpy(fileBuffer.data, content->data, content->size);
         fileBuffer.len = content->size;

         if (fileBuffer.len != currentFile->len)
         {
            cacheHandle->sameAsPrevious = MHEG5FALSE;
         }
         else if (currentFile->data == NULL || currentFile->data == &noFile)
         {
            cacheHandle->sameAsPrevious = MHEG5FALSE;
         }
         else
         {
            differ = memcmp(fileBuffer.data, currentFile->data, content->size);
            if (!differ)
            {
               cacheHandle->sameAsPrevious = MHEG5TRUE;
            }
            else
            {
               cacheHandle->sameAsPrevious = MHEG5FALSE;
            }
         }

         /*free any file already loaded and load new file*/
         if (currentFile->data != NULL && currentFile->data != &noFile)
         {
            MHEG5freeMem(currentFile->data);

            /* Free digest list */
            FreeDigestList(listEntry->digestList);
            listEntry->digestList = NULL;
         }

         currentFile->data = fileBuffer.data;
         currentFile->len = fileBuffer.len;

         success = ParseHashfile(cacheHandle);
         if (success)
         {
            if (cacheHandle->state == HASH_FILE_WAITING_FOR_HASH_AND_SIG)
            {
               cacheHandle->state = HASH_FILE_WAITING_FOR_SIG;
            }
            else
            {
               assert(cacheHandle->state == HASH_FILE_WAITING_FOR_HASH);
               VerifyHashfile(cacheHandle);
            }
         }
         else
         {
            if (cacheHandle->state == HASH_FILE_WAITING_FOR_HASH_AND_SIG)
            {
               cacheHandle->state = HASH_FILE_WAITING_FOR_SIG;
            }
            else
            {
               cacheHandle->state = HASH_FILE_FAILED;
               call = MHEG5TRUE;
            }
         }
      }
      else
      {
         if (cacheHandle->state == HASH_FILE_WAITING_FOR_HASH_AND_SIG)
         {
            cacheHandle->state = HASH_FILE_WAITING_FOR_SIG;
         }
         else
         {
            cacheHandle->state = HASH_FILE_FAILED;
            call = MHEG5TRUE;
         }
         cacheHandle->hashData.len = 0;
         if (cacheHandle->hashData.data != &noFile)
         {
            cacheHandle->hashData.data = &noFile;
            cacheHandle->sameAsPrevious = MHEG5FALSE;
         }
         else
         {
            cacheHandle->sameAsPrevious = MHEG5TRUE;
         }
      }
   }
   /*call the provided callback if required*/
   if (call && VerificationCallback != NULL)
   {
      VerificationCallback();
   }
}

static void HashLoadFailCallback( void *userData )
{
   HashfileData *cacheHandle;
   HashfileData *listEntry;
   MHEG5String *hashData;
   MHEG5Bool call;

   call = MHEG5FALSE;

   cacheHandle = (HashfileData *)userData;
   /*first ensure that the cache is still available
      it may have been reset while we were loading*/
   listEntry = hashfileList;
   while (listEntry != NULL)
   {
      if (listEntry == cacheHandle)
      {
         break;
      }
      listEntry = listEntry->next;
   }

   if (listEntry != NULL)
   {
      /*free any file already loaded*/
      hashData = &cacheHandle->hashData;

      if (hashData->data != NULL)
      {
         if (hashData->data == &noFile)
         {
            cacheHandle->sameAsPrevious = MHEG5TRUE;
         }
         else
         {
            MHEG5freeMem(hashData->data);
            hashData->len = 0;
            hashData->data = &noFile;
            cacheHandle->sameAsPrevious = MHEG5FALSE;
         }
      }
      else
      {
         hashData->len = 0;
         hashData->data = &noFile;
         cacheHandle->sameAsPrevious = MHEG5FALSE;
      }

      if (cacheHandle->state == HASH_FILE_WAITING_FOR_HASH_AND_SIG)
      {
         cacheHandle->state = HASH_FILE_WAITING_FOR_SIG;
      }
      else
      {
         cacheHandle->state = HASH_FILE_FAILED;
         call = MHEG5TRUE;
      }
   }

   /*call the provided callback if there is one*/
   if (call && VerificationCallback != NULL)
   {
      VerificationCallback();
   }
}

static MHEG5Bool ParseHashfile(HashfileData *hashfile)
{
   U32BIT fileSize;
   int i;
   U8BIT *fileData;
   U8BIT *dataEnd;
   U16BIT digestCount;
   HashDigest *previousDigest;
   MHEG5Bool success;
   MHEG5Bool continueParsing;

   /*buffers*/
   U16BIT nameCount;
   U8BIT type;
   U8BIT nameLength;
   U8BIT *name;
   U8BIT digestLength;
   U8BIT *digest;

   if (hashfile != NULL && hashfile->hashData.data != &noFile)
   {
      fileSize = hashfile->hashData.len;
      fileData = hashfile->hashData.data;
      dataEnd = fileData + fileSize;

      /*free the digest list if it already exists*/
      FreeDigestList(hashfile->digestList);
      hashfile->digestList = NULL;
   }
   else
   {
      fileSize = 0;
   }

   /*get the digest count*/
   if (fileSize >= 2)
   {
      digestCount = GET_16BITS_FROM_ARRAY(fileData, 0);
      fileData += 2;
      success = MHEG5TRUE;
      continueParsing = MHEG5TRUE;
   }
   else
   {
      success = MHEG5FALSE;
      continueParsing = MHEG5FALSE;
   }

   if (success)
   {
      /*if digest count is 0 then the file contains only a directory pathname*/
      if (digestCount == 0)
      {
         if (fileData + 2 <= dataEnd) /*make sure we have enough data*/
         {
            hashfile->digestPathname.len = GET_16BITS_FROM_ARRAY(fileData, 0);
            fileData += 2;
            hashfile->digestPathname.data = fileData;
         }
         else
         {
            success = MHEG5FALSE;
         }
      }
      else
      {
         /*digestCount > 0*/
         digestLength = 0;
         type = 0;
         nameCount = 0;

         previousDigest = NULL;
         for (i = 0; i < digestCount; i++)
         {
            if (continueParsing)
            {
               hashfile->digestList = MHEG5getMem(sizeof(HashDigest));
               if (hashfile->digestList != NULL)
               {
                  hashfile->digestList->next = previousDigest;
                  if (fileData + 1 <= dataEnd)
                  {
                     type = *fileData;
                     fileData++;

                     switch (type)
                     {
                        case 0:
                           digestLength = 0;
                           break;
                        case 2:
                           digestLength = 20;
                           break;
                        case 3:
                           digestLength = 20;
                           break;
                        default:
                           continueParsing = MHEG5FALSE;
                           break;
                     }
                  }
                  else
                  {
                     continueParsing = MHEG5FALSE;
                  }
               }
               else
               {
                  /*if there was an error allocating, save what we have*/
                  hashfile->digestList = previousDigest;
                  continueParsing = MHEG5FALSE;
               }
            }
            if (continueParsing)
            {
               if (fileData + 2 <= dataEnd)
               {
                  nameCount = GET_16BITS_FROM_ARRAY(fileData, 0);
                  fileData += 2;
               }
               else
               {
                  continueParsing = MHEG5FALSE;
               }
               if (continueParsing && nameCount != 1)
               {
                  continueParsing = MHEG5FALSE;
               }
            }

            if (continueParsing)
            {
               if (fileData + 1 <= dataEnd)
               {
                  nameLength = *fileData;
                  fileData++;
               }
               else
               {
                  continueParsing = MHEG5FALSE;
               }
            }

            if (continueParsing)
            {
               if (fileData + nameLength <= dataEnd)
               {
                  name = fileData;
                  fileData += nameLength;
               }
               else
               {
                  continueParsing = MHEG5FALSE;
               }
            }

            if (continueParsing)
            {
               if (fileData + digestLength <= dataEnd)
               {
                  digest = fileData;
                  fileData += digestLength;
               }
               else
               {
                  continueParsing = MHEG5FALSE;
               }
            }

            if (continueParsing)
            {
               hashfile->digestList->name = name;
               hashfile->digestList->nameLength = nameLength;
               hashfile->digestList->type = type;
               hashfile->digestList->digestLength = digestLength;
               hashfile->digestList->digest = digest;
               previousDigest = hashfile->digestList;
            }
         }
      }

      if (success)
      {
         hashfile->digestCount = digestCount;
      }
   }
   return success;
}

static void FreeDigestList(HashDigest *listStart)
{
   HashDigest *current;
   HashDigest *next;
   current = listStart;
   while (current != NULL)
   {
      next = current->next;
      MHEG5freeMem(current);
      current = next;
   }
}

void MHEG5ResetHashFile(U8BIT *url)
{
   HashfileData *hashfile;
   U8BIT *hashfileUrl;

   hashfileUrl = GetHashfileUrl(url);
   if (hashfileUrl != NULL)
   {
      hashfile = FindHashInfo(hashfileUrl);

      /*finished with the url string*/
      MHEG5freeMem(hashfileUrl);

      if (hashfile != NULL)
      {
         if (hashfile->state == HASH_FILE_FAILED ||
             hashfile->state == HASH_FILE_VERIFIED)
         {
            hashfile->state = HASH_FILE_RELOAD;
            if (hashfile->signature.data)
            {
               MHEG5freeMem(hashfile->signature.data);
               hashfile->signature.data = NULL;
               hashfile->signature.len = 0;
            }
            hashfile->signatureIndex = 0;
         }
         else
         {
            assert(0);
         }
      }
   }
}

static HashDigest* FindDigestForUrl(U8BIT *url, HashfileData *hashfile)
{
   U8BIT *name;
   U32BIT nameLength;
   HashDigest *digest;
   int differ;
   digest = NULL;

   name = (U8BIT *)strrchr((char *)url, '/') + 1;
   assert(name != NULL);
   nameLength = strlen((char *)name);

   digest = hashfile->digestList;
   while (digest != NULL)
   {
      if (nameLength == digest->nameLength)
      {
         differ = memcmp(name, digest->name, digest->nameLength);
         if (!differ)
         {
            break;
         }
      }
      digest = digest->next;
   }

   return digest;
}

static MHEG5Bool CheckUrlPath(U8BIT *url, HashfileData *hashfile)
{
   U16BIT urlDirectoryLength;
   U8BIT *hashDirectory;
   U16BIT hashDirectoryLength;
   MHEG5Bool success;
   U8BIT *slash;
   int differ;

   success = MHEG5TRUE;

   if (hashfile->digestCount != 0)
   {
      success = MHEG5FALSE;
   }

   if (success)
   {
      slash = (U8BIT *)strrchr((char *)url, '/');
      urlDirectoryLength = slash - url;
      hashDirectoryLength = (U16BIT)hashfile->digestPathname.len;
      hashDirectory = hashfile->digestPathname.data;

      if (hashDirectoryLength == 0 || hashDirectoryLength > urlDirectoryLength)
      {
         success = MHEG5FALSE;
      }
   }
   if (success)
   {
      differ = MHEG5strncmp(hashDirectory, url, hashDirectoryLength );
      if (differ)
      {
         success = MHEG5FALSE;
      }
   }
   if (success)
   {
      if (hashDirectory[hashDirectoryLength - 1] != '/' &&
          url[hashDirectoryLength] != '/')
      {
         success = MHEG5FALSE;
      }
   }

   return success;
}

static MHEG5Bool CheckHashes(U8BIT *content, U32BIT contentLength, HashDigest *digest)
{
   EVP_MD_CTX ctx;
   MHEG5Bool success;
   U8BIT contentDigest[EVP_MAX_MD_SIZE];
   U8BIT prefix[8];
   int differ;
   int digestSize;

   switch (digest->type)
   {
      case 0:
         success = MHEG5TRUE;
         break;
      case 2:
         /*type 2 is a straightforward hash-compare*/

         /*create the digest*/
         EVP_DigestInit(&ctx, EVP_sha1());
         EVP_DigestUpdate(&ctx, content, contentLength);
         digestSize = EVP_MD_CTX_size(&ctx);
         EVP_DigestFinal(&ctx, contentDigest, NULL);

         /*byte-compare it with the digest from the hashfile*/
         differ = memcmp(contentDigest, digest->digest, digestSize);
         if (!differ)
         {
            success = MHEG5TRUE;
         }
         else
         {
            success = MHEG5FALSE;
         }
         break;

      case 3:

         /*type 3 requires an 8 byte prefix*/
         /*1 in 32bit msbf form*/
         prefix[0] = 0;
         prefix[1] = 0;
         prefix[2] = 0;
         prefix[3] = 1;

         /*content length in 32bit msbf form*/
         prefix[4] = (U8BIT)(contentLength >> 24);
         prefix[5] = (U8BIT)(contentLength >> 16);
         prefix[6] = (U8BIT)(contentLength >> 8);
         prefix[7] = (U8BIT)contentLength;

         /*create the digest of the prefixed content*/
         EVP_DigestInit(&ctx, EVP_sha1());
         EVP_DigestUpdate(&ctx, prefix, 8);
         EVP_DigestUpdate(&ctx, content, contentLength);
         digestSize = EVP_MD_CTX_size(&ctx);
         EVP_DigestFinal(&ctx, contentDigest, NULL);

         /*byte-compare it with the digest from the hashfile*/
         differ = memcmp(contentDigest, digest->digest, digestSize);
         if (!differ)
         {
            success = MHEG5TRUE;
         }
         else
         {
            success = MHEG5FALSE;
         }
         break;

      default:
         success = MHEG5FALSE;
   }
   return success;
}

static void SigLoadFailCallback( void *userData )
{
   HashfileData *cacheHandle;
   HashfileData *listEntry;
   MHEG5Bool call;

   cacheHandle = (HashfileData *)userData;
   listEntry = hashfileList;

   call = MHEG5FALSE;
   while (listEntry != NULL)
   {
      if (listEntry == cacheHandle)
      {
         break;
      }
      listEntry = listEntry->next;
   }
   if (listEntry != NULL)
   {
      call = MHEG5TRUE;
      if (listEntry->state == HASH_FILE_WAITING_FOR_HASH_AND_SIG)
      {
         listEntry->state = HASH_FILE_WAITING_FOR_HASH;
      }
      else
      {
         assert(listEntry->state == HASH_FILE_WAITING_FOR_SIG);
         listEntry->state = HASH_FILE_FAILED;
      }
   }

   /*call the provided callback if there is one*/
   if (call && VerificationCallback)
   {
      VerificationCallback();
   }
}

static void SigLoadedCallback(void *userData, S_CONTENT *content )
{
   HashfileData *cacheHandle;
   HashfileData *listEntry;
   MHEG5String *currentFile;
   MHEG5Bool call;

   cacheHandle = (HashfileData *)userData;
   listEntry = hashfileList;

   call = MHEG5FALSE;
   while (listEntry != NULL)
   {
      if (listEntry == cacheHandle)
      {
         break;
      }
      listEntry = listEntry->next;
   }

   if (listEntry != NULL)
   {
      currentFile = &cacheHandle->signature;

      /*free any file already loaded*/
      if (currentFile->data)
      {
         MHEG5freeMem(currentFile->data);
         currentFile->data = NULL;
      }

      /*copy the data into cache*/
      currentFile->data = MHEG5getMem(content->size);
      if (currentFile->data != NULL)
      {
         currentFile->len = content->size;
         memcpy(currentFile->data, content->data, content->size);

         if (cacheHandle->state == HASH_FILE_WAITING_FOR_SIG)
         {
            VerifyHashfile(cacheHandle);
            call = MHEG5TRUE;
         }
         else
         {
            assert(cacheHandle->state == HASH_FILE_WAITING_FOR_HASH_AND_SIG);
            cacheHandle->state = HASH_FILE_WAITING_FOR_HASH;
         }
      }
      else
      {
         currentFile->len = 0;
         if (cacheHandle->state == HASH_FILE_WAITING_FOR_HASH_AND_SIG)
         {
            cacheHandle->state = HASH_FILE_WAITING_FOR_HASH;
         }
         else
         {
            cacheHandle->state = HASH_FILE_FAILED;
            call = MHEG5TRUE;
         }
      }
   }
   /*call the provided callback if there is one*/
   if (call && VerificationCallback)
   {
      VerificationCallback();
   }
}

static void VerifyHashfile(HashfileData *hashfile)
{
   MHEG5SigVerifyStatus_t status;

   if ((hashfile->signature.data != NULL) &&
       (hashfile->hashData.data != &noFile))
   {
      status = MHEG5IsValidSignature(&hashfile->hashData, &hashfile->signature);
      switch (status)
      {
         case MHEG5_SIG_VERIFIED:
            hashfile->state = HASH_FILE_VERIFIED;
            if (VerificationCallback)
            {
               VerificationCallback();
            }
            break;
         case MHEG5_SIG_NOT_VERIFIED:
            hashfile->state = HASH_FILE_WAITING_FOR_SIG;
            LoadNextSignatureFile(hashfile);
            break;
         case MHEG5_SIG_CHECK_PENDING:
            hashfile->state = HASH_FILE_WAITING_FOR_CERT;
            break;
         default:
            assert(0);
      }
   }
   else
   {
      /* Something wrong with signature or hash file */
      hashfile->state = HASH_FILE_FAILED;
   }
}

static MHEG5Bool LoadNextSignatureFile(HashfileData *hashfile)
{
   U8BIT *sigUrl;
   MHEG5String sigName;
   MHEG5Bool success;

   success = MHEG5FALSE;

   sigUrl = GetNextSigUrl(hashfile);
   if (sigUrl)
   {
      sigName.data = sigUrl;
      sigName.len = strlen((char *)sigUrl);
      (void)MHEG5FileOrmGet( sigName, FRP_HASH | FRP_CACHE_DEFAULT,
         (void *)hashfile, SigLoadedCallback, SigLoadFailCallback );

      MHEG5freeMem(sigUrl);
      if (hashfile->state == HASH_FILE_FAILED)
      {
         success = MHEG5FALSE;
      }
      else
      {
         success = MHEG5TRUE;
      }
   }

   return success;
}

static U8BIT* GetNextSigUrl(HashfileData *hashfile)
{
   U32BIT length;
   U8BIT *slash;
   U8BIT *sigUrl;
   U8BIT *sigName;
   U32BIT sigNameLen;

   sigName = (U8BIT *)"auth.sig.";
   sigNameLen = strlen((char *)sigName);

   slash = (U8BIT *)strrchr((char *)hashfile->url, '/');
   assert(slash != NULL);
   length = slash - hashfile->url + 1;

   sigUrl = MHEG5getMem(length + sigNameLen + 7);
   if (sigUrl != NULL)
   {
      memcpy(sigUrl, hashfile->url, length);
      memcpy(sigUrl + length, sigName, sigNameLen);

      hashfile->signatureIndex++;

      sprintf((char *)(sigUrl + length + sigNameLen), "%u", (unsigned int)hashfile->signatureIndex);
   }
   return sigUrl;
}

static void CertCallback(void)
{
   HashfileData *cacheEntry;

   cacheEntry = hashfileList;
   while (cacheEntry != NULL)
   {
      if (cacheEntry->state == HASH_FILE_WAITING_FOR_CERT)
      {
         VerifyHashfile(cacheEntry);
      }
      cacheEntry = cacheEntry->next;
   }
}