stefanberger / libtpms / #2046

/********************************************************************************/

/*                                                                                */

/*                Functions for testing various command properties                */

/*                             Written by Ken Goldman                                */

/*                       IBM Thomas J. Watson Research Center                        */

/*                                                                                */

/*  Licenses and Notices                                                        */

/*                                                                                */

/*  1. Copyright Licenses:                                                        */

/*                                                                                */

/*  - Trusted Computing Group (TCG) grants to the user of the source code in        */

/*    this specification (the "Source Code") a worldwide, irrevocable,                 */

/*    nonexclusive, royalty free, copyright license to reproduce, create         */

/*    derivative works, distribute, display and perform the Source Code and        */

/*    derivative works thereof, and to grant others the rights granted herein.        */

/*                                                                                */

/*  - The TCG grants to the user of the other parts of the specification         */

/*    (other than the Source Code) the rights to reproduce, distribute,         */

/*    display, and perform the specification solely for the purpose of                 */

/*    developing products based on such documents.                                */

/*                                                                                */

/*  2. Source Code Distribution Conditions:                                        */

/*                                                                                */

/*  - Redistributions of Source Code must retain the above copyright licenses,         */

/*    this list of conditions and the following disclaimers.                        */

/*                                                                                */

/*  - Redistributions in binary form must reproduce the above copyright         */

/*    licenses, this list of conditions        and the following disclaimers in the         */

/*    documentation and/or other materials provided with the distribution.        */

/*                                                                                */

/*  3. Disclaimers:                                                                */

/*                                                                                */

/*  - THE COPYRIGHT LICENSES SET FORTH ABOVE DO NOT REPRESENT ANY FORM OF        */

/*  LICENSE OR WAIVER, EXPRESS OR IMPLIED, BY ESTOPPEL OR OTHERWISE, WITH        */

/*  RESPECT TO PATENT RIGHTS HELD BY TCG MEMBERS (OR OTHER THIRD PARTIES)        */

/*  THAT MAY BE NECESSARY TO IMPLEMENT THIS SPECIFICATION OR OTHERWISE.                */

/*  Contact TCG Administration (admin@trustedcomputinggroup.org) for                 */

/*  information on specification licensing rights available through TCG         */

/*  membership agreements.                                                        */

/*                                                                                */

/*  - THIS SPECIFICATION IS PROVIDED "AS IS" WITH NO EXPRESS OR IMPLIED         */

/*    WARRANTIES WHATSOEVER, INCLUDING ANY WARRANTY OF MERCHANTABILITY OR         */

/*    FITNESS FOR A PARTICULAR PURPOSE, ACCURACY, COMPLETENESS, OR                 */

/*    NONINFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS, OR ANY WARRANTY                 */

/*    OTHERWISE ARISING OUT OF ANY PROPOSAL, SPECIFICATION OR SAMPLE.                */

/*                                                                                */

/*  - Without limitation, TCG and its members and licensors disclaim all         */

/*    liability, including liability for infringement of any proprietary         */

/*    rights, relating to use of information in this specification and to the        */

/*    implementation of this specification, and TCG disclaims all liability for        */

/*    cost of procurement of substitute goods or services, lost profits, loss         */

/*    of use, loss of data or any incidental, consequential, direct, indirect,         */

/*    or special damages, whether under contract, tort, warranty or otherwise,         */

/*    arising in any way out of use or reliance upon this specification or any         */

/*    information herein.                                                        */

/*                                                                                */

/*  (c) Copyright IBM Corp. and others, 2016 - 2023                                */

/*                                                                                */

/********************************************************************************/

//** Introduction

// This file contains the functions for testing various command properties.

//** Includes and Defines

#include "Tpm.h"

#include "CommandCodeAttributes_fp.h"

// Set the default value for CC_VEND if not already set

#ifndef CC_VEND

#  define CC_VEND (TPM_CC)(0x20000000)

#endif

typedef UINT16 ATTRIBUTE_TYPE;

// The following file is produced from the command tables in part 3 of the

// specification. It defines the attributes for each of the commands.

// NOTE: This file is currently produced by an automated process. Files

// produced from Part 2 or Part 3 tables through automated processes are not

// included in the specification so that their is no ambiguity about the

// table containing the information being the normative definition.

#define _COMMAND_CODE_ATTRIBUTES_

#include "CommandAttributeData.h"

