TpmExtensions.java.snips

/*
    This file contains source-code snippets that the code-generator inserts into the 
    appropriate class definition file.   

*/


>> TPM_HANDLE
public static final TPM_HANDLE
    /** Represents TPM_RH.NULL handle constant */
    NULL = TPM_HANDLE.from(TPM_RH.NULL),
    /** Represents TPM_RH.NULL handle constant */
    PW = TPM_HANDLE.from(TPM_RH.PW),
    /** Represents TPM_RH.OWNER handle constant */
    OWNER = TPM_HANDLE.from(TPM_RH.OWNER),
    /** Represents TPM_RH.ENDORSEMENT handle constant */
    ENDORSEMENT = TPM_HANDLE.from(TPM_RH.ENDORSEMENT),
    /** Represents TPM_RH.PLATFORM handle constant */
    PLATFORM = TPM_HANDLE.from(TPM_RH.PLATFORM);


/** Authorization value associated with this handle object.<BR>
 *  NOTE: It is tracked by the framework whenever possible but in some cases may be left uninitialized.
 */
public byte[] AuthValue;
    
/** Name of the TPM entity represented by this handle object.<BR>
 *  NOTE: It is tracked by the framework whenever possible but in some cases may be left uninitialized.
 */
public byte[] Name;

/** Wraps an arbitrary int value into a TPM handle object
 *  @param val  int value to be used as a TPM handle
 *  @return  New TPM_HANDLE object 
 */
public static TPM_HANDLE from(int val)
{
    return new TPM_HANDLE(val);
}

/** Creates a TPM handle from the given reserved handle constant
 *  @param _handle  Reserved handle constant
 *  @return  New TPM_HANDLE object 
 */
public static TPM_HANDLE from(TPM_RH _handle)
{
    return new TPM_HANDLE(_handle.toInt());
}

/** @return  New NULL TPM handle */
public static TPM_HANDLE nullHandle()
{
    return new TPM_HANDLE(TPM_RH.NULL.toInt());
}

/** Creates a pesistent TPM handle with the given offset (0 - 0x00FFFFFF)
 *  @param handleOffset  Reserved handle offset
 *  @return  New persistent TPM handle 
 */
public static TPM_HANDLE persistent(int handleOffset)
{
    return new TPM_HANDLE(((TPM_HT.PERSISTENT.toInt()) << 24) + handleOffset);
};

/** Creates a TPM handle for a PCR with the given index
 *  @param PcrIndex The PCR index (0 - 23)
 *  @return New TPM_HANDLE object
 */
public static TPM_HANDLE pcr(int PcrIndex)
{
    return new TPM_HANDLE(PcrIndex);
}

/** Creates a TPM_HANDLE for the given NV index
 *  @param  NvSlot  NV index
 *  @return New TPM handle object 
 */
public static TPM_HANDLE NV(int NvSlot)
{
    int handleVal = (TPM_HT.NV_INDEX.toInt() << 24) + NvSlot;
    return new TPM_HANDLE(handleVal);
};

/** @return  This handle type */
public TPM_HT getType()
{
    return TPM_HT.fromInt(handle >> 24);
};

/** Creates a password session handle with the given authorization value
 * @param authValue  Authorization value
 * @return  New session handle
 */
public static TPM_HANDLE pwSession(byte[] authValue)
{
    TPM_HANDLE pwapHandle = TPM_HANDLE.from(TPM_RH.PW);
    pwapHandle.AuthValue = authValue;
    return pwapHandle;
}

/** @return  The TPM name of this handle */
public byte[] getName()
{
    int handleType = getType().toInt();
    switch (handleType) {
        case 0:
        case 2:
        case 3:
        case 0x40:
            Name = Helpers.hostToNet(handle);
            return Name;

        case 1:
        case 0x80:
        case 0x81:
            if (Name.length == 0)
                throw new RuntimeException("Name is not set for handle");
            return Name;

        default:
            throw new RuntimeException("Unknown handle type");
    }
}


>> TPMT_PUBLIC
/**
 * Validate a TPM signature.  Note that this function hashes dataThatWasSigned before
 * verifying the signature.
 *
 * @param _dataThatWasSigned The data
 * @param _signature The TPM signature
 * @return True if the signature is valid 
 */
public boolean validateSignature(byte[] _dataThatWasSigned, TPMU_SIGNATURE _signature)
{
    return Crypto.validateSignature(this, _dataThatWasSigned, _signature);
}

public byte[] encrypt(byte[] inData, String label)
{
    return Crypto.asymEncrypt(this, inData, label);
}

/**
 * Returns the TPM name of this object.  The name is the alg-prepended hash of the public area.
 *
 * @return The TPM object name
 */
public byte[] getName()
{
       byte[] pub = toTpm();
    byte[] pubHash = Crypto.hash(nameAlg, pub);
    byte[] theHashAlg = Helpers.hostToNet((short)nameAlg.toInt());
    return Helpers.concatenate(theHashAlg, pubHash);
}
/**
 * Validate a TPM quote against a set of PCR and a nonce.
 * 
 * @param expectedPcrs PCR values expected
 * @param nonce The nonce
 * @param quote The TPM generated quote
 * @return Whether the quote was valid
 * 
 */
