#2071

Committed 11 Feb 2026 11:05PM UTC coverage: 77.191% (+0.002%) from 77.189%

Build # #2071

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

Merge fd5beda47 into c12e737cc

Run Details

1174 of 1370 new or added lines in 95 files covered. (85.69%)

2187 existing lines in 88 files now uncovered.

36361 of 47105 relevant lines covered (77.19%)

125833.51 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

60.99

/src/tpm2/BackwardsCompatibilityObject.c

// SPDX-License-Identifier: BSD-2-Clause

// (c) Copyright IBM Corporation 2017,2018.

#include <assert.h>

#include "BackwardsCompatibilityObject.h"

/* The following are data structure from libtpms 0.7.x with RSA 2048 support
 * that help to resume key and hash contexts (TPM2_ContextSave/Load) from this
 * earlier version. All structures that have different sizes in 0.8 are found
 * here.
 */
typedef union {
    struct {
        UINT16                  size;
        BYTE                    buffer[2048/8];
    }            t;
    TPM2B        b;
} RSA2048_TPM2B_PUBLIC_KEY_RSA;

typedef union {
    TPM2B_DIGEST                 keyedHash;
    TPM2B_DIGEST                 sym;
    RSA2048_TPM2B_PUBLIC_KEY_RSA rsa;
    TPMS_ECC_POINT               ecc;
//    TPMS_DERIVE                derive;
} RSA2048_TPMU_PUBLIC_ID;

typedef struct {
    TPMI_ALG_PUBLIC         type;
    TPMI_ALG_HASH           nameAlg;
    TPMA_OBJECT             objectAttributes;
    TPM2B_DIGEST            authPolicy;
    TPMU_PUBLIC_PARMS       parameters;
    RSA2048_TPMU_PUBLIC_ID  unique;
} RSA2048_TPMT_PUBLIC;

MUST_BE(sizeof(RSA2048_TPMT_PUBLIC) == 356);

typedef union {
    struct {
        UINT16                  size;
        BYTE                    buffer[((2048/8)/2)*5];
    }            t;
    TPM2B        b;
} RSA2048_TPM2B_PRIVATE_KEY_RSA;

MUST_BE(sizeof(RSA2048_TPM2B_PRIVATE_KEY_RSA) == 642);

typedef union {
    struct {
        UINT16                  size;
        BYTE                    buffer[((2048/8)/2)*5];
    }            t;
    TPM2B        b;
} RSA2048_TPM2B_PRIVATE_VENDOR_SPECIFIC;

typedef union {
    RSA2048_TPM2B_PRIVATE_KEY_RSA         rsa;
    TPM2B_ECC_PARAMETER                   ecc;
    TPM2B_SENSITIVE_DATA                  bits;
    TPM2B_SYM_KEY                         sym;
    RSA2048_TPM2B_PRIVATE_VENDOR_SPECIFIC any;
} RSA2048_TPMU_SENSITIVE_COMPOSITE;

typedef struct {
    TPMI_ALG_PUBLIC                  sensitiveType;
    TPM2B_AUTH                       authValue;
    TPM2B_DIGEST                     seedValue;
    RSA2048_TPMU_SENSITIVE_COMPOSITE sensitive;
} RSA2048_TPMT_SENSITIVE;

MUST_BE(sizeof(RSA2048_TPMT_SENSITIVE) == 776);

BN_TYPE(old_prime, (2048 / 2));

typedef struct RSA2048_privateExponent
{
    bn_old_prime_t          Q;
    bn_old_prime_t          dP;
    bn_old_prime_t          dQ;
    bn_old_prime_t          qInv;
} RSA2048_privateExponent_t;

static inline void CopyFromOldPrimeT(ci_prime_t *dst,
                                     const bn_old_prime_t *src)
{
    dst->allocated = src->allocated;
    dst->size = src->size;
    memcpy(dst->d, src->d, sizeof(src->d));
}

MUST_BE(sizeof(RSA2048_privateExponent_t) == 608);

typedef struct RSA2048_OBJECT
{
    // The attributes field is required to be first followed by the publicArea.
    // This allows the overlay of the object structure and a sequence structure
    OBJECT_ATTRIBUTES   attributes;         // object attributes
    RSA2048_TPMT_PUBLIC     publicArea;         // public area of an object
    RSA2048_TPMT_SENSITIVE  sensitive;          // sensitive area of an object
    RSA2048_privateExponent_t privateExponent;  // Additional field for the private
    TPM2B_NAME          qualifiedName;      // object qualified name
    TPMI_DH_OBJECT      evictHandle;        // if the object is an evict object,
    // the original handle is kept here.
    // The 'working' handle will be the
    // handle of an object slot.
    TPM2B_NAME          name;               // Name of the object name. Kept here
    // to avoid repeatedly computing it.

    // libtpms added: OBJECT lies in NVRAM; to avoid that it needs different number
    // of bytes on 32 bit and 64 bit architectures, we need to make sure it's the
    // same size; simple padding at the end works here
    UINT32             _pad;
} RSA2048_OBJECT;

MUST_BE(sizeof(RSA2048_OBJECT) == 1896);

TPMI_RH_HIERARCHY ObjectGetHierarchyFromAttributes(OBJECT* object)
{
    if(object->attributes.spsHierarchy)
        return TPM_RH_OWNER;

    if(object->attributes.epsHierarchy)
        return TPM_RH_ENDORSEMENT;

    if(object->attributes.ppsHierarchy)
        return TPM_RH_PLATFORM;

    return TPM_RH_NULL;
}

