// This file was extracted from the TCG Published
// Trusted Platform Module Library
// Part 4: Supporting Routines
// Family "2.0"
// Level 00 Revision 01.16
// October 30, 2014
#define MEMORY_LIB_C
#include "MemoryLib_fp.h"
//
// These buffers are set aside to hold command and response values. In this implementation, it is not
// guaranteed that the code will stop accessing the s_actionInputBuffer before starting to put values in the
// s_actionOutputBuffer so different buffers are required. However, the s_actionInputBuffer and
// s_responseBuffer are not needed at the same time and they could be the same buffer.
//
// Functions on BYTE Arrays
//
// MemoryMove()
//
// This function moves data from one place in memory to another. No safety checks of any type are
// performed. If source and data buffer overlap, then the move is done as if an intermediate buffer were
// used.
//
// NOTE: This function is used by MemoryCopy(), MemoryCopy2B(), and MemoryConcat2b() and requires that the caller
// know the maximum size of the destination buffer so that there is no possibility of buffer overrun.
//
LIB_EXPORT void
MemoryMove(
void *destination, // OUT: move destination
const void *source, // IN: move source
UINT32 size, // IN: number of octets to moved
UINT32 dSize // IN: size of the receive buffer
)
{
const BYTE *p = (BYTE *)source;
BYTE *q = (BYTE *)destination;
if(destination == NULL || source == NULL)
return;
pAssert(size <= dSize);
// if the destination buffer has a lower address than the
// source, then moving bytes in ascending order is safe.
dSize -= size;
if (p>q || (p+size <= q))
{
while(size--)
*q++ = *p++;
}
// If the destination buffer has a higher address than the
// source, then move bytes from the end to the beginning.
else if (p < q)
{
p += size;
q += size;
//
while (size--)
*--q = *--p;
}
// If the source and destination address are the same, nothing to move.
return;
}
//
// MemoryEqual()
//
// This function indicates if two buffers have the same values in the indicated number of bytes.
//
// Return Value Meaning
//
// TRUE all octets are the same
// FALSE all octets are not the same
//
LIB_EXPORT BOOL
MemoryEqual(
const void *buffer1, // IN: compare buffer1
const void *buffer2, // IN: compare buffer2
UINT32 size // IN: size of bytes being compared
)
{
BOOL diff = FALSE;
const BYTE *b1, *b2;
b1 = (BYTE *)buffer1;
b2 = (BYTE *)buffer2;
// Compare all bytes so that there is no leakage of information
// due to timing differences.
for(; size > 0; size--)
diff |= *b1++ ^ *b2++;
return !diff;
}
//
//
// MemoryCopy2B()
//
// This function copies a TPM2B. This can be used when the TPM2B types are the same or different. No
// size checking is done on the destination so the caller should make sure that the destination is large
// enough.
//
// This function returns the number of octets in the data buffer of the TPM2B.
//
LIB_EXPORT INT16
MemoryCopy2B(
TPM2B *dest, // OUT: receiving TPM2B
const TPM2B *source, // IN: source TPM2B
UINT16 dSize // IN: size of the receiving buffer
)
{
if(dest == NULL)
return 0;
if(source == NULL)
dest->size = 0;
else
{
dest->size = source->size;
MemoryMove(dest->buffer, source->buffer, dest->size, dSize);
}
return dest->size;
}
//
//
// MemoryConcat2B()
//
// This function will concatenate the buffer contents of a TPM2B to an the buffer contents of another TPM2B
// and adjust the size accordingly (a := (a | b)).
//
LIB_EXPORT void
MemoryConcat2B(
TPM2B *aInOut, // IN/OUT: destination 2B
TPM2B *bIn, // IN: second 2B
UINT16 aSize // IN: The size of aInOut.buffer (max values for
// aInOut.size)
)
{
MemoryMove(&aInOut->buffer[aInOut->size],
bIn->buffer,
bIn->size,
aSize - aInOut->size);
aInOut->size = aInOut->size + bIn->size;
return;
}
//
//
// Memory2BEqual()
//
// This function will compare two TPM2B structures. To be equal, they need to be the same size and the
// buffer contexts need to be the same in all octets.
//
// Return Value Meaning
//
// TRUE size and buffer contents are the same
// FALSE size or buffer contents are not the same
//
LIB_EXPORT BOOL
Memory2BEqual(
const TPM2B *aIn, // IN: compare value
const TPM2B *bIn // IN: compare value
)
{
if(aIn->size != bIn->size)
return FALSE;
return MemoryEqual(aIn->buffer, bIn->buffer, aIn->size);
}
//
//
// MemorySet()
//
// This function will set all the octets in the specified memory range to the specified octet value.
//
// NOTE: the dSize parameter forces the caller to know how big the receiving buffer is to make sure that there is no
// possibility that the caller will inadvertently run over the end of the buffer.
//
LIB_EXPORT void
MemorySet(
void *destination, // OUT: memory destination
char value, // IN: fill value
UINT32 size // IN: number of octets to fill
)
{
char *p = (char *)destination;
while (size--)
*p++ = value;
return;
}
#ifndef EMBEDDED_MODE
//
//
// MemoryGetActionInputBuffer()
//
// This function returns the address of the buffer into which the command parameters will be unmarshaled in
// preparation for calling the command actions.
//
BYTE *
MemoryGetActionInputBuffer(
UINT32 size // Size, in bytes, required for the input
// unmarshaling
)
{
BYTE *buf = NULL;
if(size > 0)
{
// In this implementation, a static buffer is set aside for action output.
// Other implementations may apply additional optimization based on command
// code or other factors.
UINT32 *p = s_actionInputBuffer;
buf = (BYTE *)p;
pAssert(size < sizeof(s_actionInputBuffer));
// size of an element in the buffer
#define SZ sizeof(s_actionInputBuffer[0])
for(size = (size + SZ - 1) / SZ; size > 0; size--)
*p++ = 0;
#undef SZ
}
return buf;
}
//
//
// MemoryGetActionOutputBuffer()
//
// This function returns the address of the buffer into which the command action code places its output
// values.
//
void *
MemoryGetActionOutputBuffer(
TPM_CC command // Command that requires the buffer
)
{
// In this implementation, a static buffer is set aside for action output.
// Other implementations may apply additional optimization based on the command
// code or other factors.
command = 0; // Unreferenced parameter
return s_actionOutputBuffer;
}
#endif // EMBEDDED_MODE ^^^^^ not defined.
//
//
// MemoryGetResponseBuffer()
//
// This function returns the address into which the command response is marshaled from values in the
// action output buffer.
//
BYTE*
MemoryGetResponseBuffer(
TPM_CC command // Command that requires the buffer
)
{
// In this implementation, a static buffer is set aside for responses.
// Other implementation may apply additional optimization based on the command
// code or other factors.
command = 0; // Unreferenced parameter
return s_responseBuffer;
}
//
//
// MemoryRemoveTrailingZeros()
//
// This function is used to adjust the length of an authorization value. It adjusts the size of the TPM2B so
// that it does not include octets at the end of the buffer that contain zero. The function returns the number
// of non-zero octets in the buffer.
//
UINT16
MemoryRemoveTrailingZeros (
TPM2B_AUTH *auth // IN/OUT: value to adjust
)
{
BYTE *a = &auth->t.buffer[auth->t.size-1];
for(; auth->t.size > 0; auth->t.size--)
{
if(*a--)
break;
}
return auth->t.size;
}