public boolean validateQuote(PCR_ReadResponse expectedPcrs, byte[] nonce, QuoteResponse quote)
{
    return Crypto.validateQuote(this, expectedPcrs, nonce, quote);
}

>> TPMS_PCR_SELECTION
/** Create a PCR_SELECTION naming a single PCR
 * @param pcrAlg The hash algorithm
 * @param pcrIndex The PCR index
 */
public TPMS_PCR_SELECTION(TPM_ALG_ID pcrAlg, int pcrIndex)
{
    hash = pcrAlg;
    int sz = 3;
    if ((pcrIndex / 8 + 1) > sz)
        sz = pcrIndex  / 8 + 1;

    pcrSelect = new byte[sz];
    pcrSelect[pcrIndex / 8] = (byte) (1 << (pcrIndex % 8));
}

/** Create a PCR_SELECTION[] from a single PCR
 * @param pcrAlg The hash algorithm
 * @param pcrIndex The PCR index
 * @return A new selection array
 */
public static TPMS_PCR_SELECTION[] CreateSelectionArray(TPM_ALG_ID pcrAlg, int pcrIndex)
{
    TPMS_PCR_SELECTION[] arr = new TPMS_PCR_SELECTION[1];
    arr[0] = new TPMS_PCR_SELECTION(pcrAlg, pcrIndex);
    return arr;
}

/**
* Create a PCR_SELECTION from an array of PCRs in the same bank
* 
* @param pcrAlg The hash algorithm
* @param pcrIndices The PCRs to select
*/
public TPMS_PCR_SELECTION(TPM_ALG_ID pcrAlg, int[] pcrIndices)
{
    hash = pcrAlg;
    int pcrMax = 0;

    for (int j = 0; j < pcrIndices.length; j++)
    {
        if (pcrIndices[j] > pcrMax)
            pcrMax = pcrIndices[j];
    }

    if (pcrMax < 23)
        pcrMax = 23;

    pcrSelect = new byte[pcrMax / 8 + 1];

    for (int j = 0; j < pcrIndices.length; j++) 
    {
        pcrSelect[pcrIndices[j] / 8] |= (byte)(1 << (pcrIndices[j] % 8));
    }
}


>> TPMT_TK_HASHCHECK

/** Create a NULL ticket (e.g. used for signing data with non-restricted keys)
 * @return The null ticket
 */
public static TPMT_TK_HASHCHECK nullTicket()
{
    TPMT_TK_HASHCHECK t = new TPMT_TK_HASHCHECK();
    t.hierarchy = TPM_HANDLE.from(TPM_RH.OWNER);
    return t;
}


>> TPMT_SYM_DEF
/** @deprecated Use default constructor instead */
@Deprecated
public static TPMT_SYM_DEF nullObject() { return new TPMT_SYM_DEF(); }

>> TPMT_SYM_DEF_OBJECT
/** @deprecated Use default constructor instead */
@Deprecated
public static TPMT_SYM_DEF_OBJECT nullObject() { return new TPMT_SYM_DEF_OBJECT(); }

>> TPMT_HA
/** Create a TPMT_HA from the hash of data
 * @param hashAlg The hash algorithm
 * @param data The data to hash
 * @return A new TPMT_HA
 */
public static TPMT_HA fromHashOf(TPM_ALG_ID hashAlg, byte[] data)
{
    return new TPMT_HA(hashAlg, Crypto.hash(hashAlg, data));
}

/** Create a TPMT_HA from the hash of a UTF8 encoded string 
 * @param hashAlg The hash algorithm
 * @param s The string to hash
 * @return A new TPMT_HA
 */
public static TPMT_HA fromHashOf(TPM_ALG_ID hashAlg, String s)
{
    byte[] buf = s.getBytes();
    return TPMT_HA.fromHashOf(hashAlg, buf);
}

/** Perform a TPM Extend operation on the contents of this TPMT_HA 
 * @param x The data to extend
 * @return The same object (to allow chaining)
 */
public TPMT_HA extend(byte[] x)
{
    byte[] t = Helpers.concatenate(digest, x);
    digest = Crypto.hash(hashAlg, t);
    return this;
}

/** Perform a TPM Event operation on the contents of this TPMT_HA 
 * @param x The data to event
 * @return The same object (to allow chaining)
 */
public TPMT_HA event(byte[] x)
{
    byte[] s = Crypto.hash(hashAlg, x);
    byte[] t = Helpers.concatenate(digest, s);
    digest = Crypto.hash(hashAlg, t);
    return this;
}

/** Reset the contents of this hash object to all zeros */
public void reset()
{
    digest = new byte[Crypto.digestSize(hashAlg)];
}

/** Create an all zero hash object 
 * @param alg The hash algorithm to use
 * @return The new zero TPMT_HA
 */
public static TPMT_HA zeroHash(TPM_ALG_ID alg)
{
    return new TPMT_HA(alg, new byte[Crypto.digestSize(alg)]);
}