static void RSA2048_OBJECT_To_OBJECT(OBJECT* dest, const RSA2048_OBJECT* src)
{
    dest->attributes = src->attributes;
    dest->hierarchy = ObjectGetHierarchyFromAttributes(dest);

    dest->publicArea.type = src->publicArea.type;
    dest->publicArea.nameAlg = src->publicArea.nameAlg;
    dest->publicArea.objectAttributes = src->publicArea.objectAttributes;
    dest->publicArea.authPolicy = src->publicArea.authPolicy;
    dest->publicArea.parameters = src->publicArea.parameters;
    /* the unique part can be one or two TPM2B's */
    switch (dest->publicArea.type) {
    case TPM_ALG_KEYEDHASH:
        MemoryCopy2B(&dest->publicArea.unique.keyedHash.b,
                     &src->publicArea.unique.keyedHash.b,
                     sizeof(src->publicArea.unique.keyedHash.t.buffer));
        memset(&dest->privateExponent, 0, sizeof(dest->privateExponent));
        break;
    case TPM_ALG_SYMCIPHER:
        MemoryCopy2B(&dest->publicArea.unique.sym.b,
                     &src->publicArea.unique.sym.b,
                     sizeof(src->publicArea.unique.sym.t.buffer));
        memset(&dest->privateExponent, 0, sizeof(dest->privateExponent));
        break;
    case TPM_ALG_RSA:
        MemoryCopy2B(&dest->publicArea.unique.rsa.b,
                     &src->publicArea.unique.rsa.b,
                     sizeof(src->publicArea.unique.rsa.t.buffer));

        CopyFromOldPrimeT(&dest->privateExponent.Q, &src->privateExponent.Q);
        CopyFromOldPrimeT(&dest->privateExponent.dP, &src->privateExponent.dP);
        CopyFromOldPrimeT(&dest->privateExponent.dQ, &src->privateExponent.dQ);
        CopyFromOldPrimeT(&dest->privateExponent.qInv, &src->privateExponent.qInv);
        break;
    case TPM_ALG_ECC:
        MemoryCopy2B(&dest->publicArea.unique.ecc.x.b,
                     &src->publicArea.unique.ecc.x.b,
                     sizeof(src->publicArea.unique.ecc.x.t.buffer));
        MemoryCopy2B(&dest->publicArea.unique.ecc.y.b,
                     &src->publicArea.unique.ecc.y.b,
                     sizeof(src->publicArea.unique.ecc.y.t.buffer));
        memset(&dest->privateExponent, 0, sizeof(dest->privateExponent));
        break;
    }

    dest->sensitive.sensitiveType = src->sensitive.sensitiveType;
    dest->sensitive.authValue = src->sensitive.authValue;
    dest->sensitive.seedValue = src->sensitive.seedValue;
    /* The RSA2048_TPMU_SENSITIVE_COMPOSITE is always a TPM2B */
    MemoryCopy2B(&dest->sensitive.sensitive.any.b,
                 &src->sensitive.sensitive.any.b,
                 sizeof(src->sensitive.sensitive.any.t.buffer));

    dest->qualifiedName = src->qualifiedName;
    dest->evictHandle = src->evictHandle;
    dest->name = src->name;
}

// Convert an RSA2048_OBJECT that was copied into buffer using MemoryCopy
TPM_RC
RSA2048_OBJECT_Buffer_To_OBJECT(OBJECT* newObject, BYTE* buffer, INT32 size)
{
    RSA2048_OBJECT    oldObject;
    TPM_RC        rc = 0;

    // get the attributes
    MemoryCopy(newObject, buffer, sizeof(newObject->attributes));
    if (ObjectIsSequence(newObject))
        {
            /* resuming old hash contexts is not supported */
            rc = TPM_RC_DISABLED;
        }
    else
        {
            if (size != sizeof(RSA2048_OBJECT))
                return TPM_RC_SIZE;
            MemoryCopy(&oldObject, buffer, sizeof(RSA2048_OBJECT));

            /* fill the newObject with the contents of the oldObject */
            RSA2048_OBJECT_To_OBJECT(newObject, &oldObject);
    }

    return rc;
}

/* The following are data structure from libtpms 0.9.x with RSA 3072 support.
 */
typedef union {
    struct {
        UINT16                  size;
        BYTE                    buffer[3072/8];
    }            t;
    TPM2B        b;
} RSA3072_TPM2B_PUBLIC_KEY_RSA;

typedef union {
    TPM2B_DIGEST                 keyedHash;
    TPM2B_DIGEST                 sym;
    RSA3072_TPM2B_PUBLIC_KEY_RSA rsa;
    TPMS_ECC_POINT               ecc;
    TPMS_DERIVE                  derive;
} RSA3072_TPMU_PUBLIC_ID;
MUST_BE(sizeof(TPM2B_DIGEST) == 2 + BITS_TO_BYTES(512));
MUST_BE(sizeof(TPMS_ECC_POINT) == 2 * (2 + BITS_TO_BYTES(638)));
MUST_BE(sizeof(TPMS_DERIVE) == 2 * (2 + 32));

typedef struct {
    TPMI_ALG_PUBLIC         type;
    TPMI_ALG_HASH           nameAlg;
    TPMA_OBJECT             objectAttributes;
    TPM2B_DIGEST            authPolicy;
    TPMU_PUBLIC_PARMS       parameters;
    RSA3072_TPMU_PUBLIC_ID          unique;
} RSA3072_TPMT_PUBLIC;
MUST_BE(sizeof(RSA3072_TPMT_PUBLIC) == 484);

typedef union {
    struct {
        UINT16                  size;
        BYTE                    buffer[((3072 / 8) / 2) * 5];
    }            t;
    TPM2B        b;
} RSA3072_TPM2B_PRIVATE_KEY_RSA;
MUST_BE(sizeof(RSA3072_TPM2B_PRIVATE_KEY_RSA) == 962);

typedef union {
    struct {
        UINT16                  size;
        BYTE                    buffer[((3072 / 8) / 2) * 5];
    }            t;
    TPM2B        b;
} RSA3072_TPM2B_PRIVATE_VENDOR_SPECIFIC;

typedef union {
    RSA3072_TPM2B_PRIVATE_KEY_RSA         rsa;
    TPM2B_ECC_PARAMETER                   ecc;
    TPM2B_SENSITIVE_DATA                  bits;
    TPM2B_SYM_KEY                         sym;
    RSA3072_TPM2B_PRIVATE_VENDOR_SPECIFIC any;
} RSA3072_TPMU_SENSITIVE_COMPOSITE;
MUST_BE(sizeof(TPM2B_ECC_PARAMETER) == 2 + BITS_TO_BYTES(638) /* BN P638 */);
MUST_BE(sizeof(TPM2B_SENSITIVE_DATA) == 2 + 128);
MUST_BE(sizeof(TPM2B_SYM_KEY) == 2 + BITS_TO_BYTES(256));

