The Tor Browser: ipc/keystore/KeyStore.cpp@97036ab72558 (annotated)

ipc/keystore/KeyStore.cpp@97036ab72558 (annotated)

ipc/keystore/KeyStore.cpp

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /* vim: set sw=4 ts=8 et ft=cpp: */
 /* 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 <fcntl.h>
 #include <sys/stat.h>
 #undef CHROMIUM_LOG
 #if defined(MOZ_WIDGET_GONK)
 #include <android/log.h>
 #define CHROMIUM_LOG(args...)  __android_log_print(ANDROID_LOG_INFO, "Gonk", args)
 #else
 #define CHROMIUM_LOG(args...)  printf(args);
 #endif
 #include "KeyStore.h"
 #include "jsfriendapi.h"
 #include "MainThreadUtils.h" // For NS_IsMainThread.
 #include "plbase64.h"
 #include "certdb.h"
 #include "ScopedNSSTypes.h"
 using namespace mozilla::ipc;
 namespace mozilla {
 namespace ipc {
 static const char* KEYSTORE_SOCKET_NAME = "keystore";
 static const char* KEYSTORE_SOCKET_PATH = "/dev/socket/keystore";
 int
 KeyStoreConnector::Create()
 {
   MOZ_ASSERT(!NS_IsMainThread());
   int fd;
   unlink(KEYSTORE_SOCKET_PATH);
   fd = socket(AF_LOCAL, SOCK_STREAM, 0);
   if (fd < 0) {
     NS_WARNING("Could not open keystore socket!");
     return -1;
   }
   return fd;
 }
 bool
 KeyStoreConnector::CreateAddr(bool aIsServer,
                               socklen_t& aAddrSize,
                               sockaddr_any& aAddr,
                               const char* aAddress)
 {
   // Keystore socket must be server
   MOZ_ASSERT(aIsServer);
   aAddr.un.sun_family = AF_LOCAL;
   if(strlen(KEYSTORE_SOCKET_PATH) > sizeof(aAddr.un.sun_path)) {
       NS_WARNING("Address too long for socket struct!");
       return false;
   }
   strcpy((char*)&aAddr.un.sun_path, KEYSTORE_SOCKET_PATH);
   aAddrSize = strlen(KEYSTORE_SOCKET_PATH) + offsetof(struct sockaddr_un, sun_path) + 1;
   return true;
 }
 bool
 KeyStoreConnector::SetUp(int aFd)
 {
   return true;
 }
 bool
 KeyStoreConnector::SetUpListenSocket(int aFd)
 {
   // Allow access of wpa_supplicant(different user, differnt group)
   chmod(KEYSTORE_SOCKET_PATH, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH);
   return true;
 }
 void
 KeyStoreConnector::GetSocketAddr(const sockaddr_any& aAddr,
                                  nsAString& aAddrStr)
 {
   // Unused.
   MOZ_CRASH("This should never be called!");
 }
 static char *
 get_cert_db_filename(void *arg, int vers)
 {
   static char keystoreDbPath[] = "/data/misc/wifi/keystore";
   return keystoreDbPath;
 }
 KeyStore::KeyStore()
 {
   // Initial NSS
   certdb = CERT_GetDefaultCertDB();
   Listen();
 }
 void
 KeyStore::Shutdown()
 {
   mShutdown = true;
   CloseSocket();
 }
 void
 KeyStore::Listen()
 {
   ListenSocket(new KeyStoreConnector());
   ResetHandlerInfo();
 }
 void
 KeyStore::ResetHandlerInfo()
 {
   mHandlerInfo.state = STATE_IDLE;
   mHandlerInfo.command = 0;
   mHandlerInfo.paramCount = 0;
   mHandlerInfo.commandPattern = nullptr;
   for (int i = 0; i < MAX_PARAM; i++) {
     mHandlerInfo.param[i].length = 0;
     memset(mHandlerInfo.param[i].data, 0, VALUE_SIZE);
   }
 }
 bool
 KeyStore::CheckSize(UnixSocketRawData *aMessage, size_t aExpectSize)
 {
   return (aMessage->mSize - aMessage->mCurrentWriteOffset >= aExpectSize) ?
          true : false;
 }
 bool
 KeyStore::ReadCommand(UnixSocketRawData *aMessage)
 {
   if (mHandlerInfo.state != STATE_IDLE) {
     NS_WARNING("Wrong state in ReadCommand()!");
     return false;
   }
   if (!CheckSize(aMessage, 1)) {
     NS_WARNING("Data size error in ReadCommand()!");
     return false;
   }
   mHandlerInfo.command = aMessage->mData[aMessage->mCurrentWriteOffset];
   aMessage->mCurrentWriteOffset++;
   // Find corrsponding command pattern
   const struct ProtocolCommand *command = commands;
   while (command->command && command->command != mHandlerInfo.command) {
     command++;
   }
   if (!command->command) {
     NS_WARNING("Unsupported command!");
     return false;
   }
   // Get command pattern.
   mHandlerInfo.commandPattern = command;
   if (command->paramNum) {
     // Read command parameter if needed.
     mHandlerInfo.state = STATE_READ_PARAM_LEN;
   } else {
     mHandlerInfo.state = STATE_PROCESSING;
   }
   return true;
 }
 bool
 KeyStore::ReadLength(UnixSocketRawData *aMessage)
 {
   if (mHandlerInfo.state != STATE_READ_PARAM_LEN) {
     NS_WARNING("Wrong state in ReadLength()!");
     return false;
   }
   if (!CheckSize(aMessage, 2)) {
     NS_WARNING("Data size error in ReadLength()!");
     return false;
   }
   // Read length of command parameter.
   unsigned short dataLength;
   memcpy(&dataLength, &aMessage->mData[aMessage->mCurrentWriteOffset], 2);
   aMessage->mCurrentWriteOffset += 2;
   mHandlerInfo.param[mHandlerInfo.paramCount].length = ntohs(dataLength);
   mHandlerInfo.state = STATE_READ_PARAM_DATA;
   return true;
 }
 bool
 KeyStore::ReadData(UnixSocketRawData *aMessage)
 {
   if (mHandlerInfo.state != STATE_READ_PARAM_DATA) {
     NS_WARNING("Wrong state in ReadData()!");
     return false;
   }
   if (!CheckSize(aMessage, mHandlerInfo.param[mHandlerInfo.paramCount].length)) {
     NS_WARNING("Data size error in ReadData()!");
     return false;
   }
   // Read command parameter.
   memcpy(mHandlerInfo.param[mHandlerInfo.paramCount].data,
          &aMessage->mData[aMessage->mCurrentWriteOffset],
          mHandlerInfo.param[mHandlerInfo.paramCount].length);
   aMessage->mCurrentWriteOffset += mHandlerInfo.param[mHandlerInfo.paramCount].length;
   mHandlerInfo.paramCount++;
   if (mHandlerInfo.paramCount == mHandlerInfo.commandPattern->paramNum) {
     mHandlerInfo.state = STATE_PROCESSING;
   } else {
     mHandlerInfo.state = STATE_READ_PARAM_LEN;
   }
   return true;
 }
 // Transform base64 certification data into DER format
 void
 KeyStore::FormatCaData(const uint8_t *aCaData, int aCaDataLength,
                        const char *aName, const uint8_t **aFormatData,
                        int &aFormatDataLength)
 {
   int bufSize = strlen(CA_BEGIN) + strlen(CA_END) + strlen(CA_TAILER) * 2 +
                 strlen(aName) * 2 + aCaDataLength + aCaDataLength/CA_LINE_SIZE + 2;
   char *buf = (char *)malloc(bufSize);
   aFormatDataLength = bufSize;
   *aFormatData = (const uint8_t *)buf;
   char *ptr = buf;
   int len;
   // Create DER header.
   len = snprintf(ptr, bufSize, "%s%s%s", CA_BEGIN, aName, CA_TAILER);
   ptr += len;
   bufSize -= len;
   // Split base64 data in lines.
   int copySize;
   while (aCaDataLength > 0) {
     copySize = (aCaDataLength > CA_LINE_SIZE) ? CA_LINE_SIZE : aCaDataLength;
     memcpy(ptr, aCaData, copySize);
     ptr += copySize;
     aCaData += copySize;
     aCaDataLength -= copySize;
     bufSize -= copySize;
     *ptr = '\n';
     ptr++;
     bufSize--;
   }
   // Create DEA tailer.
   snprintf(ptr, bufSize, "%s%s%s", CA_END, aName, CA_TAILER);
 }
 // Status response
 void
 KeyStore::SendResponse(ResponseCode aResponse)
 {
   if (aResponse == NO_RESPONSE)
     return;
   uint8_t response = (uint8_t)aResponse;
   UnixSocketRawData* data = new UnixSocketRawData((const void *)&response, 1);
   SendSocketData(data);
 }
 // Data response
 void
 KeyStore::SendData(const uint8_t *aData, int aLength)
 {
   unsigned short dataLength = htons(aLength);
   UnixSocketRawData* length = new UnixSocketRawData((const void *)&dataLength, 2);
   SendSocketData(length);
   UnixSocketRawData* data = new UnixSocketRawData((const void *)aData, aLength);
   SendSocketData(data);
 }
 void
 KeyStore::ReceiveSocketData(nsAutoPtr<UnixSocketRawData>& aMessage)
 {
   MOZ_ASSERT(NS_IsMainThread());
   bool success = true;
   while (aMessage->mCurrentWriteOffset < aMessage->mSize ||
          mHandlerInfo.state == STATE_PROCESSING) {
     switch (mHandlerInfo.state) {
       case STATE_IDLE:
         success = ReadCommand(aMessage);
         break;
       case STATE_READ_PARAM_LEN:
         success = ReadLength(aMessage);
         break;
       case STATE_READ_PARAM_DATA:
         success = ReadData(aMessage);
         break;
       case STATE_PROCESSING:
         success = false;
         if (mHandlerInfo.command == 'g') {
           // Get CA
           const uint8_t *certData;
           int certDataLength;
           const char *certName = (const char *)mHandlerInfo.param[0].data;
           // Get cert from NSS by name
           ScopedCERTCertificate cert(CERT_FindCertByNickname(certdb, certName));
           if (!cert) {
             break;
           }
           char *certDER = PL_Base64Encode((const char *)cert->derCert.data,
                                           cert->derCert.len, nullptr);
           if (!certDER) {
             break;
           }
           FormatCaData((const uint8_t *)certDER, strlen(certDER), "CERTIFICATE",
                        &certData, certDataLength);
           PL_strfree(certDER);
           SendResponse(SUCCESS);
           SendData(certData, certDataLength);
           success = true;
           free((void *)certData);
         }
         ResetHandlerInfo();
         break;
     }
     if (!success) {
       SendResponse(PROTOCOL_ERROR);
       ResetHandlerInfo();
       return;
     }
   }
 }
 void
 KeyStore::OnConnectSuccess()
 {
   mShutdown = false;
 }
 void
 KeyStore::OnConnectError()
 {
   if (!mShutdown) {
     Listen();
   }
 }
 void
 KeyStore::OnDisconnect()
 {
   if (!mShutdown) {
     Listen();
   }
 }
 } // namespace ipc
 } // namespace mozilla

The Tor Browser / annotate

ipc/keystore/KeyStore.cpp@97036ab72558 (annotated)

ipc/keystore/KeyStore.cpp