/* * Copyright (C) 2010 The Android Open Source Project * * 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 * * 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. */ #include #include #include #include #include #include #include #include #include #include #include #include "FwdLockConv.h" #include "FwdLockGlue.h" #define TRUE 1 #define FALSE 0 #define INVALID_OFFSET ((off64_t)-1) #define MAX_NUM_SESSIONS 32 #define OUTPUT_BUFFER_SIZE_INCREMENT 1024 #define READ_BUFFER_SIZE 1024 #define MAX_BOUNDARY_LENGTH 70 #define MAX_DELIMITER_LENGTH (MAX_BOUNDARY_LENGTH + 4) #define STRING_LENGTH_INCREMENT 25 #define KEY_SIZE AES_BLOCK_SIZE #define KEY_SIZE_IN_BITS (KEY_SIZE * 8) #define SHA1_HASH_SIZE 20 #define FWD_LOCK_VERSION 0 #define FWD_LOCK_SUBFORMAT 0 #define USAGE_RESTRICTION_FLAGS 0 #define CONTENT_TYPE_LENGTH_POS 7 #define TOP_HEADER_SIZE 8 /** * Data type for the parser states of the converter. */ typedef enum FwdLockConv_ParserState { FwdLockConv_ParserState_WantsOpenDelimiter, FwdLockConv_ParserState_WantsMimeHeaders, FwdLockConv_ParserState_WantsBinaryEncodedData, FwdLockConv_ParserState_WantsBase64EncodedData, FwdLockConv_ParserState_Done } FwdLockConv_ParserState_t; /** * Data type for the scanner states of the converter. */ typedef enum FwdLockConv_ScannerState { FwdLockConv_ScannerState_WantsFirstDash, FwdLockConv_ScannerState_WantsSecondDash, FwdLockConv_ScannerState_WantsCR, FwdLockConv_ScannerState_WantsLF, FwdLockConv_ScannerState_WantsBoundary, FwdLockConv_ScannerState_WantsBoundaryEnd, FwdLockConv_ScannerState_WantsMimeHeaderNameStart, FwdLockConv_ScannerState_WantsMimeHeaderName, FwdLockConv_ScannerState_WantsMimeHeaderNameEnd, FwdLockConv_ScannerState_WantsContentTypeStart, FwdLockConv_ScannerState_WantsContentType, FwdLockConv_ScannerState_WantsContentTransferEncodingStart, FwdLockConv_ScannerState_Wants_A_OR_I, FwdLockConv_ScannerState_Wants_N, FwdLockConv_ScannerState_Wants_A, FwdLockConv_ScannerState_Wants_R, FwdLockConv_ScannerState_Wants_Y, FwdLockConv_ScannerState_Wants_S, FwdLockConv_ScannerState_Wants_E, FwdLockConv_ScannerState_Wants_6, FwdLockConv_ScannerState_Wants_4, FwdLockConv_ScannerState_Wants_B, FwdLockConv_ScannerState_Wants_I, FwdLockConv_ScannerState_Wants_T, FwdLockConv_ScannerState_WantsContentTransferEncodingEnd, FwdLockConv_ScannerState_WantsMimeHeaderValueEnd, FwdLockConv_ScannerState_WantsMimeHeadersEnd, FwdLockConv_ScannerState_WantsByte1, FwdLockConv_ScannerState_WantsByte1_AfterCRLF, FwdLockConv_ScannerState_WantsByte2, FwdLockConv_ScannerState_WantsByte3, FwdLockConv_ScannerState_WantsByte4, FwdLockConv_ScannerState_WantsPadding, FwdLockConv_ScannerState_WantsWhitespace, FwdLockConv_ScannerState_WantsWhitespace_AfterCRLF, FwdLockConv_ScannerState_WantsDelimiter } FwdLockConv_ScannerState_t; /** * Data type for the content transfer encoding. */ typedef enum FwdLockConv_ContentTransferEncoding { FwdLockConv_ContentTransferEncoding_Undefined, FwdLockConv_ContentTransferEncoding_Binary, FwdLockConv_ContentTransferEncoding_Base64 } FwdLockConv_ContentTransferEncoding_t; /** * Data type for a dynamically growing string. */ typedef struct FwdLockConv_String { char *ptr; size_t length; size_t maxLength; size_t lengthIncrement; } FwdLockConv_String_t; /** * Data type for the per-file state information needed by the converter. */ typedef struct FwdLockConv_Session { FwdLockConv_ParserState_t parserState; FwdLockConv_ScannerState_t scannerState; FwdLockConv_ScannerState_t savedScannerState; off64_t numCharsConsumed; char delimiter[MAX_DELIMITER_LENGTH]; size_t delimiterLength; size_t delimiterMatchPos; FwdLockConv_String_t mimeHeaderName; FwdLockConv_String_t contentType; FwdLockConv_ContentTransferEncoding_t contentTransferEncoding; unsigned char sessionKey[KEY_SIZE]; void *pEncryptedSessionKey; size_t encryptedSessionKeyLength; AES_KEY encryptionRoundKeys; HMAC_CTX signingContext; unsigned char topHeader[TOP_HEADER_SIZE]; unsigned char counter[AES_BLOCK_SIZE]; unsigned char keyStream[AES_BLOCK_SIZE]; int keyStreamIndex; unsigned char ch; size_t outputBufferSize; size_t dataOffset; size_t numDataBytes; } FwdLockConv_Session_t; static FwdLockConv_Session_t *sessionPtrs[MAX_NUM_SESSIONS] = { NULL }; static pthread_mutex_t sessionAcquisitionMutex = PTHREAD_MUTEX_INITIALIZER; static const FwdLockConv_String_t nullString = { NULL, 0, 0, STRING_LENGTH_INCREMENT }; static const unsigned char topHeaderTemplate[] = { 'F', 'W', 'L', 'K', FWD_LOCK_VERSION, FWD_LOCK_SUBFORMAT, USAGE_RESTRICTION_FLAGS }; static const char strContent[] = "content-"; static const char strType[] = "type"; static const char strTransferEncoding[] = "transfer-encoding"; static const char strTextPlain[] = "text/plain"; static const char strApplicationVndOmaDrmRightsXml[] = "application/vnd.oma.drm.rights+xml"; static const char strApplicationVndOmaDrmContent[] = "application/vnd.oma.drm.content"; static const size_t strlenContent = sizeof strContent - 1; static const size_t strlenTextPlain = sizeof strTextPlain - 1; static const signed char base64Values[] = { -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, -2, -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 }; /** * Acquires an unused converter session. * * @return A session ID. */ static int FwdLockConv_AcquireSession() { int sessionId = -1; int i; pthread_mutex_lock(&sessionAcquisitionMutex); for (i = 0; i < MAX_NUM_SESSIONS; ++i) { if (sessionPtrs[i] == NULL) { sessionPtrs[i] = malloc(sizeof *sessionPtrs[i]); if (sessionPtrs[i] != NULL) { sessionId = i; } break; } } pthread_mutex_unlock(&sessionAcquisitionMutex); return sessionId; } /** * Checks whether a session ID is in range and currently in use. * * @param[in] sessionID A session ID. * * @return A Boolean value indicating whether the session ID is in range and currently in use. */ static int FwdLockConv_IsValidSession(int sessionId) { return 0 <= sessionId && sessionId < MAX_NUM_SESSIONS && sessionPtrs[sessionId] != NULL; } /** * Releases a converter session. * * @param[in] sessionID A session ID. */ static void FwdLockConv_ReleaseSession(int sessionId) { pthread_mutex_lock(&sessionAcquisitionMutex); assert(FwdLockConv_IsValidSession(sessionId)); memset(sessionPtrs[sessionId], 0, sizeof *sessionPtrs[sessionId]); // Zero out key data. free(sessionPtrs[sessionId]); sessionPtrs[sessionId] = NULL; pthread_mutex_unlock(&sessionAcquisitionMutex); } /** * Derives cryptographically independent keys for encryption and signing from the session key. * * @param[in,out] pSession A reference to a converter session. * * @return A status code. */ static int FwdLockConv_DeriveKeys(FwdLockConv_Session_t *pSession) { FwdLockConv_Status_t status; struct FwdLockConv_DeriveKeys_Data { AES_KEY sessionRoundKeys; unsigned char value[KEY_SIZE]; unsigned char key[KEY_SIZE]; }; const size_t kSize = sizeof(struct FwdLockConv_DeriveKeys_Data); struct FwdLockConv_DeriveKeys_Data *pData = malloc(kSize); if (pData == NULL) { status = FwdLockConv_Status_OutOfMemory; } else { if (AES_set_encrypt_key(pSession->sessionKey, KEY_SIZE_IN_BITS, &pData->sessionRoundKeys) != 0) { status = FwdLockConv_Status_ProgramError; } else { // Encrypt the 16-byte value {0, 0, ..., 0} to produce the encryption key. memset(pData->value, 0, KEY_SIZE); AES_encrypt(pData->value, pData->key, &pData->sessionRoundKeys); if (AES_set_encrypt_key(pData->key, KEY_SIZE_IN_BITS, &pSession->encryptionRoundKeys) != 0) { status = FwdLockConv_Status_ProgramError; } else { // Encrypt the 16-byte value {1, 0, ..., 0} to produce the signing key. ++pData->value[0]; AES_encrypt(pData->value, pData->key, &pData->sessionRoundKeys); HMAC_CTX_init(&pSession->signingContext); HMAC_Init_ex(&pSession->signingContext, pData->key, KEY_SIZE, EVP_sha1(), NULL); status = FwdLockConv_Status_OK; } } memset(pData, 0, kSize); // Zero out key data. free(pData); } return status; } /** * Checks whether a given character is valid in a boundary. Allows some non-standard characters that * are invalid according to RFC 2046 but nevertheless used by one vendor's DRM packager. Note that * the boundary may contain leading and internal spaces. * * @param[in] ch The character to check. * * @return A Boolean value indicating whether the given character is valid in a boundary. */ static int FwdLockConv_IsBoundaryChar(int ch) { return isalnum(ch) || ch == '\'' || ch == '(' || ch == ')' || ch == '+' || ch == '_' || ch == ',' || ch == '-' || ch == '.' || ch == '/' || ch == ':' || ch == '=' || ch == '?' || ch == ' ' || ch == '%' || ch == '[' || ch == '&' || ch == '*' || ch == '^'; } /** * Checks whether a given character should be considered whitespace, using a narrower definition * than the standard-library isspace() function. * * @param[in] ch The character to check. * * @return A Boolean value indicating whether the given character should be considered whitespace. */ static int FwdLockConv_IsWhitespace(int ch) { return ch == ' ' || ch == '\t'; } /** * Removes trailing spaces from the delimiter. * * @param[in,out] pSession A reference to a converter session. * * @return A status code. */ static FwdLockConv_Status_t FwdLockConv_RightTrimDelimiter(FwdLockConv_Session_t *pSession) { while (pSession->delimiterLength > 4 && pSession->delimiter[pSession->delimiterLength - 1] == ' ') { --pSession->delimiterLength; } if (pSession->delimiterLength > 4) { return FwdLockConv_Status_OK; } return FwdLockConv_Status_SyntaxError; } /** * Matches the open delimiter. * * @param[in,out] pSession A reference to a converter session. * @param[in] ch A character. * * @return A status code. */ static FwdLockConv_Status_t FwdLockConv_MatchOpenDelimiter(FwdLockConv_Session_t *pSession, int ch) { FwdLockConv_Status_t status = FwdLockConv_Status_OK; switch (pSession->scannerState) { case FwdLockConv_ScannerState_WantsFirstDash: if (ch == '-') { pSession->scannerState = FwdLockConv_ScannerState_WantsSecondDash; } else if (ch == '\r') { pSession->scannerState = FwdLockConv_ScannerState_WantsLF; } else { pSession->scannerState = FwdLockConv_ScannerState_WantsCR; } break; case FwdLockConv_ScannerState_WantsSecondDash: if (ch == '-') { // The delimiter starts with "\r\n--" (the open delimiter may omit the initial "\r\n"). // The rest is the user-defined boundary that should come next. pSession->delimiter[0] = '\r'; pSession->delimiter[1] = '\n'; pSession->delimiter[2] = '-'; pSession->delimiter[3] = '-'; pSession->delimiterLength = 4; pSession->scannerState = FwdLockConv_ScannerState_WantsBoundary; } else if (ch == '\r') { pSession->scannerState = FwdLockConv_ScannerState_WantsLF; } else { pSession->scannerState = FwdLockConv_ScannerState_WantsCR; } break; case FwdLockConv_ScannerState_WantsCR: if (ch == '\r') { pSession->scannerState = FwdLockConv_ScannerState_WantsLF; } break; case FwdLockConv_ScannerState_WantsLF: if (ch == '\n') { pSession->scannerState = FwdLockConv_ScannerState_WantsFirstDash; } else if (ch != '\r') { pSession->scannerState = FwdLockConv_ScannerState_WantsCR; } break; case FwdLockConv_ScannerState_WantsBoundary: if (FwdLockConv_IsBoundaryChar(ch)) { // The boundary may contain leading and internal spaces, so trailing spaces will also be // matched here. These will be removed later. if (pSession->delimiterLength < MAX_DELIMITER_LENGTH) { pSession->delimiter[pSession->delimiterLength++] = ch; } else if (ch != ' ') { status = FwdLockConv_Status_SyntaxError; } } else if (ch == '\r') { status = FwdLockConv_RightTrimDelimiter(pSession); if (status == FwdLockConv_Status_OK) { pSession->scannerState = FwdLockConv_ScannerState_WantsBoundaryEnd; } } else if (ch == '\t') { status = FwdLockConv_RightTrimDelimiter(pSession); if (status == FwdLockConv_Status_OK) { pSession->scannerState = FwdLockConv_ScannerState_WantsWhitespace; } } else { status = FwdLockConv_Status_SyntaxError; } break; case FwdLockConv_ScannerState_WantsWhitespace: if (ch == '\r') { pSession->scannerState = FwdLockConv_ScannerState_WantsBoundaryEnd; } else if (!FwdLockConv_IsWhitespace(ch)) { status = FwdLockConv_Status_SyntaxError; } break; case FwdLockConv_ScannerState_WantsBoundaryEnd: if (ch == '\n') { pSession->parserState = FwdLockConv_ParserState_WantsMimeHeaders; pSession->scannerState = FwdLockConv_ScannerState_WantsMimeHeaderNameStart; } else { status = FwdLockConv_Status_SyntaxError; } break; default: status = FwdLockConv_Status_ProgramError; break; } return status; } /** * Checks whether a given character is valid in a MIME header name. * * @param[in] ch The character to check. * * @return A Boolean value indicating whether the given character is valid in a MIME header name. */ static int FwdLockConv_IsMimeHeaderNameChar(int ch) { return isgraph(ch) && ch != ':'; } /** * Checks whether a given character is valid in a MIME header value. * * @param[in] ch The character to check. * * @return A Boolean value indicating whether the given character is valid in a MIME header value. */ static int FwdLockConv_IsMimeHeaderValueChar(int ch) { return isgraph(ch) && ch != ';'; } /** * Appends a character to the specified dynamically growing string. * * @param[in,out] pString A reference to a dynamically growing string. * @param[in] ch The character to append. * * @return A status code. */ static FwdLockConv_Status_t FwdLockConv_StringAppend(FwdLockConv_String_t *pString, int ch) { if (pString->length == pString->maxLength) { size_t newMaxLength = pString->maxLength + pString->lengthIncrement; char *newPtr = realloc(pString->ptr, newMaxLength + 1); if (newPtr == NULL) { return FwdLockConv_Status_OutOfMemory; } pString->ptr = newPtr; pString->maxLength = newMaxLength; } pString->ptr[pString->length++] = ch; pString->ptr[pString->length] = '\0'; return FwdLockConv_Status_OK; } /** * Attempts to recognize the MIME header name and changes the scanner state accordingly. * * @param[in,out] pSession A reference to a converter session. * * @return A status code. */ static FwdLockConv_Status_t FwdLockConv_RecognizeMimeHeaderName(FwdLockConv_Session_t *pSession) { FwdLockConv_Status_t status = FwdLockConv_Status_OK; if (strncmp(pSession->mimeHeaderName.ptr, strContent, strlenContent) == 0) { if (strcmp(pSession->mimeHeaderName.ptr + strlenContent, strType) == 0) { if (pSession->contentType.ptr == NULL) { pSession->scannerState = FwdLockConv_ScannerState_WantsContentTypeStart; } else { status = FwdLockConv_Status_SyntaxError; } } else if (strcmp(pSession->mimeHeaderName.ptr + strlenContent, strTransferEncoding) == 0) { if (pSession->contentTransferEncoding == FwdLockConv_ContentTransferEncoding_Undefined) { pSession->scannerState = FwdLockConv_ScannerState_WantsContentTransferEncodingStart; } else { status = FwdLockConv_Status_SyntaxError; } } else { pSession->scannerState = FwdLockConv_ScannerState_WantsCR; } } else { pSession->scannerState = FwdLockConv_ScannerState_WantsCR; } return status; } /** * Applies defaults to missing MIME header values. * * @param[in,out] pSession A reference to a converter session. * * @return A status code. */ static FwdLockConv_Status_t FwdLockConv_ApplyDefaults(FwdLockConv_Session_t *pSession) { if (pSession->contentType.ptr == NULL) { // Content type is missing: default to "text/plain". pSession->contentType.ptr = malloc(sizeof strTextPlain); if (pSession->contentType.ptr == NULL) { return FwdLockConv_Status_OutOfMemory; } memcpy(pSession->contentType.ptr, strTextPlain, sizeof strTextPlain); pSession->contentType.length = strlenTextPlain; pSession->contentType.maxLength = strlenTextPlain; } if (pSession->contentTransferEncoding == FwdLockConv_ContentTransferEncoding_Undefined) { // Content transfer encoding is missing: default to binary. pSession->contentTransferEncoding = FwdLockConv_ContentTransferEncoding_Binary; } return FwdLockConv_Status_OK; } /** * Verifies that the content type is supported. * * @param[in,out] pSession A reference to a converter session. * * @return A status code. */ static FwdLockConv_Status_t FwdLockConv_VerifyContentType(FwdLockConv_Session_t *pSession) { FwdLockConv_Status_t status; if (pSession->contentType.ptr == NULL) { status = FwdLockConv_Status_ProgramError; } else if (strcmp(pSession->contentType.ptr, strApplicationVndOmaDrmRightsXml) == 0 || strcmp(pSession->contentType.ptr, strApplicationVndOmaDrmContent) == 0) { status = FwdLockConv_Status_UnsupportedFileFormat; } else { status = FwdLockConv_Status_OK; } return status; } /** * Writes the header of the output file. * * @param[in,out] pSession A reference to a converter session. * @param[out] pOutput The output from the conversion process. * * @return A status code. */ static FwdLockConv_Status_t FwdLockConv_WriteHeader(FwdLockConv_Session_t *pSession, FwdLockConv_Output_t *pOutput) { FwdLockConv_Status_t status; if (pSession->contentType.length > UCHAR_MAX) { status = FwdLockConv_Status_SyntaxError; } else { pSession->outputBufferSize = OUTPUT_BUFFER_SIZE_INCREMENT; pOutput->fromConvertData.pBuffer = malloc(pSession->outputBufferSize); if (pOutput->fromConvertData.pBuffer == NULL) { status = FwdLockConv_Status_OutOfMemory; } else { size_t encryptedSessionKeyPos = TOP_HEADER_SIZE + pSession->contentType.length; size_t dataSignaturePos = encryptedSessionKeyPos + pSession->encryptedSessionKeyLength; size_t headerSignaturePos = dataSignaturePos + SHA1_HASH_SIZE; pSession->dataOffset = headerSignaturePos + SHA1_HASH_SIZE; memcpy(pSession->topHeader, topHeaderTemplate, sizeof topHeaderTemplate); pSession->topHeader[CONTENT_TYPE_LENGTH_POS] = (unsigned char)pSession->contentType.length; memcpy(pOutput->fromConvertData.pBuffer, pSession->topHeader, TOP_HEADER_SIZE); memcpy((char *)pOutput->fromConvertData.pBuffer + TOP_HEADER_SIZE, pSession->contentType.ptr, pSession->contentType.length); memcpy((char *)pOutput->fromConvertData.pBuffer + encryptedSessionKeyPos, pSession->pEncryptedSessionKey, pSession->encryptedSessionKeyLength); // Set the signatures to all zeros for now; they will have to be updated later. memset((char *)pOutput->fromConvertData.pBuffer + dataSignaturePos, 0, SHA1_HASH_SIZE); memset((char *)pOutput->fromConvertData.pBuffer + headerSignaturePos, 0, SHA1_HASH_SIZE); pOutput->fromConvertData.numBytes = pSession->dataOffset; status = FwdLockConv_Status_OK; } } return status; } /** * Matches the MIME headers. * * @param[in,out] pSession A reference to a converter session. * @param[in] ch A character. * @param[out] pOutput The output from the conversion process. * * @return A status code. */ static FwdLockConv_Status_t FwdLockConv_MatchMimeHeaders(FwdLockConv_Session_t *pSession, int ch, FwdLockConv_Output_t *pOutput) { FwdLockConv_Status_t status = FwdLockConv_Status_OK; switch (pSession->scannerState) { case FwdLockConv_ScannerState_WantsMimeHeaderNameStart: if (FwdLockConv_IsMimeHeaderNameChar(ch)) { pSession->mimeHeaderName.length = 0; status = FwdLockConv_StringAppend(&pSession->mimeHeaderName, tolower(ch)); if (status == FwdLockConv_Status_OK) { pSession->scannerState = FwdLockConv_ScannerState_WantsMimeHeaderName; } } else if (ch == '\r') { pSession->scannerState = FwdLockConv_ScannerState_WantsMimeHeadersEnd; } else if (!FwdLockConv_IsWhitespace(ch)) { status = FwdLockConv_Status_SyntaxError; } break; case FwdLockConv_ScannerState_WantsMimeHeaderName: if (FwdLockConv_IsMimeHeaderNameChar(ch)) { status = FwdLockConv_StringAppend(&pSession->mimeHeaderName, tolower(ch)); } else if (ch == ':') { status = FwdLockConv_RecognizeMimeHeaderName(pSession); } else if (FwdLockConv_IsWhitespace(ch)) { pSession->scannerState = FwdLockConv_ScannerState_WantsMimeHeaderNameEnd; } else { status = FwdLockConv_Status_SyntaxError; } break; case FwdLockConv_ScannerState_WantsMimeHeaderNameEnd: if (ch == ':') { status = FwdLockConv_RecognizeMimeHeaderName(pSession); } else if (!FwdLockConv_IsWhitespace(ch)) { status = FwdLockConv_Status_SyntaxError; } break; case FwdLockConv_ScannerState_WantsContentTypeStart: if (FwdLockConv_IsMimeHeaderValueChar(ch)) { status = FwdLockConv_StringAppend(&pSession->contentType, tolower(ch)); if (status == FwdLockConv_Status_OK) { pSession->scannerState = FwdLockConv_ScannerState_WantsContentType; } } else if (!FwdLockConv_IsWhitespace(ch)) { status = FwdLockConv_Status_SyntaxError; } break; case FwdLockConv_ScannerState_WantsContentType: if (FwdLockConv_IsMimeHeaderValueChar(ch)) { status = FwdLockConv_StringAppend(&pSession->contentType, tolower(ch)); } else if (ch == ';') { pSession->scannerState = FwdLockConv_ScannerState_WantsCR; } else if (ch == '\r') { pSession->scannerState = FwdLockConv_ScannerState_WantsLF; } else if (FwdLockConv_IsWhitespace(ch)) { pSession->scannerState = FwdLockConv_ScannerState_WantsMimeHeaderValueEnd; } else { status = FwdLockConv_Status_SyntaxError; } break; case FwdLockConv_ScannerState_WantsContentTransferEncodingStart: if (ch == 'b' || ch == 'B') { pSession->scannerState = FwdLockConv_ScannerState_Wants_A_OR_I; } else if (ch == '7' || ch == '8') { pSession->scannerState = FwdLockConv_ScannerState_Wants_B; } else if (!FwdLockConv_IsWhitespace(ch)) { status = FwdLockConv_Status_UnsupportedContentTransferEncoding; } break; case FwdLockConv_ScannerState_Wants_A_OR_I: if (ch == 'i' || ch == 'I') { pSession->scannerState = FwdLockConv_ScannerState_Wants_N; } else if (ch == 'a' || ch == 'A') { pSession->scannerState = FwdLockConv_ScannerState_Wants_S; } else { status = FwdLockConv_Status_UnsupportedContentTransferEncoding; } break; case FwdLockConv_ScannerState_Wants_N: if (ch == 'n' || ch == 'N') { pSession->scannerState = FwdLockConv_ScannerState_Wants_A; } else { status = FwdLockConv_Status_UnsupportedContentTransferEncoding; } break; case FwdLockConv_ScannerState_Wants_A: if (ch == 'a' || ch == 'A') { pSession->scannerState = FwdLockConv_ScannerState_Wants_R; } else { status = FwdLockConv_Status_UnsupportedContentTransferEncoding; } break; case FwdLockConv_ScannerState_Wants_R: if (ch == 'r' || ch == 'R') { pSession->scannerState = FwdLockConv_ScannerState_Wants_Y; } else { status = FwdLockConv_Status_UnsupportedContentTransferEncoding; } break; case FwdLockConv_ScannerState_Wants_Y: if (ch == 'y' || ch == 'Y') { pSession->contentTransferEncoding = FwdLockConv_ContentTransferEncoding_Binary; pSession->scannerState = FwdLockConv_ScannerState_WantsContentTransferEncodingEnd; } else { status = FwdLockConv_Status_UnsupportedContentTransferEncoding; } break; case FwdLockConv_ScannerState_Wants_S: if (ch == 's' || ch == 'S') { pSession->scannerState = FwdLockConv_ScannerState_Wants_E; } else { status = FwdLockConv_Status_UnsupportedContentTransferEncoding; } break; case FwdLockConv_ScannerState_Wants_E: if (ch == 'e' || ch == 'E') { pSession->scannerState = FwdLockConv_ScannerState_Wants_6; } else { status = FwdLockConv_Status_UnsupportedContentTransferEncoding; } break; case FwdLockConv_ScannerState_Wants_6: if (ch == '6') { pSession->scannerState = FwdLockConv_ScannerState_Wants_4; } else { status = FwdLockConv_Status_UnsupportedContentTransferEncoding; } break; case FwdLockConv_ScannerState_Wants_4: if (ch == '4') { pSession->contentTransferEncoding = FwdLockConv_ContentTransferEncoding_Base64; pSession->scannerState = FwdLockConv_ScannerState_WantsContentTransferEncodingEnd; } else { status = FwdLockConv_Status_UnsupportedContentTransferEncoding; } break; case FwdLockConv_ScannerState_Wants_B: if (ch == 'b' || ch == 'B') { pSession->scannerState = FwdLockConv_ScannerState_Wants_I; } else { status = FwdLockConv_Status_UnsupportedContentTransferEncoding; } break; case FwdLockConv_ScannerState_Wants_I: if (ch == 'i' || ch == 'I') { pSession->scannerState = FwdLockConv_ScannerState_Wants_T; } else { status = FwdLockConv_Status_UnsupportedContentTransferEncoding; } break; case FwdLockConv_ScannerState_Wants_T: if (ch == 't' || ch == 'T') { pSession->contentTransferEncoding = FwdLockConv_ContentTransferEncoding_Binary; pSession->scannerState = FwdLockConv_ScannerState_WantsContentTransferEncodingEnd; } else { status = FwdLockConv_Status_UnsupportedContentTransferEncoding; } break; case FwdLockConv_ScannerState_WantsContentTransferEncodingEnd: if (ch == ';') { pSession->scannerState = FwdLockConv_ScannerState_WantsCR; } else if (ch == '\r') { pSession->scannerState = FwdLockConv_ScannerState_WantsLF; } else if (FwdLockConv_IsWhitespace(ch)) { pSession->scannerState = FwdLockConv_ScannerState_WantsMimeHeaderValueEnd; } else { status = FwdLockConv_Status_UnsupportedContentTransferEncoding; } break; case FwdLockConv_ScannerState_WantsMimeHeaderValueEnd: if (ch == ';') { pSession->scannerState = FwdLockConv_ScannerState_WantsCR; } else if (ch == '\r') { pSession->scannerState = FwdLockConv_ScannerState_WantsLF; } else if (!FwdLockConv_IsWhitespace(ch)) { status = FwdLockConv_Status_SyntaxError; } break; case FwdLockConv_ScannerState_WantsCR: if (ch == '\r') { pSession->scannerState = FwdLockConv_ScannerState_WantsLF; } break; case FwdLockConv_ScannerState_WantsLF: if (ch == '\n') { pSession->scannerState = FwdLockConv_ScannerState_WantsMimeHeaderNameStart; } else { status = FwdLockConv_Status_SyntaxError; } break; case FwdLockConv_ScannerState_WantsMimeHeadersEnd: if (ch == '\n') { status = FwdLockConv_ApplyDefaults(pSession); if (status == FwdLockConv_Status_OK) { status = FwdLockConv_VerifyContentType(pSession); } if (status == FwdLockConv_Status_OK) { status = FwdLockConv_WriteHeader(pSession, pOutput); } if (status == FwdLockConv_Status_OK) { if (pSession->contentTransferEncoding == FwdLockConv_ContentTransferEncoding_Binary) { pSession->parserState = FwdLockConv_ParserState_WantsBinaryEncodedData; } else { pSession->parserState = FwdLockConv_ParserState_WantsBase64EncodedData; } pSession->scannerState = FwdLockConv_ScannerState_WantsByte1; } } else { status = FwdLockConv_Status_SyntaxError; } break; default: status = FwdLockConv_Status_ProgramError; break; } return status; } /** * Increments the counter, treated as a 16-byte little-endian number, by one. * * @param[in,out] pSession A reference to a converter session. */ static void FwdLockConv_IncrementCounter(FwdLockConv_Session_t *pSession) { size_t i = 0; while ((++pSession->counter[i] == 0) && (++i < AES_BLOCK_SIZE)) ; } /** * Encrypts the given character and writes it to the output buffer. * * @param[in,out] pSession A reference to a converter session. * @param[in] ch The character to encrypt and write. * @param[in,out] pOutput The output from the conversion process. * * @return A status code. */ static FwdLockConv_Status_t FwdLockConv_WriteEncryptedChar(FwdLockConv_Session_t *pSession, unsigned char ch, FwdLockConv_Output_t *pOutput) { if (pOutput->fromConvertData.numBytes == pSession->outputBufferSize) { void *pBuffer; pSession->outputBufferSize += OUTPUT_BUFFER_SIZE_INCREMENT; pBuffer = realloc(pOutput->fromConvertData.pBuffer, pSession->outputBufferSize); if (pBuffer == NULL) { return FwdLockConv_Status_OutOfMemory; } pOutput->fromConvertData.pBuffer = pBuffer; } if (++pSession->keyStreamIndex == AES_BLOCK_SIZE) { FwdLockConv_IncrementCounter(pSession); pSession->keyStreamIndex = 0; } if (pSession->keyStreamIndex == 0) { AES_encrypt(pSession->counter, pSession->keyStream, &pSession->encryptionRoundKeys); } ch ^= pSession->keyStream[pSession->keyStreamIndex]; ((unsigned char *)pOutput->fromConvertData.pBuffer)[pOutput->fromConvertData.numBytes++] = ch; ++pSession->numDataBytes; return FwdLockConv_Status_OK; } /** * Matches binary-encoded content data and encrypts it, while looking out for the close delimiter. * * @param[in,out] pSession A reference to a converter session. * @param[in] ch A character. * @param[in,out] pOutput The output from the conversion process. * * @return A status code. */ static FwdLockConv_Status_t FwdLockConv_MatchBinaryEncodedData(FwdLockConv_Session_t *pSession, int ch, FwdLockConv_Output_t *pOutput) { FwdLockConv_Status_t status = FwdLockConv_Status_OK; switch (pSession->scannerState) { case FwdLockConv_ScannerState_WantsByte1: if (ch != pSession->delimiter[pSession->delimiterMatchPos]) { // The partial match of the delimiter turned out to be spurious. Flush the matched bytes // to the output buffer and start over. size_t i; for (i = 0; i < pSession->delimiterMatchPos; ++i) { status = FwdLockConv_WriteEncryptedChar(pSession, pSession->delimiter[i], pOutput); if (status != FwdLockConv_Status_OK) { return status; } } pSession->delimiterMatchPos = 0; } if (ch != pSession->delimiter[pSession->delimiterMatchPos]) { // The current character isn't part of the delimiter. Write it to the output buffer. status = FwdLockConv_WriteEncryptedChar(pSession, ch, pOutput); } else if (++pSession->delimiterMatchPos == pSession->delimiterLength) { // The entire delimiter has been matched. The only valid characters now are the "--" // that complete the close delimiter (no more message parts are expected). pSession->scannerState = FwdLockConv_ScannerState_WantsFirstDash; } break; case FwdLockConv_ScannerState_WantsFirstDash: if (ch == '-') { pSession->scannerState = FwdLockConv_ScannerState_WantsSecondDash; } else { status = FwdLockConv_Status_SyntaxError; } break; case FwdLockConv_ScannerState_WantsSecondDash: if (ch == '-') { pSession->parserState = FwdLockConv_ParserState_Done; } else { status = FwdLockConv_Status_SyntaxError; } break; default: status = FwdLockConv_Status_ProgramError; break; } return status; } /** * Checks whether a given character is valid in base64-encoded data. * * @param[in] ch The character to check. * * @return A Boolean value indicating whether the given character is valid in base64-encoded data. */ static int FwdLockConv_IsBase64Char(int ch) { return 0 <= ch && ch <= 'z' && base64Values[ch] >= 0; } /** * Matches base64-encoded content data and encrypts it, while looking out for the close delimiter. * * @param[in,out] pSession A reference to a converter session. * @param[in] ch A character. * @param[in,out] pOutput The output from the conversion process. * * @return A status code. */ static FwdLockConv_Status_t FwdLockConv_MatchBase64EncodedData(FwdLockConv_Session_t *pSession, int ch, FwdLockConv_Output_t *pOutput) { FwdLockConv_Status_t status = FwdLockConv_Status_OK; switch (pSession->scannerState) { case FwdLockConv_ScannerState_WantsByte1: case FwdLockConv_ScannerState_WantsByte1_AfterCRLF: if (FwdLockConv_IsBase64Char(ch)) { pSession->ch = base64Values[ch] << 2; pSession->scannerState = FwdLockConv_ScannerState_WantsByte2; } else if (ch == '\r') { pSession->savedScannerState = FwdLockConv_ScannerState_WantsByte1_AfterCRLF; pSession->scannerState = FwdLockConv_ScannerState_WantsLF; } else if (ch == '-') { if (pSession->scannerState == FwdLockConv_ScannerState_WantsByte1_AfterCRLF) { pSession->delimiterMatchPos = 3; pSession->scannerState = FwdLockConv_ScannerState_WantsDelimiter; } else { status = FwdLockConv_Status_SyntaxError; } } else if (!FwdLockConv_IsWhitespace(ch)) { status = FwdLockConv_Status_SyntaxError; } break; case FwdLockConv_ScannerState_WantsByte2: if (FwdLockConv_IsBase64Char(ch)) { pSession->ch |= base64Values[ch] >> 4; status = FwdLockConv_WriteEncryptedChar(pSession, pSession->ch, pOutput); if (status == FwdLockConv_Status_OK) { pSession->ch = base64Values[ch] << 4; pSession->scannerState = FwdLockConv_ScannerState_WantsByte3; } } else if (ch == '\r') { pSession->savedScannerState = pSession->scannerState; pSession->scannerState = FwdLockConv_ScannerState_WantsLF; } else if (!FwdLockConv_IsWhitespace(ch)) { status = FwdLockConv_Status_SyntaxError; } break; case FwdLockConv_ScannerState_WantsByte3: if (FwdLockConv_IsBase64Char(ch)) { pSession->ch |= base64Values[ch] >> 2; status = FwdLockConv_WriteEncryptedChar(pSession, pSession->ch, pOutput); if (status == FwdLockConv_Status_OK) { pSession->ch = base64Values[ch] << 6; pSession->scannerState = FwdLockConv_ScannerState_WantsByte4; } } else if (ch == '\r') { pSession->savedScannerState = pSession->scannerState; pSession->scannerState = FwdLockConv_ScannerState_WantsLF; } else if (ch == '=') { pSession->scannerState = FwdLockConv_ScannerState_WantsPadding; } else if (!FwdLockConv_IsWhitespace(ch)) { status = FwdLockConv_Status_SyntaxError; } break; case FwdLockConv_ScannerState_WantsByte4: if (FwdLockConv_IsBase64Char(ch)) { pSession->ch |= base64Values[ch]; status = FwdLockConv_WriteEncryptedChar(pSession, pSession->ch, pOutput); if (status == FwdLockConv_Status_OK) { pSession->scannerState = FwdLockConv_ScannerState_WantsByte1; } } else if (ch == '\r') { pSession->savedScannerState = pSession->scannerState; pSession->scannerState = FwdLockConv_ScannerState_WantsLF; } else if (ch == '=') { pSession->scannerState = FwdLockConv_ScannerState_WantsWhitespace; } else if (!FwdLockConv_IsWhitespace(ch)) { status = FwdLockConv_Status_SyntaxError; } break; case FwdLockConv_ScannerState_WantsLF: if (ch == '\n') { pSession->scannerState = pSession->savedScannerState; } else { status = FwdLockConv_Status_SyntaxError; } break; case FwdLockConv_ScannerState_WantsPadding: if (ch == '=') { pSession->scannerState = FwdLockConv_ScannerState_WantsWhitespace; } else { status = FwdLockConv_Status_SyntaxError; } break; case FwdLockConv_ScannerState_WantsWhitespace: case FwdLockConv_ScannerState_WantsWhitespace_AfterCRLF: if (ch == '\r') { pSession->savedScannerState = FwdLockConv_ScannerState_WantsWhitespace_AfterCRLF; pSession->scannerState = FwdLockConv_ScannerState_WantsLF; } else if (ch == '-') { if (pSession->scannerState == FwdLockConv_ScannerState_WantsWhitespace_AfterCRLF) { pSession->delimiterMatchPos = 3; pSession->scannerState = FwdLockConv_ScannerState_WantsDelimiter; } else { status = FwdLockConv_Status_SyntaxError; } } else if (FwdLockConv_IsWhitespace(ch)) { pSession->scannerState = FwdLockConv_ScannerState_WantsWhitespace; } else { status = FwdLockConv_Status_SyntaxError; } break; case FwdLockConv_ScannerState_WantsDelimiter: if (ch != pSession->delimiter[pSession->delimiterMatchPos]) { status = FwdLockConv_Status_SyntaxError; } else if (++pSession->delimiterMatchPos == pSession->delimiterLength) { pSession->scannerState = FwdLockConv_ScannerState_WantsFirstDash; } break; case FwdLockConv_ScannerState_WantsFirstDash: if (ch == '-') { pSession->scannerState = FwdLockConv_ScannerState_WantsSecondDash; } else { status = FwdLockConv_Status_SyntaxError; } break; case FwdLockConv_ScannerState_WantsSecondDash: if (ch == '-') { pSession->parserState = FwdLockConv_ParserState_Done; } else { status = FwdLockConv_Status_SyntaxError; } break; default: status = FwdLockConv_Status_ProgramError; break; } return status; } /** * Pushes a single character into the converter's state machine. * * @param[in,out] pSession A reference to a converter session. * @param[in] ch A character. * @param[in,out] pOutput The output from the conversion process. * * @return A status code. */ static FwdLockConv_Status_t FwdLockConv_PushChar(FwdLockConv_Session_t *pSession, int ch, FwdLockConv_Output_t *pOutput) { FwdLockConv_Status_t status; ++pSession->numCharsConsumed; switch (pSession->parserState) { case FwdLockConv_ParserState_WantsOpenDelimiter: status = FwdLockConv_MatchOpenDelimiter(pSession, ch); break; case FwdLockConv_ParserState_WantsMimeHeaders: status = FwdLockConv_MatchMimeHeaders(pSession, ch, pOutput); break; case FwdLockConv_ParserState_WantsBinaryEncodedData: status = FwdLockConv_MatchBinaryEncodedData(pSession, ch, pOutput); break; case FwdLockConv_ParserState_WantsBase64EncodedData: if (ch == '\n' && pSession->scannerState != FwdLockConv_ScannerState_WantsLF) { // Repair base64-encoded data that doesn't have carriage returns in its line breaks. status = FwdLockConv_MatchBase64EncodedData(pSession, '\r', pOutput); if (status != FwdLockConv_Status_OK) { break; } } status = FwdLockConv_MatchBase64EncodedData(pSession, ch, pOutput); break; case FwdLockConv_ParserState_Done: status = FwdLockConv_Status_OK; break; default: status = FwdLockConv_Status_ProgramError; break; } return status; } FwdLockConv_Status_t FwdLockConv_OpenSession(int *pSessionId, FwdLockConv_Output_t *pOutput) { FwdLockConv_Status_t status; if (pSessionId == NULL || pOutput == NULL) { status = FwdLockConv_Status_InvalidArgument; } else { *pSessionId = FwdLockConv_AcquireSession(); if (*pSessionId < 0) { status = FwdLockConv_Status_TooManySessions; } else { FwdLockConv_Session_t *pSession = sessionPtrs[*pSessionId]; pSession->encryptedSessionKeyLength = FwdLockGlue_GetEncryptedKeyLength(KEY_SIZE); if (pSession->encryptedSessionKeyLength < AES_BLOCK_SIZE) { // The encrypted session key is used as the CTR-mode nonce, so it must be at least // the size of a single AES block. status = FwdLockConv_Status_ProgramError; } else { pSession->pEncryptedSessionKey = malloc(pSession->encryptedSessionKeyLength); if (pSession->pEncryptedSessionKey == NULL) { status = FwdLockConv_Status_OutOfMemory; } else { if (!FwdLockGlue_GetRandomNumber(pSession->sessionKey, KEY_SIZE)) { status = FwdLockConv_Status_RandomNumberGenerationFailed; } else if (!FwdLockGlue_EncryptKey(pSession->sessionKey, KEY_SIZE, pSession->pEncryptedSessionKey, pSession->encryptedSessionKeyLength)) { status = FwdLockConv_Status_KeyEncryptionFailed; } else { status = FwdLockConv_DeriveKeys(pSession); } if (status == FwdLockConv_Status_OK) { memset(pSession->sessionKey, 0, KEY_SIZE); // Zero out key data. memcpy(pSession->counter, pSession->pEncryptedSessionKey, AES_BLOCK_SIZE); pSession->parserState = FwdLockConv_ParserState_WantsOpenDelimiter; pSession->scannerState = FwdLockConv_ScannerState_WantsFirstDash; pSession->numCharsConsumed = 0; pSession->delimiterMatchPos = 0; pSession->mimeHeaderName = nullString; pSession->contentType = nullString; pSession->contentTransferEncoding = FwdLockConv_ContentTransferEncoding_Undefined; pSession->keyStreamIndex = -1; pOutput->fromConvertData.pBuffer = NULL; pOutput->fromConvertData.errorPos = INVALID_OFFSET; } else { free(pSession->pEncryptedSessionKey); } } } if (status != FwdLockConv_Status_OK) { FwdLockConv_ReleaseSession(*pSessionId); *pSessionId = -1; } } } return status; } FwdLockConv_Status_t FwdLockConv_ConvertData(int sessionId, const void *pBuffer, size_t numBytes, FwdLockConv_Output_t *pOutput) { FwdLockConv_Status_t status; if (!FwdLockConv_IsValidSession(sessionId) || pBuffer == NULL || pOutput == NULL) { status = FwdLockConv_Status_InvalidArgument; } else { size_t i; FwdLockConv_Session_t *pSession = sessionPtrs[sessionId]; pSession->dataOffset = 0; pSession->numDataBytes = 0; pOutput->fromConvertData.numBytes = 0; status = FwdLockConv_Status_OK; for (i = 0; i < numBytes; ++i) { status = FwdLockConv_PushChar(pSession, ((char *)pBuffer)[i], pOutput); if (status != FwdLockConv_Status_OK) { break; } } if (status == FwdLockConv_Status_OK) { // Update the data signature. HMAC_Update(&pSession->signingContext, &((unsigned char *)pOutput->fromConvertData.pBuffer)[pSession->dataOffset], pSession->numDataBytes); } else if (status == FwdLockConv_Status_SyntaxError) { pOutput->fromConvertData.errorPos = pSession->numCharsConsumed; } } return status; } FwdLockConv_Status_t FwdLockConv_CloseSession(int sessionId, FwdLockConv_Output_t *pOutput) { FwdLockConv_Status_t status; if (!FwdLockConv_IsValidSession(sessionId) || pOutput == NULL) { status = FwdLockConv_Status_InvalidArgument; } else { FwdLockConv_Session_t *pSession = sessionPtrs[sessionId]; free(pOutput->fromConvertData.pBuffer); if (pSession->parserState != FwdLockConv_ParserState_Done) { pOutput->fromCloseSession.errorPos = pSession->numCharsConsumed; status = FwdLockConv_Status_SyntaxError; } else { // Finalize the data signature. unsigned int signatureSize = SHA1_HASH_SIZE; HMAC_Final(&pSession->signingContext, pOutput->fromCloseSession.signatures, &signatureSize); if (signatureSize != SHA1_HASH_SIZE) { status = FwdLockConv_Status_ProgramError; } else { // Calculate the header signature, which is a signature of the rest of the header // including the data signature. HMAC_Init_ex(&pSession->signingContext, NULL, KEY_SIZE, NULL, NULL); HMAC_Update(&pSession->signingContext, pSession->topHeader, TOP_HEADER_SIZE); HMAC_Update(&pSession->signingContext, (unsigned char *)pSession->contentType.ptr, pSession->contentType.length); HMAC_Update(&pSession->signingContext, pSession->pEncryptedSessionKey, pSession->encryptedSessionKeyLength); HMAC_Update(&pSession->signingContext, pOutput->fromCloseSession.signatures, SHA1_HASH_SIZE); HMAC_Final(&pSession->signingContext, &pOutput->fromCloseSession.signatures[SHA1_HASH_SIZE], &signatureSize); if (signatureSize != SHA1_HASH_SIZE) { status = FwdLockConv_Status_ProgramError; } else { pOutput->fromCloseSession.fileOffset = TOP_HEADER_SIZE + pSession->contentType.length + pSession->encryptedSessionKeyLength; status = FwdLockConv_Status_OK; } } pOutput->fromCloseSession.errorPos = INVALID_OFFSET; } free(pSession->mimeHeaderName.ptr); free(pSession->contentType.ptr); free(pSession->pEncryptedSessionKey); HMAC_CTX_cleanup(&pSession->signingContext); FwdLockConv_ReleaseSession(sessionId); } return status; } FwdLockConv_Status_t FwdLockConv_ConvertOpenFile(int inputFileDesc, FwdLockConv_ReadFunc_t *fpReadFunc, int outputFileDesc, FwdLockConv_WriteFunc_t *fpWriteFunc, FwdLockConv_LSeekFunc_t *fpLSeekFunc, off64_t *pErrorPos) { FwdLockConv_Status_t status; if (pErrorPos != NULL) { *pErrorPos = INVALID_OFFSET; } if (fpReadFunc == NULL || fpWriteFunc == NULL || fpLSeekFunc == NULL || inputFileDesc < 0 || outputFileDesc < 0) { status = FwdLockConv_Status_InvalidArgument; } else { char *pReadBuffer = malloc(READ_BUFFER_SIZE); if (pReadBuffer == NULL) { status = FwdLockConv_Status_OutOfMemory; } else { int sessionId; FwdLockConv_Output_t output; status = FwdLockConv_OpenSession(&sessionId, &output); if (status == FwdLockConv_Status_OK) { ssize_t numBytesRead; FwdLockConv_Status_t closeStatus; while ((numBytesRead = fpReadFunc(inputFileDesc, pReadBuffer, READ_BUFFER_SIZE)) > 0) { status = FwdLockConv_ConvertData(sessionId, pReadBuffer, (size_t)numBytesRead, &output); if (status == FwdLockConv_Status_OK) { if (output.fromConvertData.pBuffer != NULL && output.fromConvertData.numBytes > 0) { ssize_t numBytesWritten = fpWriteFunc(outputFileDesc, output.fromConvertData.pBuffer, output.fromConvertData.numBytes); if (numBytesWritten != (ssize_t)output.fromConvertData.numBytes) { status = FwdLockConv_Status_FileWriteError; break; } } } else { if (status == FwdLockConv_Status_SyntaxError && pErrorPos != NULL) { *pErrorPos = output.fromConvertData.errorPos; } break; } } // end while if (numBytesRead < 0) { status = FwdLockConv_Status_FileReadError; } closeStatus = FwdLockConv_CloseSession(sessionId, &output); if (status == FwdLockConv_Status_OK) { if (closeStatus != FwdLockConv_Status_OK) { if (closeStatus == FwdLockConv_Status_SyntaxError && pErrorPos != NULL) { *pErrorPos = output.fromCloseSession.errorPos; } status = closeStatus; } else if (fpLSeekFunc(outputFileDesc, output.fromCloseSession.fileOffset, SEEK_SET) < 0) { status = FwdLockConv_Status_FileSeekError; } else if (fpWriteFunc(outputFileDesc, output.fromCloseSession.signatures, FWD_LOCK_SIGNATURES_SIZE) != FWD_LOCK_SIGNATURES_SIZE) { status = FwdLockConv_Status_FileWriteError; } } } free(pReadBuffer); } } return status; }