typedef struct {
    TPMI_ALG_PUBLIC             sensitiveType;
    TPM2B_AUTH                  authValue;
    TPM2B_DIGEST                seedValue;
    RSA3072_TPMU_SENSITIVE_COMPOSITE    sensitive;
} RSA3072_TPMT_SENSITIVE;
MUST_BE(sizeof(TPM2B_AUTH) == 2 + BITS_TO_BYTES(512));
MUST_BE(sizeof(TPM2B_DIGEST) == 2 + BITS_TO_BYTES(512));
MUST_BE(sizeof(RSA3072_TPMT_SENSITIVE) == 1096);

BN_TYPE(rsa3072_prime, (3072 / 2));

typedef struct RSA3072_privateExponent
{
    bn_rsa3072_prime_t          Q;
    bn_rsa3072_prime_t          dP;
    bn_rsa3072_prime_t          dQ;
    bn_rsa3072_prime_t          qInv;
} RSA3072_privateExponent_t;
MUST_BE(sizeof(RSA3072_privateExponent_t) == 864);

typedef struct RSA3072_OBJECT
{
    // The attributes field is required to be first followed by the publicArea.
    // This allows the overlay of the object structure and a sequence structure
    OBJECT_ATTRIBUTES     attributes;     // object attributes
    RSA3072_TPMT_PUBLIC     publicArea;     // public area of an object
    RSA3072_TPMT_SENSITIVE  sensitive;      // sensitive area of an object
#if 1                                        // libtpms added begin: keep
    RSA3072_privateExponent_t privateExponent;    // Additional field for the private
#endif                                        // libtpms added end
    TPM2B_NAME        qualifiedName;  // object qualified name
    TPMI_DH_OBJECT    evictHandle;    // if the object is an evict object,
    // the original handle is kept here.
    // The 'working' handle will be the
    // handle of an object slot.
    TPM2B_NAME name;                  // Name of the object name. Kept here
    // to avoid repeatedly computing it.

    // libtpms added: SEED_COMPAT_LEVEL to use for deriving child keys
    SEED_COMPAT_LEVEL   seedCompatLevel;
    // libtpms added: OBJECT lies in NVRAM; to avoid that it needs different number
    // of bytes on 32 bit and 64 bit architectures, we need to make sure it's the
    // same size; simple padding at the end works here
    UINT8               _pad[3];
} RSA3072_OBJECT;
MUST_BE(sizeof(RSA3072_OBJECT) == 2600);

static inline void CopyFromRSA3072PrimeT(ci_prime_t* dst,
                                       const bn_rsa3072_prime_t* src)
{
    dst->allocated = src->allocated;
    dst->size = src->size;
    memcpy(dst->d, src->d, sizeof(src->d));
}

static inline void CopyToRSA3072PrimeT(bn_rsa3072_prime_t* dst,
                                       const ci_prime_t* src)
{
    dst->allocated = src->allocated;
    dst->size = src->size;
    memcpy(dst->d, src->d, sizeof(dst->d));
}

static void RSA3072_OBJECT_To_OBJECT(OBJECT* dest, const RSA3072_OBJECT* src)
{
    dest->attributes = src->attributes;
    dest->hierarchy = ObjectGetHierarchyFromAttributes(dest);

    dest->publicArea.type = src->publicArea.type;
    dest->publicArea.nameAlg = src->publicArea.nameAlg;
    dest->publicArea.objectAttributes = src->publicArea.objectAttributes;
    dest->publicArea.authPolicy = src->publicArea.authPolicy;
    dest->publicArea.parameters = src->publicArea.parameters;
    /* the unique part can be one or two TPM2B's */
    switch (dest->publicArea.type) {
    case TPM_ALG_KEYEDHASH:
        MemoryCopy2B(&dest->publicArea.unique.keyedHash.b,
                     &src->publicArea.unique.keyedHash.b,
                     sizeof(src->publicArea.unique.keyedHash.t.buffer));
        memset(&dest->privateExponent, 0, sizeof(dest->privateExponent));
        break;
    case TPM_ALG_SYMCIPHER:
        MemoryCopy2B(&dest->publicArea.unique.sym.b,
                     &src->publicArea.unique.sym.b,
                     sizeof(src->publicArea.unique.sym.t.buffer));
        memset(&dest->privateExponent, 0, sizeof(dest->privateExponent));
        break;
    case TPM_ALG_RSA:
        MemoryCopy2B(&dest->publicArea.unique.rsa.b,
                     &src->publicArea.unique.rsa.b,
                     sizeof(src->publicArea.unique.rsa.t.buffer));

        CopyFromRSA3072PrimeT(&dest->privateExponent.Q, &src->privateExponent.Q);
        CopyFromRSA3072PrimeT(&dest->privateExponent.dP, &src->privateExponent.dP);
        CopyFromRSA3072PrimeT(&dest->privateExponent.dQ, &src->privateExponent.dQ);
        CopyFromRSA3072PrimeT(&dest->privateExponent.qInv, &src->privateExponent.qInv);
        break;
    case TPM_ALG_ECC:
        MemoryCopy2B(&dest->publicArea.unique.ecc.x.b,
                     &src->publicArea.unique.ecc.x.b,
                     sizeof(src->publicArea.unique.ecc.x.t.buffer));
        MemoryCopy2B(&dest->publicArea.unique.ecc.y.b,
                     &src->publicArea.unique.ecc.y.b,
                     sizeof(src->publicArea.unique.ecc.y.t.buffer));
        memset(&dest->privateExponent, 0, sizeof(dest->privateExponent));
        break;
    }

    dest->sensitive.sensitiveType = src->sensitive.sensitiveType;
    dest->sensitive.authValue = src->sensitive.authValue;
    dest->sensitive.seedValue = src->sensitive.seedValue;
    /* The OLD_TPMU_SENSITIVE_COMPOSITE is always a TPM2B */
    MemoryCopy2B(&dest->sensitive.sensitive.any.b,
                 &src->sensitive.sensitive.any.b,
                 sizeof(src->sensitive.sensitive.any.t.buffer));

    dest->qualifiedName = src->qualifiedName;
    dest->evictHandle = src->evictHandle;
    dest->name = src->name;
    dest->seedCompatLevel = src->seedCompatLevel;
}

