Milestone 5: deliver embedded RDP sessions and lifecycle hardening
This commit is contained in:
Keith Smith
591
third_party/FreeRDP/libfreerdp/crypto/per.c
vendored
Normal file
591
third_party/FreeRDP/libfreerdp/crypto/per.c
vendored
Normal file
@@ -0,0 +1,591 @@
|
||||
/**
|
||||
* FreeRDP: A Remote Desktop Protocol Implementation
|
||||
* ASN.1 Packed Encoding Rules (BER)
|
||||
*
|
||||
* Copyright 2011-2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
|
||||
*
|
||||
* 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 <winpr/assert.h>
|
||||
#include <winpr/cast.h>
|
||||
#include <winpr/print.h>
|
||||
|
||||
#include <freerdp/config.h>
|
||||
#include <freerdp/crypto/per.h>
|
||||
|
||||
#include <freerdp/log.h>
|
||||
#define TAG FREERDP_TAG("crypto.per")
|
||||
|
||||
/**
|
||||
* Read PER length.
|
||||
*
|
||||
* @param s stream to read from
|
||||
* @param length A pointer to return the length read, must not be nullptr
|
||||
*
|
||||
* @return \b TRUE for success, \b FALSE otherwise.
|
||||
*/
|
||||
|
||||
BOOL per_read_length(wStream* s, UINT16* length)
|
||||
{
|
||||
BYTE byte = 0;
|
||||
|
||||
WINPR_ASSERT(length);
|
||||
if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
|
||||
return FALSE;
|
||||
|
||||
Stream_Read_UINT8(s, byte);
|
||||
|
||||
if (byte & 0x80)
|
||||
{
|
||||
if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
|
||||
return FALSE;
|
||||
|
||||
byte &= ~(0x80);
|
||||
*length = WINPR_ASSERTING_INT_CAST(UINT16, byte << 8);
|
||||
Stream_Read_UINT8(s, byte);
|
||||
*length += byte;
|
||||
}
|
||||
else
|
||||
{
|
||||
*length = byte;
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Write PER length.
|
||||
* @param s stream
|
||||
* @param length length
|
||||
*
|
||||
* @return \b TRUE for success, \b FALSE otherwise.
|
||||
*/
|
||||
|
||||
BOOL per_write_length(wStream* s, UINT16 length)
|
||||
{
|
||||
if (length > 0x7F)
|
||||
{
|
||||
if (!Stream_EnsureRemainingCapacity(s, 2))
|
||||
return FALSE;
|
||||
Stream_Write_UINT16_BE(s, (length | 0x8000));
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!Stream_EnsureRemainingCapacity(s, 1))
|
||||
return FALSE;
|
||||
Stream_Write_UINT8(s, (UINT8)length);
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read PER choice.
|
||||
* @param s stream
|
||||
* @param choice choice
|
||||
*
|
||||
* @return \b TRUE for success, \b FALSE otherwise.
|
||||
*/
|
||||
|
||||
BOOL per_read_choice(wStream* s, BYTE* choice)
|
||||
{
|
||||
if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
|
||||
return FALSE;
|
||||
|
||||
Stream_Read_UINT8(s, *choice);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Write PER CHOICE.
|
||||
* @param s stream
|
||||
* @param choice index of chosen field
|
||||
*
|
||||
* @return \b TRUE for success, \b FALSE otherwise.
|
||||
*/
|
||||
|
||||
BOOL per_write_choice(wStream* s, BYTE choice)
|
||||
{
|
||||
if (!Stream_EnsureRemainingCapacity(s, 1))
|
||||
return FALSE;
|
||||
Stream_Write_UINT8(s, choice);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read PER selection.
|
||||
* @param s stream
|
||||
* @param selection selection
|
||||
*
|
||||
* @return \b TRUE for success, \b FALSE otherwise.
|
||||
*/
|
||||
|
||||
BOOL per_read_selection(wStream* s, BYTE* selection)
|
||||
{
|
||||
if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
|
||||
return FALSE;
|
||||
|
||||
WINPR_ASSERT(selection);
|
||||
Stream_Read_UINT8(s, *selection);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Write PER selection for OPTIONAL fields.
|
||||
* @param s stream
|
||||
* @param selection bit map of selected fields
|
||||
*
|
||||
* @return \b TRUE for success, \b FALSE otherwise.
|
||||
*/
|
||||
|
||||
BOOL per_write_selection(wStream* s, BYTE selection)
|
||||
{
|
||||
if (!Stream_EnsureRemainingCapacity(s, 1))
|
||||
return FALSE;
|
||||
Stream_Write_UINT8(s, selection);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read PER number of sets.
|
||||
* @param s stream
|
||||
* @param number number of sets
|
||||
*
|
||||
* @return \b TRUE for success, \b FALSE otherwise.
|
||||
*/
|
||||
|
||||
BOOL per_read_number_of_sets(wStream* s, BYTE* number)
|
||||
{
|
||||
if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
|
||||
return FALSE;
|
||||
|
||||
WINPR_ASSERT(number);
|
||||
Stream_Read_UINT8(s, *number);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Write PER number of sets for SET OF.
|
||||
*
|
||||
* @param s stream
|
||||
* @param number number of sets
|
||||
*
|
||||
* @return \b TRUE for success, \b FALSE otherwise.
|
||||
*/
|
||||
|
||||
BOOL per_write_number_of_sets(wStream* s, BYTE number)
|
||||
{
|
||||
if (!Stream_EnsureRemainingCapacity(s, 1))
|
||||
return FALSE;
|
||||
Stream_Write_UINT8(s, number);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read PER padding with zeros.
|
||||
*
|
||||
* @param s A stream to read from
|
||||
* @param length the data to write
|
||||
*
|
||||
* @return \b TRUE for success, \b FALSE otherwise.
|
||||
*/
|
||||
|
||||
BOOL per_read_padding(wStream* s, UINT16 length)
|
||||
{
|
||||
if (!Stream_CheckAndLogRequiredLength(TAG, s, length))
|
||||
return FALSE;
|
||||
|
||||
Stream_Seek(s, length);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Write PER padding with zeros.
|
||||
* @param s A stream to write to
|
||||
* @param length the data to write
|
||||
*
|
||||
* @return \b TRUE for success, \b FALSE otherwise.
|
||||
*/
|
||||
|
||||
BOOL per_write_padding(wStream* s, UINT16 length)
|
||||
{
|
||||
if (!Stream_EnsureRemainingCapacity(s, length))
|
||||
return FALSE;
|
||||
Stream_Zero(s, length);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read PER INTEGER.
|
||||
* @param s stream
|
||||
* @param integer integer
|
||||
*
|
||||
* @return \b TRUE for success, \b FALSE otherwise.
|
||||
*/
|
||||
|
||||
BOOL per_read_integer(wStream* s, UINT32* integer)
|
||||
{
|
||||
UINT16 length = 0;
|
||||
|
||||
WINPR_ASSERT(integer);
|
||||
|
||||
if (!per_read_length(s, &length))
|
||||
return FALSE;
|
||||
|
||||
if (!Stream_CheckAndLogRequiredLength(TAG, s, length))
|
||||
return FALSE;
|
||||
|
||||
if (length == 0)
|
||||
*integer = 0;
|
||||
else if (length == 1)
|
||||
Stream_Read_UINT8(s, *integer);
|
||||
else if (length == 2)
|
||||
Stream_Read_UINT16_BE(s, *integer);
|
||||
else
|
||||
return FALSE;
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Write PER INTEGER.
|
||||
* @param s stream
|
||||
* @param integer integer
|
||||
*
|
||||
* @return \b TRUE for success, \b FALSE otherwise.
|
||||
*/
|
||||
|
||||
BOOL per_write_integer(wStream* s, UINT32 integer)
|
||||
{
|
||||
if (integer <= UINT8_MAX)
|
||||
{
|
||||
if (!per_write_length(s, 1))
|
||||
return FALSE;
|
||||
if (!Stream_EnsureRemainingCapacity(s, 1))
|
||||
return FALSE;
|
||||
Stream_Write_UINT8(s, WINPR_ASSERTING_INT_CAST(UINT8, integer));
|
||||
}
|
||||
else if (integer <= UINT16_MAX)
|
||||
{
|
||||
if (!per_write_length(s, 2))
|
||||
return FALSE;
|
||||
if (!Stream_EnsureRemainingCapacity(s, 2))
|
||||
return FALSE;
|
||||
Stream_Write_UINT16_BE(s, WINPR_ASSERTING_INT_CAST(UINT16, integer));
|
||||
}
|
||||
else if (integer <= UINT32_MAX)
|
||||
{
|
||||
if (!per_write_length(s, 4))
|
||||
return FALSE;
|
||||
if (!Stream_EnsureRemainingCapacity(s, 4))
|
||||
return FALSE;
|
||||
Stream_Write_UINT32_BE(s, integer);
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read PER INTEGER (UINT16).
|
||||
*
|
||||
* @param s The stream to read from
|
||||
* @param integer The integer result variable pointer, must not be nullptr
|
||||
* @param min minimum value
|
||||
*
|
||||
* @return \b TRUE for success, \b FALSE otherwise
|
||||
*/
|
||||
|
||||
BOOL per_read_integer16(wStream* s, UINT16* integer, UINT16 min)
|
||||
{
|
||||
if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
|
||||
return FALSE;
|
||||
|
||||
Stream_Read_UINT16_BE(s, *integer);
|
||||
|
||||
if (*integer > UINT16_MAX - min)
|
||||
{
|
||||
WLog_WARN(TAG, "PER uint16 invalid value %" PRIu16 " > %d", *integer, UINT16_MAX - min);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
*integer += min;
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Write PER INTEGER (UINT16).
|
||||
* @param s stream
|
||||
* @param integer integer
|
||||
* @param min minimum value
|
||||
*
|
||||
* @return \b TRUE for success, \b FALSE otherwise.
|
||||
*/
|
||||
|
||||
BOOL per_write_integer16(wStream* s, UINT16 integer, UINT16 min)
|
||||
{
|
||||
if (min > integer)
|
||||
return FALSE;
|
||||
if (!Stream_EnsureRemainingCapacity(s, 2))
|
||||
return FALSE;
|
||||
Stream_Write_UINT16_BE(s, integer - min);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read PER ENUMERATED.
|
||||
*
|
||||
* @param s The stream to read from
|
||||
* @param enumerated enumerated result variable, must not be nullptr
|
||||
* @param count enumeration count
|
||||
*
|
||||
* @return \b TRUE for success, \b FALSE otherwise
|
||||
*/
|
||||
|
||||
BOOL per_read_enumerated(wStream* s, BYTE* enumerated, BYTE count)
|
||||
{
|
||||
if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
|
||||
return FALSE;
|
||||
|
||||
WINPR_ASSERT(enumerated);
|
||||
Stream_Read_UINT8(s, *enumerated);
|
||||
|
||||
/* check that enumerated value falls within expected range */
|
||||
if (*enumerated + 1 > count)
|
||||
{
|
||||
WLog_WARN(TAG, "PER invalid data, expected %" PRIu8 " < %" PRIu8, *enumerated, count);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Write PER ENUMERATED.
|
||||
*
|
||||
* @param s The stream to write to
|
||||
* @param enumerated enumerated
|
||||
* @param count enumeration count
|
||||
*
|
||||
* @return \b TRUE for success, \b FALSE otherwise
|
||||
*/
|
||||
|
||||
BOOL per_write_enumerated(wStream* s, BYTE enumerated, WINPR_ATTR_UNUSED BYTE count)
|
||||
{
|
||||
if (!Stream_EnsureRemainingCapacity(s, 1))
|
||||
return FALSE;
|
||||
Stream_Write_UINT8(s, enumerated);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static BOOL per_check_oid_and_log_mismatch(const BYTE* got, const BYTE* expect, size_t length)
|
||||
{
|
||||
if (memcmp(got, expect, length) == 0)
|
||||
{
|
||||
return TRUE;
|
||||
}
|
||||
else
|
||||
{
|
||||
char* got_str = winpr_BinToHexString(got, length, TRUE);
|
||||
char* expect_str = winpr_BinToHexString(expect, length, TRUE);
|
||||
|
||||
WLog_WARN(TAG, "PER OID mismatch, got %s, expected %s", got_str, expect_str);
|
||||
free(got_str);
|
||||
free(expect_str);
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Read PER OBJECT_IDENTIFIER (OID).
|
||||
*
|
||||
* @param s The stream to read from
|
||||
* @param oid object identifier (OID)
|
||||
* @warning It works correctly only for limited set of OIDs.
|
||||
*
|
||||
* @return \b TRUE for success, \b FALSE otherwise
|
||||
*/
|
||||
|
||||
BOOL per_read_object_identifier(wStream* s, const BYTE oid[6])
|
||||
{
|
||||
BYTE t12 = 0;
|
||||
UINT16 length = 0;
|
||||
BYTE a_oid[6] = WINPR_C_ARRAY_INIT;
|
||||
|
||||
if (!per_read_length(s, &length))
|
||||
return FALSE;
|
||||
|
||||
if (length != 5)
|
||||
{
|
||||
WLog_WARN(TAG, "PER length, got %" PRIu16 ", expected 5", length);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
if (!Stream_CheckAndLogRequiredLength(TAG, s, length))
|
||||
return FALSE;
|
||||
|
||||
Stream_Read_UINT8(s, t12); /* first two tuples */
|
||||
a_oid[0] = t12 / 40;
|
||||
a_oid[1] = t12 % 40;
|
||||
|
||||
Stream_Read_UINT8(s, a_oid[2]); /* tuple 3 */
|
||||
Stream_Read_UINT8(s, a_oid[3]); /* tuple 4 */
|
||||
Stream_Read_UINT8(s, a_oid[4]); /* tuple 5 */
|
||||
Stream_Read_UINT8(s, a_oid[5]); /* tuple 6 */
|
||||
|
||||
return per_check_oid_and_log_mismatch(a_oid, oid, sizeof(a_oid));
|
||||
}
|
||||
|
||||
/**
|
||||
* Write PER OBJECT_IDENTIFIER (OID)
|
||||
* @param s stream
|
||||
* @param oid object identifier (oid)
|
||||
* @warning It works correctly only for limited set of OIDs.
|
||||
*
|
||||
* @return \b TRUE for success, \b FALSE otherwise.
|
||||
*/
|
||||
|
||||
BOOL per_write_object_identifier(wStream* s, const BYTE oid[6])
|
||||
{
|
||||
BYTE t12 = oid[0] * 40 + oid[1];
|
||||
if (!Stream_EnsureRemainingCapacity(s, 6))
|
||||
return FALSE;
|
||||
Stream_Write_UINT8(s, 5); /* length */
|
||||
Stream_Write_UINT8(s, t12); /* first two tuples */
|
||||
Stream_Write_UINT8(s, oid[2]); /* tuple 3 */
|
||||
Stream_Write_UINT8(s, oid[3]); /* tuple 4 */
|
||||
Stream_Write_UINT8(s, oid[4]); /* tuple 5 */
|
||||
Stream_Write_UINT8(s, oid[5]); /* tuple 6 */
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read PER OCTET_STRING.
|
||||
*
|
||||
* @param s The stream to read from
|
||||
* @param oct_str octet string
|
||||
* @param length string length
|
||||
* @param min minimum length
|
||||
*
|
||||
* @return \b TRUE for success, \b FALSE otherwise.
|
||||
*/
|
||||
|
||||
BOOL per_read_octet_string(wStream* s, const BYTE* oct_str, UINT16 length, UINT16 min)
|
||||
{
|
||||
UINT16 mlength = 0;
|
||||
|
||||
if (!per_read_length(s, &mlength))
|
||||
return FALSE;
|
||||
|
||||
if (mlength + min != length)
|
||||
{
|
||||
WLog_ERR(TAG, "length mismatch: %d!= %" PRIu16, mlength + min, length);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
if (!Stream_CheckAndLogRequiredLength(TAG, s, length))
|
||||
return FALSE;
|
||||
|
||||
const BYTE* a_oct_str = Stream_ConstPointer(s);
|
||||
Stream_Seek(s, length);
|
||||
|
||||
return per_check_oid_and_log_mismatch(a_oct_str, oct_str, length);
|
||||
}
|
||||
|
||||
/**
|
||||
* Write PER OCTET_STRING
|
||||
* @param s stream
|
||||
* @param oct_str octet string
|
||||
* @param length string length
|
||||
* @param min minimum string length
|
||||
*
|
||||
* @return \b TRUE for success, \b FALSE otherwise.
|
||||
*/
|
||||
|
||||
BOOL per_write_octet_string(wStream* s, const BYTE* oct_str, UINT16 length, UINT16 min)
|
||||
{
|
||||
UINT16 mlength = 0;
|
||||
|
||||
mlength = (length >= min) ? length - min : min;
|
||||
|
||||
if (!per_write_length(s, mlength))
|
||||
return FALSE;
|
||||
|
||||
if (!Stream_EnsureRemainingCapacity(s, length))
|
||||
return FALSE;
|
||||
for (UINT16 i = 0; i < length; i++)
|
||||
Stream_Write_UINT8(s, oct_str[i]);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read PER NumericString.
|
||||
* @param s stream
|
||||
* @param min minimum string length
|
||||
*
|
||||
* @return \b TRUE for success, \b FALSE otherwise.
|
||||
*/
|
||||
|
||||
BOOL per_read_numeric_string(wStream* s, UINT16 min)
|
||||
{
|
||||
size_t length = 0;
|
||||
UINT16 mlength = 0;
|
||||
|
||||
if (!per_read_length(s, &mlength))
|
||||
return FALSE;
|
||||
|
||||
length = (mlength + min + 1) / 2;
|
||||
|
||||
if (!Stream_CheckAndLogRequiredLength(TAG, s, length))
|
||||
return FALSE;
|
||||
|
||||
Stream_Seek(s, length);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Write PER NumericString.
|
||||
* @param s stream
|
||||
* @param num_str numeric string
|
||||
* @param length string length
|
||||
* @param min minimum string length
|
||||
*
|
||||
* @return \b TRUE for success, \b FALSE otherwise.
|
||||
*/
|
||||
|
||||
BOOL per_write_numeric_string(wStream* s, const BYTE* num_str, UINT16 length, UINT16 min)
|
||||
{
|
||||
WINPR_ASSERT(num_str || (length == 0));
|
||||
|
||||
const UINT16 mlength = (length >= min) ? length - min : min;
|
||||
|
||||
if (!per_write_length(s, mlength))
|
||||
return FALSE;
|
||||
|
||||
if (!Stream_EnsureRemainingCapacity(s, length))
|
||||
return FALSE;
|
||||
for (UINT16 i = 0; i < length; i += 2)
|
||||
{
|
||||
BYTE c1 = num_str[i];
|
||||
BYTE c2 = ((i + 1) < length) ? num_str[i + 1] : 0x30;
|
||||
|
||||
if ((c1 < 0x30) || (c2 < 0x30))
|
||||
return FALSE;
|
||||
|
||||
c1 = (c1 - 0x30) % 10;
|
||||
c2 = (c2 - 0x30) % 10;
|
||||
const BYTE num = WINPR_ASSERTING_INT_CAST(BYTE, (c1 << 4) | c2);
|
||||
|
||||
Stream_Write_UINT8(s, num); /* string */
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
Reference in New Issue
Block a user