//** Command Attribute Functions

//*** NextImplementedIndex()

// This function is used when the lists are not compressed. In a compressed list,

// only the implemented commands are present. So, a search might find a value

// but that value may not be implemented. This function checks to see if the input

// commandIndex points to an implemented command and, if not, it searches upwards

// until it finds one. When the list is compressed, this function gets defined

// as a no-op.

//  Return Type: COMMAND_INDEX

//  UNIMPLEMENTED_COMMAND_INDEX     command is not implemented

//  other                           index of the command

#if !COMPRESSED_LISTS

{

    {

                                                    TPMA_CC, commandIndex)))        // libtpms added end

    }

    return UNIMPLEMENTED_COMMAND_INDEX;

}

#else

#  define NextImplementedIndex(x) (x)

#endif

//*** GetClosestCommandIndex()

// This function returns the command index for the command with a value that is

// equal to or greater than the input value

//  Return Type: COMMAND_INDEX

//  UNIMPLEMENTED_COMMAND_INDEX     command is not implemented

//  other                           index of a command

COMMAND_INDEX

)

{

    // The commandCode is a UINT32 and the search index is UINT16. We are going to

    // search for a match but need to make sure that the commandCode value is not

    // out of range. To do this, need to clear the vendor bit of the commandCode

    // (if set) and compare the result to the 16-bit searchIndex value. If it is

    // out of range, indicate that the command is not implemented

        return UNIMPLEMENTED_COMMAND_INDEX;

    // if there is at least one vendor command, the last entry in the array will

    // have the v bit set. If the input commandCode is larger than the last

    // vendor-command, then it is out of range.

    {

#if VENDOR_COMMAND_ARRAY_SIZE > 0

        COMMAND_INDEX commandIndex;

        COMMAND_INDEX min;

        COMMAND_INDEX max;

        int           diff;

#  if LIBRARY_COMMAND_ARRAY_SIZE == COMMAND_COUNT

#    error "Constants are not consistent."

#  endif

        // Check to see if the value is equal to or below the minimum

        // entry.

        // Note: Put this check first so that the typical case of only one vendor-

        // specific command doesn't waste any more time.

        if(GET_ATTRIBUTE(s_ccAttr[LIBRARY_COMMAND_ARRAY_SIZE], TPMA_CC, commandIndex)

           >= searchIndex)

        {

            // the vendor array is always assumed to be packed so there is

            // no need to check to see if the command is implemented

            return LIBRARY_COMMAND_ARRAY_SIZE;

        }

        // See if this is out of range on the top

        if(GET_ATTRIBUTE(s_ccAttr[COMMAND_COUNT - 1], TPMA_CC, commandIndex)

           < searchIndex)

        {

            return UNIMPLEMENTED_COMMAND_INDEX;

        }

        commandIndex = UNIMPLEMENTED_COMMAND_INDEX;  // Needs initialization to keep

                                                     // compiler happy

        min  = LIBRARY_COMMAND_ARRAY_SIZE;           // first vendor command

        max  = COMMAND_COUNT - 1;                    // last vendor command

        diff = 1;                                    // needs initialization to keep

                                                     // compiler happy

        while(min <= max)

        {

            commandIndex = (min + max + 1) / 2;

            diff = GET_ATTRIBUTE(s_ccAttr[commandIndex], TPMA_CC, commandIndex)

                   - searchIndex;

            if(diff == 0)

                return commandIndex;

            if(diff > 0)

                max = commandIndex - 1;

            else

                min = commandIndex + 1;

        }

        // didn't find and exact match. commandIndex will be pointing at the last

        // item tested. If 'diff' is positive, then the last item tested was

        // larger index of the command code so it is the smallest value

        // larger than the requested value.

        if(diff > 0)

            return commandIndex;

        // if 'diff' is negative, then the value tested was smaller than

        // the commandCode index and the next higher value is the correct one.

        // Note: this will necessarily be in range because of the earlier check

        // that the index was within range.

        return commandIndex + 1;

#else

        // If there are no vendor commands so anything with the vendor bit set is out

        // of range

        return UNIMPLEMENTED_COMMAND_INDEX;

#endif

    }

    // Get here if the V-Bit was not set in 'commandCode'

       < searchIndex)

    {

        // requested index is out of the range to the top

#if VENDOR_COMMAND_ARRAY_SIZE > 0

        // If there are vendor commands, then the first vendor command

        // is the next value greater than the commandCode.

        // NOTE: we got here if the starting index did not have the V bit but we

        // reached the end of the array of library commands (non-vendor). Since

        // there is at least one vendor command, and vendor commands are always

        // in a compressed list that starts after the library list, the next

        // index value contains a valid vendor command.

        return LIBRARY_COMMAND_ARRAY_SIZE;

#else

        // if there are no vendor commands, then this is out of range

        return UNIMPLEMENTED_COMMAND_INDEX;

#endif

    }

    // If the request is lower than any value in the array, then return

    // the lowest value (needs to be an index for an implemented command

    {

    }

    else

    {

#if COMPRESSED_LISTS

        COMMAND_INDEX commandIndex = UNIMPLEMENTED_COMMAND_INDEX;

        COMMAND_INDEX min          = 0;

        COMMAND_INDEX max          = LIBRARY_COMMAND_ARRAY_SIZE - 1;

        int           diff         = 1;

#  if LIBRARY_COMMAND_ARRAY_SIZE == 0

#    error "Something is terribly wrong"

#  endif

        // The s_ccAttr array contains an extra entry at the end (a zero value).

        // Don't count this as an array entry. This means that max should start

        // out pointing to the last valid entry in the array which is - 2

        pAssert(

            max

            == (sizeof(s_ccAttr) / sizeof(TPMA_CC) - VENDOR_COMMAND_ARRAY_SIZE - 2));

        while(min <= max)

        {

            commandIndex = (min + max + 1) / 2;

            diff = GET_ATTRIBUTE(s_ccAttr[commandIndex], TPMA_CC, commandIndex)

                   - searchIndex;

            if(diff == 0)

                return commandIndex;

            if(diff > 0)

                max = commandIndex - 1;

            else

                min = commandIndex + 1;

        }

        // didn't find and exact match. commandIndex will be pointing at the

        // last item tested. If diff is positive, then the last item tested was

        // larger index of the command code so it is the smallest value

        // larger than the requested value.

        if(diff > 0)

            return commandIndex;

        // if diff is negative, then the value tested was smaller than

        // the commandCode index and the next higher value is the correct one.

        // Note: this will necessarily be in range because of the earlier check

        // that the index was within range.

        return commandIndex + 1;

#else

        // The list is not compressed so offset into the array by the command

        // code value of the first entry in the list. Then go find the first

        // implemented command.

#endif

    }

}