/* Convert an OBJECT to the (smaller) RSA3072_OBJECT. */
static void OBJECT_To_RSA3072_OBJECT(RSA3072_OBJECT* dest, const OBJECT* src)
{
    dest->attributes = src->attributes;

    dest->publicArea.type = src->publicArea.type;
    dest->publicArea.nameAlg = src->publicArea.nameAlg;
    dest->publicArea.objectAttributes = src->publicArea.objectAttributes;
    dest->publicArea.authPolicy = src->publicArea.authPolicy;
    dest->publicArea.parameters = src->publicArea.parameters;
    /* the unique part can be one or two TPM2B's */
    switch (dest->publicArea.type) {
    case TPM_ALG_KEYEDHASH:
        MemoryCopy2B(&dest->publicArea.unique.keyedHash.b,
                     &src->publicArea.unique.keyedHash.b,
                     sizeof(dest->publicArea.unique.keyedHash.t.buffer));
        break;
    case TPM_ALG_SYMCIPHER:
        MemoryCopy2B(&dest->publicArea.unique.sym.b,
                     &src->publicArea.unique.sym.b,
                     sizeof(dest->publicArea.unique.sym.t.buffer));
        break;
    case TPM_ALG_RSA:
        MemoryCopy2B(&dest->publicArea.unique.rsa.b,
                     &src->publicArea.unique.rsa.b,
                     sizeof(dest->publicArea.unique.rsa.t.buffer));

        CopyToRSA3072PrimeT(&dest->privateExponent.Q, &src->privateExponent.Q);
        CopyToRSA3072PrimeT(&dest->privateExponent.dP, &src->privateExponent.dP);
        CopyToRSA3072PrimeT(&dest->privateExponent.dQ, &src->privateExponent.dQ);
        CopyToRSA3072PrimeT(&dest->privateExponent.qInv, &src->privateExponent.qInv);
        break;
    case TPM_ALG_ECC:
        MemoryCopy2B(&dest->publicArea.unique.ecc.x.b,
                     &src->publicArea.unique.ecc.x.b,
                     sizeof(dest->publicArea.unique.ecc.x.t.buffer));
        MemoryCopy2B(&dest->publicArea.unique.ecc.y.b,
                     &src->publicArea.unique.ecc.y.b,
                     sizeof(dest->publicArea.unique.ecc.y.t.buffer));
        break;
    }

    dest->sensitive.sensitiveType = src->sensitive.sensitiveType;
    dest->sensitive.authValue = src->sensitive.authValue;
    dest->sensitive.seedValue = src->sensitive.seedValue;
    /* The OLD_TPMU_SENSITIVE_COMPOSITE is always a TPM2B */
    MemoryCopy2B(&dest->sensitive.sensitive.any.b,
                 &src->sensitive.sensitive.any.b,
                 sizeof(dest->sensitive.sensitive.any.t.buffer));

    dest->qualifiedName = src->qualifiedName;
    dest->evictHandle = src->evictHandle;
    dest->name = src->name;
    dest->seedCompatLevel = src->seedCompatLevel;
    MemorySet(dest->_pad, 0, sizeof(dest->_pad));
}

TPM_RC
RSA3072_OBJECT_Buffer_To_OBJECT(OBJECT *object, BYTE *buffer, INT32 size)
{
    RSA3072_OBJECT rsa3072_object;

    if (size != sizeof(RSA3072_OBJECT))
        return TPM_RC_SIZE;

    MemoryCopy(&rsa3072_object, buffer, size);

    RSA3072_OBJECT_To_OBJECT(object, &rsa3072_object);

    return 0;
}

UINT32 OBJECT_To_Buffer_As_RSA3072_OBJECT(OBJECT* object, BYTE* buffer, UINT32 size)
{
    RSA3072_OBJECT rsa3072_object;
    UINT32         written = sizeof(rsa3072_object);

    OBJECT_To_RSA3072_OBJECT(&rsa3072_object, object);

    pAssert(size >= sizeof(rsa3072_object));
    MemoryCopy(buffer, &rsa3072_object, sizeof(rsa3072_object));

    return written;
}

