The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

 /* vim:set ts=2 sw=2 sts=2 et cindent: */

 /* This Source Code Form is subject to the terms of the Mozilla Public

  * License, v. 2.0. If a copy of the MPL was not distributed with this

  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 #include <string.h>

 #include <stdlib.h>

 #include <fcntl.h>

 #include "bzlib.h"

 #include "archivereader.h"

 #include "errors.h"

 #ifdef XP_WIN

 #include "nsAlgorithm.h" // Needed by nsVersionComparator.cpp

 #include "updatehelper.h"

 #endif

 #define UPDATER_NO_STRING_GLUE_STL

 #include "nsVersionComparator.cpp"

 #undef UPDATER_NO_STRING_GLUE_STL

 #if defined(XP_UNIX)

 # include <sys/types.h>

 #elif defined(XP_WIN)

 # include <io.h>

 #endif

 static int inbuf_size  = 262144;

 static int outbuf_size = 262144;

 static char *inbuf  = nullptr;

 static char *outbuf = nullptr;

 #ifdef XP_WIN

 #include "resource.h"

 /**

  * Obtains the data of the specified resource name and type.

  *

  * @param  name The name ID of the resource

  * @param  type The type ID of the resource

  * @param  data Out parameter which sets the pointer to a buffer containing

  *                  the needed data.

  * @param  size Out parameter which sets the size of the returned data buffer 

  * @return TRUE on success

 */

 BOOL

 LoadFileInResource(int name, int type, const uint8_t *&data, uint32_t& size)

 {

   HMODULE handle = GetModuleHandle(nullptr);

   if (!handle) {

     return FALSE;

   }

   HRSRC resourceInfoBlockHandle = FindResource(handle, 

                                                MAKEINTRESOURCE(name),

                                                MAKEINTRESOURCE(type));

   if (!resourceInfoBlockHandle) {

     FreeLibrary(handle);

     return FALSE;

   }

   HGLOBAL resourceHandle = LoadResource(handle, resourceInfoBlockHandle);

   if (!resourceHandle) {

     FreeLibrary(handle);

     return FALSE;

   }

   size = SizeofResource(handle, resourceInfoBlockHandle);

   data = static_cast<const uint8_t*>(::LockResource(resourceHandle));

   FreeLibrary(handle);

   return TRUE;

 }

 /**

  * Performs a verification on the opened MAR file with the passed in

  * certificate name ID and type ID.

  *

  * @param  archive   The MAR file to verify the signature on

  * @param  name      The name ID of the resource

  * @param  type      THe type ID of the resource

  * @return OK on success, CERT_LOAD_ERROR or CERT_VERIFY_ERROR on failure.

 */

 int

 VerifyLoadedCert(MarFile *archive, int name, int type)

 {

   uint32_t size = 0;

   const uint8_t *data = nullptr;

   if (!LoadFileInResource(name, type, data, size) || !data || !size) {

     return CERT_LOAD_ERROR;

   }

   if (mar_verify_signaturesW(archive, &data, &size, 1)) {

     return CERT_VERIFY_ERROR;

   }

   return OK;

 }

 #endif

 /**

  * Performs a verification on the opened MAR file.  Both the primary and backup 

  * keys stored are stored in the current process and at least the primary key 

  * will be tried.  Success will be returned as long as one of the two 

  * signatures verify.

  *

  * @return OK on success

 */

 int

 ArchiveReader::VerifySignature()

 {

   if (!mArchive) {

     return ARCHIVE_NOT_OPEN;

   }

 #ifdef XP_WIN

   // If the fallback key exists we're running an XPCShell test and we should

   // use the XPCShell specific cert for the signed MAR.

   int rv;

   if (DoesFallbackKeyExist()) {

     rv = VerifyLoadedCert(mArchive, IDR_XPCSHELL_CERT, TYPE_CERT);

   } else {

     rv = VerifyLoadedCert(mArchive, IDR_PRIMARY_CERT, TYPE_CERT);

     if (rv != OK) {

       rv = VerifyLoadedCert(mArchive, IDR_BACKUP_CERT, TYPE_CERT);

     }

   }

   return rv;

 #else

   return OK;

 #endif

 }

 /**

  * Verifies that the MAR file matches the current product, channel, and version

  * 

  * @param MARChannelID   The MAR channel name to use, only updates from MARs

  *                       with a matching MAR channel name will succeed.

  *                       If an empty string is passed, no check will be done

  *                       for the channel name in the product information block.

  *                       If a comma separated list of values is passed then

  *                       one value must match.

  * @param appVersion     The application version to use, only MARs with an

  *                       application version >= to appVersion will be applied.

  * @return OK on success

  *         COULD_NOT_READ_PRODUCT_INFO_BLOCK if the product info block 

  *                                           could not be read.

  *         MARCHANNEL_MISMATCH_ERROR         if update-settings.ini's MAR 

  *                                           channel ID doesn't match the MAR

  *                                           file's MAR channel ID. 

  *         VERSION_DOWNGRADE_ERROR           if the application version for

  *                                           this updater is newer than the

  *                                           one in the MAR.

  */

 int

 ArchiveReader::VerifyProductInformation(const char *MARChannelID, 

                                         const char *appVersion)

 {

   if (!mArchive) {

     return ARCHIVE_NOT_OPEN;

   }

   ProductInformationBlock productInfoBlock;

   int rv = mar_read_product_info_block(mArchive, 

                                        &productInfoBlock);

   if (rv != OK) {

     return COULD_NOT_READ_PRODUCT_INFO_BLOCK_ERROR;

   }

   // Only check the MAR channel name if specified, it should be passed in from

   // the update-settings.ini file.

   if (MARChannelID && strlen(MARChannelID)) {

     // Check for at least one match in the comma separated list of values.

     const char *delimiter = " ,\t";

     // Make a copy of the string in case a read only memory buffer 

     // was specified.  strtok modifies the input buffer.

     char channelCopy[512] = { 0 };

     strncpy(channelCopy, MARChannelID, sizeof(channelCopy) - 1);

     char *channel = strtok(channelCopy, delimiter);

     rv = MAR_CHANNEL_MISMATCH_ERROR;

     while(channel) {

       if (!strcmp(channel, productInfoBlock.MARChannelID)) {

         rv = OK;

         break;

       }

       channel = strtok(nullptr, delimiter);

     }

   }

   if (rv == OK) {

     /* Compare both versions to ensure we don't have a downgrade

         -1 if appVersion is older than productInfoBlock.productVersion

         1 if appVersion is newer than productInfoBlock.productVersion

         0 if appVersion is the same as productInfoBlock.productVersion

        This even works with strings like:

         - 12.0a1 being older than 12.0a2

         - 12.0a2 being older than 12.0b1

         - 12.0a1 being older than 12.0

         - 12.0 being older than 12.1a1 */

     int versionCompareResult = 

       mozilla::CompareVersions(appVersion, productInfoBlock.productVersion);

     if (1 == versionCompareResult) {

       rv = VERSION_DOWNGRADE_ERROR;

     }

   }

   free((void *)productInfoBlock.MARChannelID);

   free((void *)productInfoBlock.productVersion);

   return rv;

 }

 int

 ArchiveReader::Open(const NS_tchar *path)

 {

   if (mArchive)

     Close();

   if (!inbuf) {

     inbuf = (char *)malloc(inbuf_size);

     if (!inbuf) {

       // Try again with a smaller buffer.

       inbuf_size = 1024;

       inbuf = (char *)malloc(inbuf_size);

       if (!inbuf)

         return ARCHIVE_READER_MEM_ERROR;

     }

   }

   if (!outbuf) {

     outbuf = (char *)malloc(outbuf_size);

     if (!outbuf) {

       // Try again with a smaller buffer.

       outbuf_size = 1024;

       outbuf = (char *)malloc(outbuf_size);

       if (!outbuf)

         return ARCHIVE_READER_MEM_ERROR;

     }

   }

 #ifdef XP_WIN

   mArchive = mar_wopen(path);

 #else

   mArchive = mar_open(path);

 #endif

   if (!mArchive)

     return READ_ERROR;

   return OK;

 }

 void

 ArchiveReader::Close()

 {

   if (mArchive) {

     mar_close(mArchive);

     mArchive = nullptr;

   }

   if (inbuf) {

     free(inbuf);

     inbuf = nullptr;

   }

   if (outbuf) {

     free(outbuf);

     outbuf = nullptr;

   }

 }

 int

 ArchiveReader::ExtractFile(const char *name, const NS_tchar *dest)

 {

   const MarItem *item = mar_find_item(mArchive, name);

   if (!item)

     return READ_ERROR;

 #ifdef XP_WIN

   FILE* fp = _wfopen(dest, L"wb+");

 #else

   int fd = creat(dest, item->flags);

   if (fd == -1)

     return WRITE_ERROR;

   FILE *fp = fdopen(fd, "wb");

 #endif

   if (!fp)

     return WRITE_ERROR;

   int rv = ExtractItemToStream(item, fp);

   fclose(fp);

   return rv;

 }

 int

 ArchiveReader::ExtractFileToStream(const char *name, FILE *fp)

 {

   const MarItem *item = mar_find_item(mArchive, name);

   if (!item)

     return READ_ERROR;

   return ExtractItemToStream(item, fp);

 }

 int

 ArchiveReader::ExtractItemToStream(const MarItem *item, FILE *fp)

 {

   /* decompress the data chunk by chunk */

   bz_stream strm;

   int offset, inlen, outlen, ret = OK;

   memset(&strm, 0, sizeof(strm));

   if (BZ2_bzDecompressInit(&strm, 0, 0) != BZ_OK)

     return UNEXPECTED_BZIP_ERROR;

   offset = 0;

   for (;;) {

     if (!item->length) {

       ret = UNEXPECTED_MAR_ERROR;

       break;

     }

     if (offset < (int) item->length && strm.avail_in == 0) {

       inlen = mar_read(mArchive, item, offset, inbuf, inbuf_size);

       if (inlen <= 0)

         return READ_ERROR;

       offset += inlen;

       strm.next_in = inbuf;

       strm.avail_in = inlen;

     }

     strm.next_out = outbuf;

     strm.avail_out = outbuf_size;

     ret = BZ2_bzDecompress(&strm);

     if (ret != BZ_OK && ret != BZ_STREAM_END) {

       ret = UNEXPECTED_BZIP_ERROR;

       break;

     }

     outlen = outbuf_size - strm.avail_out;

     if (outlen) {

       if (fwrite(outbuf, outlen, 1, fp) != 1) {

         ret = WRITE_ERROR;

         break;

       }

     }

     if (ret == BZ_STREAM_END) {

       ret = OK;

       break;

     }

   }

   BZ2_bzDecompressEnd(&strm);

   return ret;

 }