//*** CommandCodeToComandIndex()

// This function returns the index in the various attributes arrays of the

// command.

//  Return Type: COMMAND_INDEX

//  UNIMPLEMENTED_COMMAND_INDEX     command is not implemented

//  other                           index of the command

COMMAND_INDEX

)

{

    // Extract the low 16-bits of the command code to get the starting search index

#if !COMPRESSED_LISTS

    {

        // Check for out of range or unimplemented.

        // Note, since a COMMAND_INDEX is unsigned, if searchIndex is smaller than

        // the lowest value of command, it will become a 'negative' number making

        // it look like a large unsigned number, this will cause it to fail

        // the unsigned check below.

                                           commandCode))                        // libtpms added

        return commandIndex;

    }

#endif

    // Need this code for any vendor code lookup or for compressed lists

    // Look at the returned value from get closest. If it isn't the one that was

    // requested, then the command is not implemented.

    // libtpms: Or it may be runtime-disabled

    {

            != searchIndex)

                                           commandCode))                        // libtpms added

            commandIndex = UNIMPLEMENTED_COMMAND_INDEX;

    }

    return commandIndex;

}

//*** GetNextCommandIndex()

// This function returns the index of the next implemented command.

//  Return Type: COMMAND_INDEX

//  UNIMPLEMENTED_COMMAND_INDEX     no more implemented commands

//  other                           the index of the next implemented command

COMMAND_INDEX

)

{

    {

                                                      TPMA_CC, commandIndex)))

#if !COMPRESSED_LISTS

#endif

    }

    return UNIMPLEMENTED_COMMAND_INDEX;

}

//*** GetCommandCode()

// This function returns the commandCode associated with the command index

TPM_CC

)

{

}

//*** CommandAuthRole()

//

//  This function returns the authorization role required of a handle.

//

//  Return Type: AUTH_ROLE

//  AUTH_NONE       no authorization is required

//  AUTH_USER       user role authorization is required

//  AUTH_ADMIN      admin role authorization is required

//  AUTH_DUP        duplication role authorization is required

AUTH_ROLE

                UINT32        handleIndex    // IN: handle index (zero based)

)

{

    {

        // Any authorization role set?

            return AUTH_USER;

            return AUTH_ADMIN;

    }

    {

    }

    return AUTH_NONE;

}

//*** EncryptSize()

// This function returns the size of the decrypt size field. This function returns

// 0 if encryption is not allowed

//  Return Type: int

//  0       encryption not allowed

//  2       size field is two bytes

//  4       size field is four bytes

)

{

}

//*** DecryptSize()

// This function returns the size of the decrypt size field. This function returns

// 0 if decryption is not allowed

//  Return Type: int

//  0       encryption not allowed

//  2       size field is two bytes

//  4       size field is four bytes

)

{

}

//*** IsSessionAllowed()

//

// This function indicates if the command is allowed to have sessions.

//

// This function must not be called if the command is not known to be implemented.

//

//  Return Type: BOOL

//      TRUE(1)         session is allowed with this command

//      FALSE(0)        session is not allowed with this command

)

{

}

//*** IsHandleInResponse()

// This function determines if a command has a handle in the response

{

}

//*** IsWriteOperation()

// Checks to see if an operation will write to an NV Index and is subject to being

// blocked by read-lock

)

{

#ifdef WRITE_LOCK

    return ((s_commandAttributes[commandIndex] & WRITE_LOCK) != 0);

#else

    {

        {

#  if CC_NV_Increment

            case TPM_CC_NV_Increment:

#  endif

#  if CC_NV_SetBits

            case TPM_CC_NV_SetBits:

#  endif

#  if CC_NV_Extend

            case TPM_CC_NV_Extend:

#  endif

#  if CC_AC_Send

            case TPM_CC_AC_Send:

#  endif

            // NV write lock counts as a write operation for authorization purposes.

            // We check to see if the NV is write locked before we do the

            // authorization. If it is locked, we fail the command early.

            case TPM_CC_NV_WriteLock:

            default:

                break;

        }

    }

    return FALSE;

#endif

}

//*** IsReadOperation()

// Checks to see if an operation will write to an NV Index and is

// subject to being blocked by write-lock.

)

{

#ifdef READ_LOCK

    return ((s_commandAttributes[commandIndex] & READ_LOCK) != 0);

#else

    {

        {

            case TPM_CC_PolicyNV:

            case TPM_CC_NV_Certify:

            // NV read lock counts as a read operation for authorization purposes.

            // We check to see if the NV is read locked before we do the

            // authorization. If it is locked, we fail the command early.

            case TPM_CC_NV_ReadLock:

            default:

                break;

        }

    }

    return FALSE;

#endif

}

//*** CommandCapGetCCList()

// This function returns a list of implemented commands and command attributes

// starting from the command in 'commandCode'.

//  Return Type: TPMI_YES_NO

//      YES         more command attributes are available

//      NO          no more command attributes are available

TPMI_YES_NO

                    UINT32 count,        // IN: maximum count for number of entries in

                                         //     'commandList'

                    TPML_CCA* commandList  // OUT: list of TPMA_CC

)

{

    // initialize output handle list count

    {

#if !COMPRESSED_LISTS

        // this check isn't needed for compressed lists.

#endif

                                                       TPMA_CC, commandIndex)))

        {

            // If the list is not full, add the attributes for this command.

                s_ccAttr[commandIndex];

        }

        else

        {

            // If the list is full but there are more commands to report,

            // indicate this and return.

            more = YES;

            break;

        }

    }

}

//*** CommandCapGetOneCC()

// This function checks whether a command is implemented, and returns its

// attributes if so.

                        TPMA_CC* commandAttributes  // OUT: command attributes

)

{

    {

    }

    return FALSE;

}

#if 0 /* libtpms added */

//*** IsVendorCommand()

// Function indicates if a command index references a vendor command.

//  Return Type: BOOL

//      TRUE(1)         command is a vendor command

//      FALSE(0)        command is not a vendor command

BOOL IsVendorCommand(COMMAND_INDEX commandIndex  // IN: command index to check

)

{

    return (IS_ATTRIBUTE(s_ccAttr[commandIndex], TPMA_CC, V));

}

#endif /* libtpms added */