1	// SPDX-License-Identifier: BSD-2-Clause
2
3	// (c) Copyright IBM Corporation 2017,2018.
4
5	#include <assert.h>
6
7	#include "BackwardsCompatibilityObject.h"
8
9	/* The following are data structure from libtpms 0.7.x with RSA 2048 support
10	* that help to resume key and hash contexts (TPM2_ContextSave/Load) from this
11	* earlier version. All structures that have different sizes in 0.8 are found
12	* here.
13	*/
14	typedef union {
15	struct {
16	UINT16 size;
17	BYTE buffer[2048/8];
18	} t;
19	TPM2B b;
20	} RSA2048_TPM2B_PUBLIC_KEY_RSA;
21
22	typedef union {
23	TPM2B_DIGEST keyedHash;
24	TPM2B_DIGEST sym;
25	RSA2048_TPM2B_PUBLIC_KEY_RSA rsa;
26	TPMS_ECC_POINT ecc;
27	// TPMS_DERIVE derive;
28	} RSA2048_TPMU_PUBLIC_ID;
29
30	typedef struct {
31	TPMI_ALG_PUBLIC type;
32	TPMI_ALG_HASH nameAlg;
33	TPMA_OBJECT objectAttributes;
34	TPM2B_DIGEST authPolicy;
35	TPMU_PUBLIC_PARMS parameters;
36	RSA2048_TPMU_PUBLIC_ID unique;
37	} RSA2048_TPMT_PUBLIC;
38
39	MUST_BE(sizeof(RSA2048_TPMT_PUBLIC) == 356);
40
41	typedef union {
42	struct {
43	UINT16 size;
44	BYTE buffer[((2048/8)/2)*5];
45	} t;
46	TPM2B b;
47	} RSA2048_TPM2B_PRIVATE_KEY_RSA;
48
49	MUST_BE(sizeof(RSA2048_TPM2B_PRIVATE_KEY_RSA) == 642);
50
51	typedef union {
52	struct {
53	UINT16 size;
54	BYTE buffer[((2048/8)/2)*5];
55	} t;
56	TPM2B b;
57	} RSA2048_TPM2B_PRIVATE_VENDOR_SPECIFIC;
58
59	typedef union {
60	RSA2048_TPM2B_PRIVATE_KEY_RSA rsa;
61	TPM2B_ECC_PARAMETER ecc;
62	TPM2B_SENSITIVE_DATA bits;
63	TPM2B_SYM_KEY sym;
64	RSA2048_TPM2B_PRIVATE_VENDOR_SPECIFIC any;
65	} RSA2048_TPMU_SENSITIVE_COMPOSITE;
66
67	typedef struct {
68	TPMI_ALG_PUBLIC sensitiveType;
69	TPM2B_AUTH authValue;
70	TPM2B_DIGEST seedValue;
71	RSA2048_TPMU_SENSITIVE_COMPOSITE sensitive;
72	} RSA2048_TPMT_SENSITIVE;
73
74	MUST_BE(sizeof(RSA2048_TPMT_SENSITIVE) == 776);
75
76	BN_TYPE(old_prime, (2048 / 2));
77
78	typedef struct RSA2048_privateExponent
79	{
80	bn_old_prime_t Q;
81	bn_old_prime_t dP;
82	bn_old_prime_t dQ;
83	bn_old_prime_t qInv;
84	} RSA2048_privateExponent_t;
85
86	static inline void CopyFromOldPrimeT(ci_prime_t *dst,
87	const bn_old_prime_t *src)
88	{
UNCOV 89	dst->allocated = src->allocated;	×
UNCOV 90	dst->size = src->size;	×
UNCOV 91	memcpy(dst->d, src->d, sizeof(src->d));	×
92	}
93
94	MUST_BE(sizeof(RSA2048_privateExponent_t) == 608);
95
96	typedef struct RSA2048_OBJECT
97	{
98	// The attributes field is required to be first followed by the publicArea.
99	// This allows the overlay of the object structure and a sequence structure
100	OBJECT_ATTRIBUTES attributes; // object attributes
101	RSA2048_TPMT_PUBLIC publicArea; // public area of an object
102	RSA2048_TPMT_SENSITIVE sensitive; // sensitive area of an object
103	RSA2048_privateExponent_t privateExponent; // Additional field for the private
104	TPM2B_NAME qualifiedName; // object qualified name
105	TPMI_DH_OBJECT evictHandle; // if the object is an evict object,
106	// the original handle is kept here.
107	// The 'working' handle will be the
108	// handle of an object slot.
109	TPM2B_NAME name; // Name of the object name. Kept here
110	// to avoid repeatedly computing it.
111
112	// libtpms added: OBJECT lies in NVRAM; to avoid that it needs different number
113	// of bytes on 32 bit and 64 bit architectures, we need to make sure it's the
114	// same size; simple padding at the end works here
115	UINT32 _pad;
116	} RSA2048_OBJECT;
117
118	MUST_BE(sizeof(RSA2048_OBJECT) == 1896);
119
120	TPMI_RH_HIERARCHY ObjectGetHierarchyFromAttributes(OBJECT* object)	68,948✔
121	{
122	if(object->attributes.spsHierarchy)	68,948✔
123	return TPM_RH_OWNER;
124
125	if(object->attributes.epsHierarchy)	1,332✔
126	return TPM_RH_ENDORSEMENT;
127
128	if(object->attributes.ppsHierarchy)	110✔
129	return TPM_RH_PLATFORM;	22✔
130
131	return TPM_RH_NULL;
132	}
133
134	static void RSA2048_OBJECT_To_OBJECT(OBJECT* dest, const RSA2048_OBJECT* src)
135	{
UNCOV 136	dest->attributes = src->attributes;	×
UNCOV 137	dest->hierarchy = ObjectGetHierarchyFromAttributes(dest);	×
138
UNCOV 139	dest->publicArea.type = src->publicArea.type;	×
UNCOV 140	dest->publicArea.nameAlg = src->publicArea.nameAlg;	×
141	dest->publicArea.objectAttributes = src->publicArea.objectAttributes;	×
UNCOV 142	dest->publicArea.authPolicy = src->publicArea.authPolicy;	×
UNCOV 143	dest->publicArea.parameters = src->publicArea.parameters;	×
144	/* the unique part can be one or two TPM2B's */
145	switch (dest->publicArea.type) {	×
146	case TPM_ALG_KEYEDHASH:	×
147	MemoryCopy2B(&dest->publicArea.unique.keyedHash.b,	×
148	&src->publicArea.unique.keyedHash.b,
149	sizeof(src->publicArea.unique.keyedHash.t.buffer));
UNCOV 150	memset(&dest->privateExponent, 0, sizeof(dest->privateExponent));	×
151	break;
UNCOV 152	case TPM_ALG_SYMCIPHER:	×
153	MemoryCopy2B(&dest->publicArea.unique.sym.b,	×
154	&src->publicArea.unique.sym.b,
155	sizeof(src->publicArea.unique.sym.t.buffer));
UNCOV 156	memset(&dest->privateExponent, 0, sizeof(dest->privateExponent));	×
157	break;
UNCOV 158	case TPM_ALG_RSA:	×
UNCOV 159	MemoryCopy2B(&dest->publicArea.unique.rsa.b,	×
160	&src->publicArea.unique.rsa.b,
161	sizeof(src->publicArea.unique.rsa.t.buffer));
162
163	CopyFromOldPrimeT(&dest->privateExponent.Q, &src->privateExponent.Q);	×
UNCOV 164	CopyFromOldPrimeT(&dest->privateExponent.dP, &src->privateExponent.dP);	×
UNCOV 165	CopyFromOldPrimeT(&dest->privateExponent.dQ, &src->privateExponent.dQ);	×
166	CopyFromOldPrimeT(&dest->privateExponent.qInv, &src->privateExponent.qInv);	×
167	break;	×
UNCOV 168	case TPM_ALG_ECC:	×
UNCOV 169	MemoryCopy2B(&dest->publicArea.unique.ecc.x.b,	×
170	&src->publicArea.unique.ecc.x.b,
171	sizeof(src->publicArea.unique.ecc.x.t.buffer));
UNCOV 172	MemoryCopy2B(&dest->publicArea.unique.ecc.y.b,	×
173	&src->publicArea.unique.ecc.y.b,
174	sizeof(src->publicArea.unique.ecc.y.t.buffer));
UNCOV 175	memset(&dest->privateExponent, 0, sizeof(dest->privateExponent));	×
176	break;
177	}
178
179	dest->sensitive.sensitiveType = src->sensitive.sensitiveType;	×
UNCOV 180	dest->sensitive.authValue = src->sensitive.authValue;	×
UNCOV 181	dest->sensitive.seedValue = src->sensitive.seedValue;	×
182	/* The RSA2048_TPMU_SENSITIVE_COMPOSITE is always a TPM2B */
UNCOV 183	MemoryCopy2B(&dest->sensitive.sensitive.any.b,	×
184	&src->sensitive.sensitive.any.b,
185	sizeof(src->sensitive.sensitive.any.t.buffer));
186
UNCOV 187	dest->qualifiedName = src->qualifiedName;	×
UNCOV 188	dest->evictHandle = src->evictHandle;	×
UNCOV 189	dest->name = src->name;	×
190	}
191
192	// Convert an RSA2048_OBJECT that was copied into buffer using MemoryCopy
193	TPM_RC
UNCOV 194	RSA2048_OBJECT_Buffer_To_OBJECT(OBJECT* newObject, BYTE* buffer, INT32 size)	×
195	{
UNCOV 196	RSA2048_OBJECT oldObject;	×
UNCOV 197	TPM_RC rc = 0;	×
198
199	// get the attributes
UNCOV 200	MemoryCopy(newObject, buffer, sizeof(newObject->attributes));	×
UNCOV 201	if (ObjectIsSequence(newObject))	×
202	{
203	/* resuming old hash contexts is not supported */
204	rc = TPM_RC_DISABLED;
205	}
206	else
207	{
UNCOV 208	if (size != sizeof(RSA2048_OBJECT))	×
209	return TPM_RC_SIZE;
UNCOV 210	MemoryCopy(&oldObject, buffer, sizeof(RSA2048_OBJECT));	×
211
212	/* fill the newObject with the contents of the oldObject */
UNCOV 213	RSA2048_OBJECT_To_OBJECT(newObject, &oldObject);	×
214	}
215
216	return rc;
217	}
218
219	/* The following are data structure from libtpms 0.9.x with RSA 3072 support.
220	*/
221	typedef union {
222	struct {
223	UINT16 size;
224	BYTE buffer[3072/8];
225	} t;
226	TPM2B b;
227	} RSA3072_TPM2B_PUBLIC_KEY_RSA;
228
229	typedef union {
230	TPM2B_DIGEST keyedHash;
231	TPM2B_DIGEST sym;
232	RSA3072_TPM2B_PUBLIC_KEY_RSA rsa;
233	TPMS_ECC_POINT ecc;
234	TPMS_DERIVE derive;
235	} RSA3072_TPMU_PUBLIC_ID;
236	MUST_BE(sizeof(TPM2B_DIGEST) == 2 + BITS_TO_BYTES(512));
237	MUST_BE(sizeof(TPMS_ECC_POINT) == 2 * (2 + BITS_TO_BYTES(638)));
238	MUST_BE(sizeof(TPMS_DERIVE) == 2 * (2 + 32));
239
240	typedef struct {
241	TPMI_ALG_PUBLIC type;
242	TPMI_ALG_HASH nameAlg;
243	TPMA_OBJECT objectAttributes;
244	TPM2B_DIGEST authPolicy;
245	TPMU_PUBLIC_PARMS parameters;
246	RSA3072_TPMU_PUBLIC_ID unique;
247	} RSA3072_TPMT_PUBLIC;
248	MUST_BE(sizeof(RSA3072_TPMT_PUBLIC) == 484);
249
250	typedef union {
251	struct {
252	UINT16 size;
253	BYTE buffer[((3072 / 8) / 2) * 5];
254	} t;
255	TPM2B b;
256	} RSA3072_TPM2B_PRIVATE_KEY_RSA;
257	MUST_BE(sizeof(RSA3072_TPM2B_PRIVATE_KEY_RSA) == 962);
258
259	typedef union {
260	struct {
261	UINT16 size;
262	BYTE buffer[((3072 / 8) / 2) * 5];
263	} t;
264	TPM2B b;
265	} RSA3072_TPM2B_PRIVATE_VENDOR_SPECIFIC;
266
267	typedef union {
268	RSA3072_TPM2B_PRIVATE_KEY_RSA rsa;
269	TPM2B_ECC_PARAMETER ecc;
270	TPM2B_SENSITIVE_DATA bits;
271	TPM2B_SYM_KEY sym;
272	RSA3072_TPM2B_PRIVATE_VENDOR_SPECIFIC any;
273	} RSA3072_TPMU_SENSITIVE_COMPOSITE;
274	MUST_BE(sizeof(TPM2B_ECC_PARAMETER) == 2 + BITS_TO_BYTES(638) /* BN P638 */);
275	MUST_BE(sizeof(TPM2B_SENSITIVE_DATA) == 2 + 128);
276	MUST_BE(sizeof(TPM2B_SYM_KEY) == 2 + BITS_TO_BYTES(256));
277
278	typedef struct {
279	TPMI_ALG_PUBLIC sensitiveType;
280	TPM2B_AUTH authValue;
281	TPM2B_DIGEST seedValue;
282	RSA3072_TPMU_SENSITIVE_COMPOSITE sensitive;
283	} RSA3072_TPMT_SENSITIVE;
284	MUST_BE(sizeof(TPM2B_AUTH) == 2 + BITS_TO_BYTES(512));
285	MUST_BE(sizeof(TPM2B_DIGEST) == 2 + BITS_TO_BYTES(512));
286	MUST_BE(sizeof(RSA3072_TPMT_SENSITIVE) == 1096);
287
288	BN_TYPE(rsa3072_prime, (3072 / 2));
289
290	typedef struct RSA3072_privateExponent
291	{
292	bn_rsa3072_prime_t Q;
293	bn_rsa3072_prime_t dP;
294	bn_rsa3072_prime_t dQ;
295	bn_rsa3072_prime_t qInv;
296	} RSA3072_privateExponent_t;
297	MUST_BE(sizeof(RSA3072_privateExponent_t) == 864);
298
299	typedef struct RSA3072_OBJECT
300	{
301	// The attributes field is required to be first followed by the publicArea.
302	// This allows the overlay of the object structure and a sequence structure
303	OBJECT_ATTRIBUTES attributes; // object attributes
304	RSA3072_TPMT_PUBLIC publicArea; // public area of an object
305	RSA3072_TPMT_SENSITIVE sensitive; // sensitive area of an object
306	#if 1 // libtpms added begin: keep
307	RSA3072_privateExponent_t privateExponent; // Additional field for the private
308	#endif // libtpms added end
309	TPM2B_NAME qualifiedName; // object qualified name
310	TPMI_DH_OBJECT evictHandle; // if the object is an evict object,
311	// the original handle is kept here.
312	// The 'working' handle will be the
313	// handle of an object slot.
314	TPM2B_NAME name; // Name of the object name. Kept here
315	// to avoid repeatedly computing it.
316
317	// libtpms added: SEED_COMPAT_LEVEL to use for deriving child keys
318	SEED_COMPAT_LEVEL seedCompatLevel;
319	// libtpms added: OBJECT lies in NVRAM; to avoid that it needs different number
320	// of bytes on 32 bit and 64 bit architectures, we need to make sure it's the
321	// same size; simple padding at the end works here
322	UINT8 _pad[3];
323	} RSA3072_OBJECT;
324	MUST_BE(sizeof(RSA3072_OBJECT) == 2600);
325
326	static inline void CopyFromRSA3072PrimeT(ci_prime_t* dst,	269,268✔
327	const bn_rsa3072_prime_t* src)
328	{
329	dst->allocated = src->allocated;	269,268✔
330	dst->size = src->size;	269,268✔
331	memcpy(dst->d, src->d, sizeof(src->d));	269,268✔
332	}	269,268✔
333
334	static inline void CopyToRSA3072PrimeT(bn_rsa3072_prime_t* dst,	1,732✔
335	const ci_prime_t* src)
336	{
337	dst->allocated = src->allocated;	1,732✔
338	dst->size = src->size;	1,732✔
339	memcpy(dst->d, src->d, sizeof(dst->d));	1,732✔
340	}	1,732✔
341
342	static void RSA3072_OBJECT_To_OBJECT(OBJECT* dest, const RSA3072_OBJECT* src)	67,513✔
343	{
344	dest->attributes = src->attributes;	67,513✔
345	dest->hierarchy = ObjectGetHierarchyFromAttributes(dest);	67,513✔
346
347	dest->publicArea.type = src->publicArea.type;	67,513✔
348	dest->publicArea.nameAlg = src->publicArea.nameAlg;	67,513✔
349	dest->publicArea.objectAttributes = src->publicArea.objectAttributes;	67,513✔
350	dest->publicArea.authPolicy = src->publicArea.authPolicy;	67,513✔
351	dest->publicArea.parameters = src->publicArea.parameters;	67,513✔
352	/* the unique part can be one or two TPM2B's */
353	switch (dest->publicArea.type) {	67,513✔
UNCOV 354	case TPM_ALG_KEYEDHASH:	×
UNCOV 355	MemoryCopy2B(&dest->publicArea.unique.keyedHash.b,	×
356	&src->publicArea.unique.keyedHash.b,
357	sizeof(src->publicArea.unique.keyedHash.t.buffer));
UNCOV 358	memset(&dest->privateExponent, 0, sizeof(dest->privateExponent));	×
359	break;
UNCOV 360	case TPM_ALG_SYMCIPHER:	×
UNCOV 361	MemoryCopy2B(&dest->publicArea.unique.sym.b,	×
362	&src->publicArea.unique.sym.b,
363	sizeof(src->publicArea.unique.sym.t.buffer));
UNCOV 364	memset(&dest->privateExponent, 0, sizeof(dest->privateExponent));	×
365	break;
366	case TPM_ALG_RSA:	67,317✔
367	MemoryCopy2B(&dest->publicArea.unique.rsa.b,	67,317✔
368	&src->publicArea.unique.rsa.b,
369	sizeof(src->publicArea.unique.rsa.t.buffer));
370
371	CopyFromRSA3072PrimeT(&dest->privateExponent.Q, &src->privateExponent.Q);	67,317✔
372	CopyFromRSA3072PrimeT(&dest->privateExponent.dP, &src->privateExponent.dP);	67,317✔
373	CopyFromRSA3072PrimeT(&dest->privateExponent.dQ, &src->privateExponent.dQ);	67,317✔
374	CopyFromRSA3072PrimeT(&dest->privateExponent.qInv, &src->privateExponent.qInv);	67,317✔
375	break;	67,317✔
376	case TPM_ALG_ECC:	196✔
377	MemoryCopy2B(&dest->publicArea.unique.ecc.x.b,	196✔
378	&src->publicArea.unique.ecc.x.b,
379	sizeof(src->publicArea.unique.ecc.x.t.buffer));
380	MemoryCopy2B(&dest->publicArea.unique.ecc.y.b,	196✔
381	&src->publicArea.unique.ecc.y.b,
382	sizeof(src->publicArea.unique.ecc.y.t.buffer));
383	memset(&dest->privateExponent, 0, sizeof(dest->privateExponent));	196✔
384	break;
385	}
386
387	dest->sensitive.sensitiveType = src->sensitive.sensitiveType;	67,513✔
388	dest->sensitive.authValue = src->sensitive.authValue;	67,513✔
389	dest->sensitive.seedValue = src->sensitive.seedValue;	67,513✔
390	/* The OLD_TPMU_SENSITIVE_COMPOSITE is always a TPM2B */
391	MemoryCopy2B(&dest->sensitive.sensitive.any.b,	67,513✔
392	&src->sensitive.sensitive.any.b,
393	sizeof(src->sensitive.sensitive.any.t.buffer));
394
395	dest->qualifiedName = src->qualifiedName;	67,513✔
396	dest->evictHandle = src->evictHandle;	67,513✔
397	dest->name = src->name;	67,513✔
398	dest->seedCompatLevel = src->seedCompatLevel;	67,513✔
399	}	67,513✔
400
401	/* Convert an OBJECT to the (smaller) RSA3072_OBJECT. */
402	static void OBJECT_To_RSA3072_OBJECT(RSA3072_OBJECT* dest, const OBJECT* src)	463✔
403	{
404	dest->attributes = src->attributes;	463✔
405
406	dest->publicArea.type = src->publicArea.type;	463✔
407	dest->publicArea.nameAlg = src->publicArea.nameAlg;	463✔
408	dest->publicArea.objectAttributes = src->publicArea.objectAttributes;	463✔
409	dest->publicArea.authPolicy = src->publicArea.authPolicy;	463✔
410	dest->publicArea.parameters = src->publicArea.parameters;	463✔
411	/* the unique part can be one or two TPM2B's */
412	switch (dest->publicArea.type) {	463✔
UNCOV 413	case TPM_ALG_KEYEDHASH:	×
UNCOV 414	MemoryCopy2B(&dest->publicArea.unique.keyedHash.b,	×
415	&src->publicArea.unique.keyedHash.b,
416	sizeof(dest->publicArea.unique.keyedHash.t.buffer));
UNCOV 417	break;	×
UNCOV 418	case TPM_ALG_SYMCIPHER:	×
UNCOV 419	MemoryCopy2B(&dest->publicArea.unique.sym.b,	×
420	&src->publicArea.unique.sym.b,
421	sizeof(dest->publicArea.unique.sym.t.buffer));
UNCOV 422	break;	×
423	case TPM_ALG_RSA:	433✔
424	MemoryCopy2B(&dest->publicArea.unique.rsa.b,	433✔
425	&src->publicArea.unique.rsa.b,
426	sizeof(dest->publicArea.unique.rsa.t.buffer));
427
428	CopyToRSA3072PrimeT(&dest->privateExponent.Q, &src->privateExponent.Q);	433✔
429	CopyToRSA3072PrimeT(&dest->privateExponent.dP, &src->privateExponent.dP);	433✔
430	CopyToRSA3072PrimeT(&dest->privateExponent.dQ, &src->privateExponent.dQ);	433✔
431	CopyToRSA3072PrimeT(&dest->privateExponent.qInv, &src->privateExponent.qInv);	433✔
432	break;	433✔
433	case TPM_ALG_ECC:	30✔
434	MemoryCopy2B(&dest->publicArea.unique.ecc.x.b,	30✔
435	&src->publicArea.unique.ecc.x.b,
436	sizeof(dest->publicArea.unique.ecc.x.t.buffer));
437	MemoryCopy2B(&dest->publicArea.unique.ecc.y.b,	30✔
438	&src->publicArea.unique.ecc.y.b,
439	sizeof(dest->publicArea.unique.ecc.y.t.buffer));
440	break;	30✔
441	}
442
443	dest->sensitive.sensitiveType = src->sensitive.sensitiveType;	463✔
444	dest->sensitive.authValue = src->sensitive.authValue;	463✔
445	dest->sensitive.seedValue = src->sensitive.seedValue;	463✔
446	/* The OLD_TPMU_SENSITIVE_COMPOSITE is always a TPM2B */
447	MemoryCopy2B(&dest->sensitive.sensitive.any.b,	463✔
448	&src->sensitive.sensitive.any.b,
449	sizeof(dest->sensitive.sensitive.any.t.buffer));
450
451	dest->qualifiedName = src->qualifiedName;	463✔
452	dest->evictHandle = src->evictHandle;	463✔
453	dest->name = src->name;	463✔
454	dest->seedCompatLevel = src->seedCompatLevel;	463✔
455	MemorySet(dest->_pad, 0, sizeof(dest->_pad));	463✔
456	}	463✔
457
458	TPM_RC
459	RSA3072_OBJECT_Buffer_To_OBJECT(OBJECT object, BYTE buffer, INT32 size)	67,513✔
460	{
461	RSA3072_OBJECT rsa3072_object;	67,513✔
462
463	if (size != sizeof(RSA3072_OBJECT))	67,513✔
464	return TPM_RC_SIZE;
465
466	MemoryCopy(&rsa3072_object, buffer, size);	67,513✔
467
468	RSA3072_OBJECT_To_OBJECT(object, &rsa3072_object);	67,513✔
469
470	return 0;	67,513✔
471	}
472
473	UINT32 OBJECT_To_Buffer_As_RSA3072_OBJECT(OBJECT* object, BYTE* buffer, UINT32 size)	463✔
474	{
475	RSA3072_OBJECT rsa3072_object;	463✔
476	UINT32 written = sizeof(rsa3072_object);	463✔
477
478	OBJECT_To_RSA3072_OBJECT(&rsa3072_object, object);	463✔
479
480	pAssert(size >= sizeof(rsa3072_object));	463✔
481	MemoryCopy(buffer, &rsa3072_object, sizeof(rsa3072_object));	463✔
482
483	return written;	463✔
484	}

stefanberger / libtpms / #2071

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous