| /* Microsoft Reference Implementation for TPM 2.0 |
| * |
| * The copyright in this software is being made available under the BSD License, |
| * included below. This software may be subject to other third party and |
| * contributor rights, including patent rights, and no such rights are granted |
| * under this license. |
| * |
| * Copyright (c) Microsoft Corporation |
| * |
| * All rights reserved. |
| * |
| * BSD License |
| * |
| * Redistribution and use in source and binary forms, with or without modification, |
| * are permitted provided that the following conditions are met: |
| * |
| * Redistributions of source code must retain the above copyright notice, this list |
| * of conditions and the following disclaimer. |
| * |
| * Redistributions in binary form must reproduce the above copyright notice, this |
| * list of conditions and the following disclaimer in the documentation and/or |
| * other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ""AS IS"" |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR |
| * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
| * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON |
| * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
| * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include <assert.h> |
| |
| #include "Tpm.h" |
| #include "Marshal.h" |
| #include "TableMarshal.h" |
| |
| #if TABLE_DRIVEN_MARSHAL |
| |
| extern ArrayMarshal_mst ArrayLookupTable[]; |
| |
| extern UINT16 MarshalLookupTable[]; |
| |
| typedef struct { int a; } External_Structure_t; |
| |
| extern struct Exernal_Structure_t MarshalData; |
| |
| #define IS_SUCCESS(UNMARSHAL_FUNCTION) \ |
| (TPM_RC_SUCCESS == (result = (UNMARSHAL_FUNCTION))) |
| |
| marshalIndex_t IntegerDispatch[] = { |
| UINT8_MARSHAL_REF, UINT16_MARSHAL_REF, UINT32_MARSHAL_REF, UINT64_MARSHAL_REF, |
| INT8_MARSHAL_REF, INT16_MARSHAL_REF, INT32_MARSHAL_REF, INT64_MARSHAL_REF |
| }; |
| |
| #if 1 |
| #define GetDescriptor(reference) \ |
| ((MarshalHeader_mst *)(((BYTE *)(&MarshalData)) + (reference & NULL_MASK))) |
| #else |
| static const MarshalHeader_mst *GetDescriptor(marshalIndex_t index) |
| { |
| const MarshalHeader_mst *mst = MarshalLookupTable[index & NULL_MASK]; |
| return mst; |
| } |
| #endif |
| |
| #define GetUnionDescriptor(_index_) \ |
| ((UnionMarshal_mst *)GetDescriptor(_index_)) |
| #define GetArrayDescriptor(_index_) \ |
| ((ArrayMarshal_mst *))(ArrayLookupTable[_index_ & NULL_MASK]) |
| |
| //*** GetUnmarshaledInteger() |
| // Gets the unmarshaled value and normalizes it to a UIN32 for other |
| // processing (comparisons and such). |
| static UINT32 GetUnmarshaledInteger( |
| marshalIndex_t type, |
| const void *target |
| ) |
| { |
| int size = (type & SIZE_MASK); |
| // |
| if(size == FOUR_BYTES) |
| return *((UINT32 *)target); |
| if(type & IS_SIGNED) |
| { |
| if(size == TWO_BYTES) |
| return (UINT32)*((int16_t *)target); |
| return (UINT32)*((int8_t *)target); |
| } |
| if(size == TWO_BYTES) |
| return (UINT32)*((UINT16 *)target); |
| return (UINT32)*((UINT8 *)target); |
| } |
| |
| static UINT32 GetSelector( |
| void *structure, |
| const UINT16 *values, |
| UINT16 descriptor |
| ) |
| { |
| unsigned sel = GET_ELEMENT_NUMBER(descriptor); |
| // Get the offset of the value in the unmarshaled structure |
| const UINT16 *entry = &values[(sel * 3)]; |
| // |
| return GetUnmarshaledInteger(GET_ELEMENT_SIZE(entry[0]), |
| ((UINT8 *)structure) + entry[2]); |
| } |
| |
| static TPM_RC UnmarshalBytes( |
| UINT8 *target, // IN/OUT: place to put the bytes |
| UINT8 **buffer, // IN/OUT: source of the input data |
| INT32 *size, // IN/OUT: remaining bytes in the input buffer |
| int count // IN: number of bytes to get |
| ) |
| { |
| if((*size -= count) >= 0) |
| { |
| memcpy(target, *buffer, count); |
| *buffer += count; |
| return TPM_RC_SUCCESS; |
| } |
| return TPM_RC_INSUFFICIENT; |
| } |
| |
| //*** MarshalBytes() |
| // Marshal an array of bytes. |
| static UINT16 MarshalBytes( |
| UINT8 *source, |
| UINT8 **buffer, |
| INT32 *size, |
| int32_t count |
| ) |
| { |
| if(buffer != NULL) |
| { |
| if(size != NULL && (size -= count) < 0) |
| return 0; |
| memcpy(*buffer, source, count); |
| *buffer += count; |
| } |
| return (UINT16)count; |
| } |
| |
| //*** ArrayUnmarshal() |
| // Unmarshal an array. The 'index' is of the form: 'type'_ARRAY_MARSHAL_INDEX. |
| static TPM_RC ArrayUnmarshal( |
| UINT16 index, // IN: the type of the array |
| UINT8 *target, // IN: target for the data |
| UINT8 **buffer, // IN/OUT: place to get the data |
| INT32 *size, // IN/OUT: remaining unmarshal data |
| UINT32 count // IN: number of values of 'index' to |
| // unmarshal |
| ) |
| { |
| marshalIndex_t which = ArrayLookupTable[index & NULL_MASK].type; |
| UINT16 stride = ArrayLookupTable[index & NULL_MASK].stride; |
| TPM_RC result; |
| // |
| if(stride == 1) // A byte array |
| result = UnmarshalBytes(target, buffer, size, count); |
| else |
| { |
| which |= index & NULL_FLAG; |
| for(result = TPM_RC_SUCCESS; count > 0; target += stride, count--) |
| if(!IS_SUCCESS(Unmarshal(which, target, buffer, size))) |
| break; |
| } |
| return result; |
| } |
| |
| //*** ArrayMarshal() |
| static UINT16 ArrayMarshal( |
| UINT16 index, // IN: the type of the array |
| UINT8 *source, // IN: source of the data |
| UINT8 **buffer, // IN/OUT: place to put the data |
| INT32 *size, // IN/OUT: amount of space for the data |
| UINT32 count // IN: number of values of 'index' to marshal |
| ) |
| { |
| marshalIndex_t which = ArrayLookupTable[index & NULL_MASK].type; |
| UINT16 stride = ArrayLookupTable[index & NULL_MASK].stride; |
| UINT16 retVal; |
| // |
| if(stride == 1) // A byte array |
| return MarshalBytes(source, buffer, size, count); |
| which |= index & NULL_FLAG; |
| for(retVal = 0 |
| ; count > 0 |
| ; source += stride, count--) |
| retVal += Marshal(which, source, buffer, size); |
| |
| return retVal; |
| } |
| |
| //***UnmarshalUnion() |
| TPM_RC |
| UnmarshalUnion( |
| UINT16 typeIndex, // IN: the thing to unmarshal |
| void *target, // IN: were the data goes to |
| UINT8 **buffer, // IN/OUT: the data source buffer |
| INT32 *size, // IN/OUT: the remaining size |
| UINT32 selector |
| ) |
| { |
| int i; |
| UnionMarshal_mst *ut = GetUnionDescriptor(typeIndex); |
| marshalIndex_t selected; |
| // |
| for(i = 0; i < ut->countOfselectors; i++) |
| { |
| if(selector == ut->selectors[i]) |
| { |
| UINT8 *offset = ((UINT8 *)ut) + ut->offsetOfUnmarshalTypes; |
| // Get the selected thing to unmarshal |
| selected = ((marshalIndex_t *)offset)[i]; |
| if(ut->modifiers & IS_ARRAY_UNION) |
| return UnmarshalBytes(target, buffer, size, selected); |
| else |
| { |
| // Propagate NULL_FLAG if the null flag was |
| // propagated to the structure containing the union |
| selected |= (typeIndex & NULL_FLAG); |
| return Unmarshal(selected, target, buffer, size); |
| } |
| } |
| } |
| // Didn't find the value. |
| return TPM_RC_SELECTOR; |
| } |
| |
| //*** MarshalUnion() |
| UINT16 |
| MarshalUnion( |
| UINT16 typeIndex, // IN: the thing to marshal |
| void *source, // IN: were the data comes from |
| UINT8 **buffer, // IN/OUT: the data source buffer |
| INT32 *size, // IN/OUT: the remaining size |
| UINT32 selector // IN: the union selector |
| ) |
| { |
| int i; |
| UnionMarshal_mst *ut = GetUnionDescriptor(typeIndex); |
| marshalIndex_t selected; |
| // |
| for(i = 0; i < ut->countOfselectors; i++) |
| { |
| if(selector == ut->selectors[i]) |
| { |
| UINT8 *offset = ((UINT8 *)ut) + ut->offsetOfUnmarshalTypes; |
| // Get the selected thing to unmarshal |
| selected = ((marshalIndex_t *)offset)[i]; |
| if(ut->modifiers & IS_ARRAY_UNION) |
| return MarshalBytes(source, buffer, size, selected); |
| else |
| return Marshal(selected, source, buffer, size); |
| } |
| } |
| if(size != NULL) |
| *size = -1; |
| return 0; |
| } |
| |
| TPM_RC |
| UnmarshalInteger( |
| int iSize, // IN: Number of bytes in the integer |
| void *target, // OUT: receives the integer |
| UINT8 **buffer, // IN/OUT: source of the data |
| INT32 *size, // IN/OUT: amount of data available |
| UINT32 *value // OUT: optional copy of 'target' |
| ) |
| { |
| // This is just to save typing |
| #define _MB_ (*buffer) |
| // The size is a power of two so convert to regular integer |
| int bytes = (1 << (iSize & SIZE_MASK)); |
| // |
| // Check to see if there is enough data to fulfill the request |
| if((*size -= bytes) >= 0) |
| { |
| // The most comon size |
| if(bytes == 4) |
| { |
| *((UINT32 *)target) = (UINT32)((((((_MB_[0] << 8) | _MB_[1]) << 8) |
| | _MB_[2]) << 8) | _MB_[3]); |
| // If a copy is needed, copy it. |
| if(value != NULL) |
| *value = *((UINT32 *)target); |
| } |
| else if(bytes == 2) |
| { |
| *((UINT16 *)target) = (UINT16)((_MB_[0] << 8) | _MB_[1]); |
| // If a copy is needed, copy with the appropriate sign extension |
| if(value != NULL) |
| { |
| if(iSize & IS_SIGNED) |
| *value = (UINT32)(*((INT16 *)target)); |
| else |
| *value = (UINT32)(*((UINT16 *)target)); |
| } |
| } |
| else if(bytes == 1) |
| { |
| *((UINT8*)target) = (UINT8)_MB_[0]; |
| // If a copy is needed, copy with the appropriate sign extension |
| if(value != NULL) |
| { |
| if(iSize & IS_SIGNED) |
| *value = (UINT32)(*((INT8 *)target)); |
| else |
| *value = (UINT32)(*((UINT8 *)target)); |
| } |
| } |
| else |
| { |
| // There is no input type that is a 64-bit value other than a UINT64. So |
| // there is no reason to do anything other than unmarshal it. |
| *((UINT64 *)target) = BYTE_ARRAY_TO_UINT64(*buffer); |
| } |
| *buffer += bytes; |
| return TPM_RC_SUCCESS; |
| #undef _MB_ |
| } |
| return TPM_RC_INSUFFICIENT; |
| } |
| |
| //*** Unmarshal() |
| // This is the function that performs unmarshaling of different numbered types. Each |
| // TPM type has a number. The number is used to lookup the address of the data |
| // structure that describes how to unmarshal that data type. |
| // |
| TPM_RC |
| Unmarshal( |
| UINT16 typeIndex, // IN: the thing to marshal |
| void *target, // IN: were the data goes from |
| UINT8 **buffer, // IN/OUT: the data source buffer |
| INT32 *size // IN/OUT: the remaining size |
| ) |
| { |
| const MarshalHeader_mst *sel; |
| TPM_RC result; |
| // |
| sel = GetDescriptor(typeIndex); |
| switch(sel->marshalType) |
| { |
| case UINT_MTYPE: |
| { |
| // A simple signed or unsigned integer value. |
| return UnmarshalInteger(sel->modifiers, target, |
| buffer, size, NULL); |
| } |
| case VALUES_MTYPE: |
| { |
| // This is the general-purpose structure that can handle things like |
| // TPMI_DH_PARENT that has multiple ranges, multiple singles and a |
| // 'null' value. When things cover a large range with holes in the range |
| // they can be turned into multiple ranges. There is no option for a bit |
| // field. |
| // The structure is: |
| // typedef const struct ValuesMarshal_mst |
| // { |
| // UINT8 marshalType; // VALUES_MTYPE |
| // UINT8 modifiers; |
| // UINT8 errorCode; |
| // UINT8 ranges; |
| // UINT8 singles; |
| // UINT32 values[1]; |
| // } ValuesMarshal_mst; |
| // Unmarshal the base type |
| UINT32 val; |
| if(IS_SUCCESS(UnmarshalInteger(sel->modifiers, target, |
| buffer, size, &val))) |
| { |
| ValuesMarshal_mst *vmt = ((ValuesMarshal_mst *)sel); |
| const UINT32 *check = vmt->values; |
| // |
| // if the TAKES_NULL flag is set, then the first entry in the values |
| // list is the NULL value. Iy is not included in the 'ranges' or |
| // 'singles' count. |
| if((vmt->modifiers & TAKES_NULL) && (val == *check++)) |
| { |
| if((typeIndex & NULL_FLAG) == 0) |
| result = (TPM_RC)(sel->errorCode); |
| } |
| // No NULL value or input is not the NULL value |
| else |
| { |
| int i; |
| // |
| // Check all the min-max ranges. |
| for(i = vmt->ranges - 1; i >= 0; check = &check[2], i--) |
| if((UINT32)(val - check[0]) <= check[1]) |
| break; |
| // if the input is in a selected range, then i >= 0 |
| if(i < 0) |
| { |
| // Not in any range, so check sigles |
| for(i = vmt->singles - 1; i >= 0; i--) |
| if(val == check[i]) |
| break; |
| } |
| // If input not in range and not in any single so return error |
| if(i < 0) |
| result = (TPM_RC)(sel->errorCode); |
| } |
| } |
| break; |
| } |
| case TABLE_MTYPE: |
| { |
| // This is a table with or without bit checking. The input is checked |
| // against each value in the table. If the value is in the table, and |
| // a bits table is present, then the bit field is checked to see if the |
| // indicated value is implemented. For example, if there is a table of |
| // allowed RSA key sizes and the 2nd entry matches, then the 2nd bit in |
| // the bit field is checked to see if that allowed size is implemented |
| // in this TPM. |
| // typedef const struct TableMarshal_mst |
| // { |
| // UINT8 marshalType; // TABLE_MTYPE |
| // UINT8 modifiers; |
| // UINT8 errorCode; |
| // UINT8 singles; |
| // UINT32 values[singles + 1 if TAKES_NULL]; |
| // } TableMarshal_mst; |
| |
| UINT32 val; |
| // |
| // Unmarshal the base type |
| if(IS_SUCCESS(UnmarshalInteger(sel->modifiers, target, |
| buffer, size, &val))) |
| { |
| TableMarshal_mst *tmt = ((TableMarshal_mst *)sel); |
| const UINT32 *check = tmt->values; |
| // |
| // If this type has a null value, then it is the first value in the |
| // list of values. It does not count in the count of values |
| if((tmt->modifiers & TAKES_NULL) && (val == *check++)) |
| { |
| if((typeIndex & NULL_FLAG) == 0) |
| result = (TPM_RC)(sel->errorCode); |
| } |
| else |
| { |
| int i; |
| // |
| // Process the singles |
| for(i = tmt->singles - 1; i >= 0; i--) |
| { |
| // does the input value match the value in the table |
| if(val == check[i]) |
| { |
| // If there is an associated bit table, make sure that |
| // the corresponding bit is SET |
| if((HAS_BITS & tmt->modifiers) |
| && (!IS_BIT_SET32(i, &(check[tmt->singles])))) |
| // if not SET, then this is a failure. |
| i = -1; |
| break; |
| } |
| } |
| // error if not found or bit not SET |
| if(i < 0) |
| result = (TPM_RC)(sel->errorCode); |
| } |
| } |
| break; |
| } |
| case MIN_MAX_MTYPE: |
| { |
| // A MIN_MAX is a range. It can have a bit field and a NULL value that is |
| // outside of the range. If the input value is in the min-max range then |
| // it is valid unless there is an associated bit field. Otherwise, it |
| // it is only valid if the corresponding value in the bit field is SET. |
| // The min value is 'values[0]' or 'values[1]' if there is a NULL value. |
| // The max value is the value after min. The max value is in the table as |
| // max minus min. This allows 'val' to be subtracted from min and then |
| // checked against max with one unsigned comparison. If present, the bit |
| // field will be the first 'values' after max. |
| // typedef const struct MinMaxMarshal_mst |
| // { |
| // UINT8 marshalType; // MIN_MAX_MTYPE |
| // UINT8 modifiers; |
| // UINT8 errorCode; |
| // UINT32 values[2 + 1 if TAKES_NULL]; |
| // } MinMaxMarshal_mst; |
| UINT32 val; |
| // |
| // A min-max has a range. It can have a bit-field that is indexed to the |
| // min value (something that matches min has a bit at 0. This is useful |
| // for algorithms. The min-max define a range of algorithms to be checked |
| // and the bit field can check to see if the algorithm in that range is |
| // allowed. |
| if(IS_SUCCESS(UnmarshalInteger(sel->modifiers, target, |
| buffer, size, &val))) |
| { |
| MinMaxMarshal_mst *mmt = (MinMaxMarshal_mst *)sel; |
| const UINT32 *check = mmt->values; |
| // |
| // If this type takes a NULL, see if it matches. This |
| if((mmt->modifiers & TAKES_NULL) && (val == *check++)) |
| { |
| if((typeIndex & NULL_FLAG) == 0) |
| result = (TPM_RC)(mmt->errorCode); |
| } |
| else |
| { |
| val -= *check; |
| if((val > check[1]) |
| || ((mmt->modifiers & HAS_BITS) && |
| !IS_BIT_SET32(val, &check[2]))) |
| result = (TPM_RC)(mmt->errorCode); |
| } |
| } |
| break; |
| } |
| case ATTRIBUTES_MTYPE: |
| { |
| // This is used for TPMA values. |
| UINT32 mask; |
| AttributesMarshal_mst *amt = (AttributesMarshal_mst *)sel; |
| // |
| if(IS_SUCCESS(UnmarshalInteger(sel->modifiers, target, |
| buffer, size, &mask))) |
| { |
| if((mask & amt->attributeMask) != 0) |
| result = TPM_RC_RESERVED_BITS; |
| } |
| break; |
| } |
| case STRUCTURE_MTYPE: |
| { |
| // A structure (not a union). A structure has elements (one defined per |
| // row). Three UINT16 values are used for each row. The first indicates |
| // the type of the entry. They choices are: simple, union, or array. A |
| // simple type can be a simple integer or another structure. It can also |
| // be a specific "interface type." For example, when a structure entry is |
| // a value that is used define the dimension of an array, the entry of |
| // the structure will reference a "synthetic" interface type, most often |
| // a min-max value. If the type of the entry is union or array, then the |
| // first value indicates which of the previous elements provides the union |
| // selector or the array dimension. That previous entry is referenced in |
| // the unmarshaled structure in memory (Not the marshaled buffer). The |
| // previous entry indicates the location in the structure of the value. |
| // The second entry of each structure entry indicated the index of the |
| // type associated with the entry. This is an index into the array of |
| // arrays or the union table (merged with the normal table in this |
| // implementation). The final entry is the offset in the unmarshaled |
| // structure where the value is located. This is the offsetof(STRUcTURE, |
| // element). This value is added to the input 'target' or 'source' value |
| // to determine where the value goes. |
| StructMarshal_mst *mst = (StructMarshal_mst *)sel; |
| int i; |
| const UINT16 *value = mst->values; |
| // |
| for(result = TPM_RC_SUCCESS, i = mst->elements |
| ; (TPM_RC_SUCCESS == result) && (i > 0) |
| ; value = &value[3], i--) |
| { |
| UINT16 descriptor = value[0]; |
| marshalIndex_t index = value[1]; |
| // The offset of the object in the structure is in the last value in |
| // the triplet. Add that value to the start of the structure |
| UINT8 *offset = ((UINT8 *)target) + value[2]; |
| // |
| if ((ELEMENT_PROPAGATE & descriptor) |
| && (typeIndex & NULL_FLAG)) |
| index |= NULL_FLAG; |
| switch(GET_ELEMENT_TYPE(descriptor)) |
| { |
| case SIMPLE_STYPE: |
| { |
| result = Unmarshal(index, offset, buffer, size); |
| break; |
| } |
| case UNION_STYPE: |
| { |
| UINT32 choice; |
| // |
| // Get the selector or array dimension value |
| choice = GetSelector(target, mst->values, descriptor); |
| result = UnmarshalUnion(index, offset, buffer, size, choice); |
| break; |
| } |
| case ARRAY_STYPE: |
| { |
| UINT32 dimension; |
| // |
| dimension = GetSelector(target, mst->values, descriptor); |
| result = ArrayUnmarshal(index, offset, buffer, |
| size, dimension); |
| break; |
| } |
| default: |
| result = TPM_RC_FAILURE; |
| break; |
| } |
| } |
| break; |
| } |
| case TPM2B_MTYPE: |
| { |
| // A primitive TPM2B. A size and byte buffer. The single value (other than |
| // the tag) references the synthetic 'interface' value for the size |
| // parameter. |
| Tpm2bMarshal_mst *m2bt = (Tpm2bMarshal_mst *)sel; |
| // |
| if(IS_SUCCESS(Unmarshal(m2bt->sizeIndex, target, buffer, size))) |
| result = UnmarshalBytes(((TPM2B *)target)->buffer, |
| buffer, size, *((UINT16 *)target)); |
| break; |
| } |
| case TPM2BS_MTYPE: |
| { |
| // This is used when a TPM2B contains a structure. |
| Tpm2bsMarshal_mst *m2bst = (Tpm2bsMarshal_mst *)sel; |
| INT32 count; |
| // |
| if(IS_SUCCESS(Unmarshal(m2bst->sizeIndex, target, buffer, size))) |
| { |
| // fetch the size value and convert it to a 32-bit count value |
| count = (int32_t)*((UINT16 *)target); |
| if(count == 0) |
| { |
| if(m2bst->modifiers & SIZE_EQUAL) |
| result = TPM_RC_SIZE; |
| } |
| else if((*size -= count) >= 0) |
| { |
| marshalIndex_t index = m2bst->dataIndex; |
| // |
| // If this type propigates a null (PROPIGATE_NULL), propigate it |
| if ((m2bst->modifiers & PROPAGATE_NULL) |
| && (typeIndex & typeIndex)) |
| index |= NULL_FLAG; |
| // The structure might not start two bytes after the start of the |
| // size field. The offset to the start of the structure is between |
| // 2 and 8 bytes. This is encoded into the low 4 bits of the |
| // modifiers byte byte |
| if(IS_SUCCESS(Unmarshal(index, |
| ((UINT8 *)target) + (m2bst->modifiers & OFFSET_MASK), |
| buffer, &count))) |
| { |
| if(count != 0) |
| result = TPM_RC_SIZE; |
| } |
| } |
| else |
| result = TPM_RC_INSUFFICIENT; |
| } |
| break; |
| } |
| case LIST_MTYPE: |
| { |
| // Used for a list. A list is a qualified 32-bit 'count' value followed |
| // by a type indicator. |
| ListMarshal_mst *mlt = (ListMarshal_mst *)sel; |
| marshalIndex_t index = mlt->arrayRef; |
| // |
| if(IS_SUCCESS(Unmarshal(mlt->sizeIndex, target, buffer, size))) |
| { |
| // If this type propigates a null (PROPIGATE_NULL), propigate it |
| if ((mlt->modifiers & PROPAGATE_NULL) |
| && (typeIndex & NULL_FLAG)) |
| index |= NULL_FLAG; |
| result = ArrayUnmarshal(index, |
| ((UINT8 *)target) +(mlt->modifiers & OFFSET_MASK), |
| buffer, size, *((UINT32 *)target)); |
| } |
| break; |
| } |
| case NULL_MTYPE: |
| { |
| result = TPM_RC_SUCCESS; |
| break; |
| } |
| #if 0 |
| case COMPOSITE_MTYPE: |
| { |
| CompositeMarshal_mst *mct = (CompositeMarshal_mst *)sel; |
| int i; |
| UINT8 *buf = *buffer; |
| INT32 sz = *size; |
| // |
| result = TPM_RC_VALUE; |
| for(i = GET_ELEMENT_COUNT(mct->modifiers) - 1; i <= 0; i--) |
| { |
| marshalIndex_t index = mct->types[i]; |
| // |
| // This type might take a null so set it in each called value, just |
| // in case it is needed in that value. Only one value in each |
| // composite should have the takes null SET. |
| index |= typeIndex & NULL_MASK; |
| result = Unmarshal(index, target, buffer, size); |
| if(result == TPM_RC_SUCCESS) |
| break; |
| // Each of the composite values does its own unmarshaling. This |
| // has some execution overhead if it is unmarshaled multiple times |
| // but it saves code size in not having to reproduce the various |
| // unmarshaling types that can be in a composite. So, what this means |
| // is that the buffer pointer and size have to be reset for each |
| // unmarshaled value. |
| *buffer = buf; |
| *size = sz; |
| } |
| break; |
| } |
| #endif // 0 |
| default: |
| { |
| result = TPM_RC_FAILURE; |
| break; |
| } |
| } |
| return result; |
| } |
| |
| //*** Marshal() |
| // This is the function that drives marshaling of output. Because there is no |
| // validation of the output, there is a lot less code. |
| UINT16 Marshal( |
| UINT16 typeIndex, // IN: the thing to marshal |
| void *source, // IN: were the data comes from |
| UINT8 **buffer, // IN/OUT: the data source buffer |
| INT32 *size // IN/OUT: the remaining size |
| ) |
| { |
| #define _source ((UINT8 *)source) |
| |
| const MarshalHeader_mst *sel; |
| UINT16 retVal; |
| // |
| sel = GetDescriptor(typeIndex); |
| switch(sel->marshalType) |
| { |
| case VALUES_MTYPE: |
| case UINT_MTYPE: |
| case TABLE_MTYPE: |
| case MIN_MAX_MTYPE: |
| case ATTRIBUTES_MTYPE: |
| case COMPOSITE_MTYPE: |
| { |
| #if BIG_ENDIAN_TPM |
| #define MM16 0 |
| #define MM32 0 |
| #define MM64 0 |
| #else |
| // These flip the constant index values so that they count in reverse order when doing |
| // little-endian stuff |
| #define MM16 1 |
| #define MM32 3 |
| #define MM64 7 |
| #endif |
| // Just change the name and cast the type of the input parameters for typing purposes |
| #define mb (*buffer) |
| #define _source ((UINT8 *)source) |
| retVal = (1 << (sel->modifiers & SIZE_MASK)); |
| if(buffer != NULL) |
| { |
| if((size == NULL) || ((*size -= retVal) >= 0)) |
| { |
| if(retVal == 4) |
| { |
| mb[0 ^ MM32] = _source[0]; |
| mb[1 ^ MM32] = _source[1]; |
| mb[2 ^ MM32] = _source[2]; |
| mb[3 ^ MM32] = _source[3]; |
| } |
| else if(retVal == 2) |
| { |
| mb[0 ^ MM16] = _source[0]; |
| mb[1 ^ MM16] = _source[1]; |
| } |
| else if(retVal == 1) |
| mb[0] = _source[0]; |
| else |
| { |
| mb[0 ^ MM64] = _source[0]; |
| mb[1 ^ MM64] = _source[1]; |
| mb[2 ^ MM64] = _source[2]; |
| mb[3 ^ MM64] = _source[3]; |
| mb[4 ^ MM64] = _source[4]; |
| mb[5 ^ MM64] = _source[5]; |
| mb[6 ^ MM64] = _source[6]; |
| mb[7 ^ MM64] = _source[7]; |
| } |
| *buffer += retVal; |
| } |
| } |
| break; |
| } |
| case STRUCTURE_MTYPE: |
| { |
| //#define _mst ((StructMarshal_mst *)sel) |
| StructMarshal_mst *mst = ((StructMarshal_mst *)sel); |
| int i; |
| const UINT16 *value = mst->values; |
| |
| // |
| for(retVal = 0, i = mst->elements; i > 0; value = &value[3], i--) |
| { |
| UINT16 des = value[0]; |
| marshalIndex_t index = value[1]; |
| UINT8 *offset = _source + value[2]; |
| // |
| switch(GET_ELEMENT_TYPE(des)) |
| { |
| case UNION_STYPE: |
| { |
| UINT32 choice; |
| // |
| choice = GetSelector(source, mst->values, des); |
| retVal += MarshalUnion(index, offset, buffer, size, choice); |
| break; |
| } |
| case ARRAY_STYPE: |
| { |
| UINT32 count; |
| // |
| count = GetSelector(source, mst->values, des); |
| retVal += ArrayMarshal(index, offset, buffer, size, count); |
| break; |
| } |
| case SIMPLE_STYPE: |
| default: |
| { |
| // This is either another structure or a simple type |
| retVal += Marshal(index, offset, buffer, size); |
| break; |
| } |
| } |
| } |
| break; |
| } |
| case TPM2B_MTYPE: |
| { |
| // Get the number of bytes being marshaled |
| INT32 val = (int32_t)*((UINT16 *)source); |
| // |
| retVal = Marshal(UINT16_MARSHAL_REF, source, buffer, size); |
| |
| // This is a standard 2B with a byte buffer |
| retVal += MarshalBytes(((TPM2B *)_source)->buffer, buffer, size, val); |
| break; |
| } |
| case TPM2BS_MTYPE: // A structure in a TPM2B |
| { |
| Tpm2bsMarshal_mst *m2bst = (Tpm2bsMarshal_mst *)sel; |
| UINT8 *offset; |
| UINT16 amount; |
| UINT8 *marshaledSize; |
| // |
| // Save the address of where the size should go |
| marshaledSize = *buffer; |
| |
| // marshal the size (checks the space and advanced the pointer) |
| retVal = Marshal(UINT16_MARSHAL_REF, source, buffer, size); |
| |
| // This gets the 'offsetof' the structure to marshal. It was placed in the |
| // modifiers byte because the offset from the start of the TPM2B to the |
| // start of the structure is going to be less than 8 and the modifiers |
| // byte isn't needed for anything else. |
| offset = _source + (m2bst->modifiers & SIGNED_MASK); |
| |
| // Marshal the structure and get its size |
| amount = Marshal(m2bst->dataIndex, offset, buffer, size); |
| |
| // put the size in the space used when the size was marshaled. |
| if(buffer != NULL) |
| UINT16_TO_BYTE_ARRAY(amount, marshaledSize); |
| retVal += amount; |
| break; |
| } |
| case LIST_MTYPE: |
| { |
| ListMarshal_mst * mlt = ((ListMarshal_mst *)sel); |
| UINT8 *offset = _source + (mlt->modifiers & SIGNED_MASK); |
| retVal = Marshal(UINT32_MARSHAL_REF, source, buffer, size); |
| retVal += ArrayMarshal((marshalIndex_t)(mlt->arrayRef), offset, |
| buffer, size, *((UINT32 *)source)); |
| break; |
| } |
| case NULL_MTYPE: |
| retVal = 0; |
| break; |
| case ERROR_MTYPE: |
| default: |
| { |
| if(size != NULL) |
| *size = -1; |
| retVal = 0; |
| break; |
| } |
| } |
| return retVal; |
| |
| } |
| |
| #endif // TABLE_DRIVEN_MARSHAL |
