public override TPMCommandResponse Process()
{
byte[] nonce = NonceGenerator.GenerateByteNonce (20);
TPMBlob requestBlob = new TPMBlob ();
requestBlob.WriteCmdHeader (TPMCmdTags.TPM_TAG_RQU_COMMAND, TPMOrdinals.TPM_ORD_ReadPubek);
requestBlob.Write (nonce, 0, nonce.Length);
requestBlob.WriteCmdSize ();
TPMBlob responseBlob = TransmitMe(requestBlob);
responseBlob.SkipHeader ();
long posStart = responseBlob.Position;
TPMPubkeyCore pubkey = TPMPubkeyCore.CreateFromTPMBlob(responseBlob);
long posEnd = responseBlob.Position;
Digest digest = new Digest (responseBlob, 20);
if (digest.CompareTo (
new HashStreamDataProvider (responseBlob, posStart, posEnd - posStart, false),
new HashByteDataProvider (nonce)) == false)
{
throw new TPMResponseException ("Local digest does not match remote digest");
}
Parameters responseParams = new Parameters ();
responseParams.AddValue (TPMPubkey.PARAM_TPM_PUBKEY, pubkey);
return new TPMCommandResponse (true, TPMCommandNames.TPM_CMD_ReadPubek, responseParams);
}
public void WriteToTpmBlob(TPMBlob blob)
{
((ITPMBlobWritable)_version).WriteToTpmBlob(blob);
blob.Write(_fixed, 0, _fixed.Length);
blob.Write(_compositeHash, 0, _compositeHash.Length);
blob.Write(_nonce, 0, _nonce.Length);
}
public void ReadFromTpmBlob(TPMBlob blob)
{
UInt16 handleCount = blob.ReadUInt16 ();
for (int i = 0; i < handleCount; i++)
_handles.Add (blob.ReadUInt32());
}
public override TPMCommandResponse Process()
{
//We don't have any meaningful labeldata we could include,
//so generate some random
byte[] labelData = new byte[16];
Random r = new Random();
r.NextBytes(labelData);
if(_params.IsDefined<ITPMHandle>("handle") == false)
return new TPMCommandResponse(false, TPMCommandNames.TPM_CMD_SaveContext, new Parameters());
ITPMHandle handle = _params.GetValueOf<ITPMHandle>("handle");
TPMBlob requestBlob = new TPMBlob();
requestBlob.WriteCmdHeader(TPMCmdTags.TPM_TAG_RQU_COMMAND, TPMOrdinals.TPM_ORD_SaveContext);
requestBlob.WriteUInt32(handle.Handle);
requestBlob.WriteUInt32((uint)handle.ResourceType);
requestBlob.Write(labelData, 0, labelData.Length);
TPMBlob responseBlob = TransmitMe(requestBlob);
responseBlob.SkipHeader();
uint blobSize = responseBlob.ReadUInt32();
byte[] contextBlob = responseBlob.ReadBytes((int)blobSize);
Parameters responseParams = new Parameters();
responseParams.AddPrimitiveType("context_blob", contextBlob);
return new TPMCommandResponse(true, TPMCommandNames.TPM_CMD_SaveContext, responseParams);
}
public HashTPMBlobWritableDataProvider(ITPMBlobWritable blobWritable)
{
TPMBlob tempBlob = new TPMBlob ();
blobWritable.WriteToTpmBlob (tempBlob);
_subDataProvider = new HashStreamDataProvider (tempBlob, null, null, true);
}
public void ReadFromTpmBlob(TPMBlob blob)
{
uint size = blob.ReadUInt16();
byte[] selectionBits = new byte[size];
blob.Read(selectionBits, 0, (int)size);
_pcrSelection = new BitMap(selectionBits);
}
public ResponseAuthHandleInfoCore(TPMBlob blob, long startIndex)
{
blob.Seek(startIndex, SeekOrigin.Begin);
_nonceEven = blob.ReadBytes(20);
_continueAuthSession = blob.ReadBool();
_tpmAuthData = blob.ReadBytes(20);
}
public void WriteToTpmBlob(TPMBlob blob)
{
((ITPMBlobWritable)_versionStruct).WriteToTpmBlob(blob);
blob.WriteUInt32((uint)_sealInfo.Length);
blob.Write(_sealInfo,0,_sealInfo.Length);
blob.WriteUInt32((uint)_encData.Length);
blob.Write(_encData, 0, _encData.Length);
}
public void WriteToTpmBlob(TPMBlob blob)
{
((ITPMBlobWritable)_pcrSelection).WriteToTpmBlob(blob);
blob.WriteUInt32((uint)_pcrValues.Length * 20);
foreach(byte[] pcrValue in _pcrValues)
blob.Write(pcrValue,0, pcrValue.Length);
}
public void ReadFromTpmBlob(TPMBlob blob)
{
_keyLength = blob.ReadUInt32 ();
_numPrimes = blob.ReadUInt32 ();
uint expoSize = blob.ReadUInt32 ();
_exponent = new byte[expoSize];
blob.Read (_exponent, 0, (int)expoSize);
}
public static TPMContextBlobCore CreateFromBytes(byte[] rawContextBLob)
{
using(TPMBlob blob = new TPMBlob(rawContextBLob))
{
TPMContextBlobCore contextBlob = new TPMContextBlobCore();
contextBlob.ReadFromTpmBlob(blob);
return contextBlob;
}
}
public void ReadFromTpmBlob(TPMBlob blob)
{
_pcrSelection = TPMPCRSelectionCore.CreateFromTPMBlob(blob);
uint valueSize = blob.ReadUInt32();
_pcrValues = new byte[valueSize/20][];
for(int i = 0; i<valueSize/20; i++)
_pcrValues[i] = blob.ReadBytes(20);
}
public void ReadFromTpmBlob(TPMBlob blob)
{
_versionStruct = CapabilityDataCore.TPMVersionCore.CreateFromTPMBlob(blob);
_sealInfo = new byte[blob.ReadUInt32()];
blob.Read(_sealInfo, 0, _sealInfo.Length);
_encData = new byte[blob.ReadUInt32()];
blob.Read(_encData, 0, _encData.Length);
}
public void ReadFromTpmBlob(TPMBlob blob)
{
_authHandle = blob.ReadUInt32();
_nonceEven = new byte[20];
blob.Read(_nonceEven, 0, _nonceEven.Length);
if(_authType == AuthHandle.AuthType.OSAP)
{
_nonceEvenOSAP = new byte[20];
blob.Read(_nonceEvenOSAP, 0, _nonceEvenOSAP.Length);
}
}
public void ReadFromTpmBlob(TPMBlob blob)
{
/*uint responseSize = */blob.ReadUInt32 ();
this._tag = blob.ReadUInt16 ();
this._version = new TPMVersionCore (blob);
this._specLevel = blob.ReadUInt16 ();
this._errataRev = blob.ReadByte ();
this._tpmVendorId = new byte[4];
blob.Read (_tpmVendorId, 0, _tpmVendorId.Length);
ushort vendorSize = blob.ReadUInt16 ();
_vendorSpecific = blob.ReadBytes (vendorSize);
}
public void ReadFromTpmBlob(TPMBlob blob)
{
_tag = (TPMStructureTag)blob.ReadUInt16();
_resourceType = (TPMResourceType)blob.ReadUInt32();
_handle = blob.ReadUInt32();
_label = blob.ReadBytes(16);
_contextCount = blob.ReadUInt32();
_integrityDigest = blob.ReadBytes(20);
uint additionalSize = blob.ReadUInt32();
_additionalData = blob.ReadBytes((int)additionalSize);
uint sensitiveSize = blob.ReadUInt32();
_sensitiveData = blob.ReadBytes((int)sensitiveSize);
}
public override TPMCommandResponse Process()
{
TPMBlob requestBlob = new TPMBlob();
requestBlob.WriteCmdHeader(TPMCmdTags.TPM_TAG_RQU_COMMAND, TPMOrdinals.TPM_ORD_OIAP);
requestBlob.WriteCmdSize();
_commandAuthHelper.EnsureFreeSlot();
TPMBlob responseBlob = TransmitMe(requestBlob);
responseBlob.SkipHeader();
AuthHandleCore authHandle = new AuthHandleCore(AuthHandle.AuthType.OIAP, responseBlob);
_responseParameters = new Parameters();
_responseParameters.AddValue("auth_handle", authHandle);
return new TPMCommandResponse(true, TPMCommandNames.TPM_CMD_OIAP, _responseParameters);
}
/// <summary>
/// Writes target to sink with the uint size preceding
/// </summary>
/// <param name="sink"></param>
/// <param name="target"></param>
public static void WriteITPMBlobWritableWithUIntSize(TPMBlob sink, ITPMBlobWritable target)
{
if (target == null)
{
sink.WriteUInt32 (0);
}
else
{
using (TPMBlob tempBlob = new TPMBlob ())
{
target.WriteToTpmBlob (tempBlob);
sink.WriteUInt32 ((uint)tempBlob.Length);
sink.Write (tempBlob.ToArray (), 0, (int)tempBlob.Length);
}
}
}
public override TPMCommandResponse Process()
{
using(TPMBlob requestBlob = new TPMBlob())
{
requestBlob.WriteCmdHeader(TPMCmdTags.TPM_TAG_RQU_COMMAND, TPMOrdinals.TPM_ORD_GetRandom);
requestBlob.WriteUInt32(_params.GetValueOf<uint>("bytes_requested"));
_responseBlob = TransmitMe(requestBlob);
}
_responseBlob.SkipHeader();
uint responseByteSize = _responseBlob.ReadUInt32();
_responseParameters = new Parameters();
_responseParameters.AddPrimitiveType("data", _responseBlob.ReadBytes((int)responseByteSize));
return new TPMCommandResponse(true, TPMCommandNames.TPM_CMD_GetRandom, _responseParameters);
}
public override TPMCommandResponse Process()
{
using(TPMBlob requestBlob = new TPMBlob())
{
requestBlob.WriteCmdHeader(TPMCmdTags.TPM_TAG_RQU_COMMAND, TPMOrdinals.TPM_ORD_ReadCounter);
requestBlob.WriteUInt32(_params.GetValueOf<uint>("counter_id"));
_responseBlob = TransmitMe(requestBlob);
}
_responseBlob.SkipHeader();
_responseParameters = new Parameters();
_responseParameters.AddPrimitiveType("counter_id", _params.GetValueOf<uint>("counter_id"));
_responseParameters.AddValue("counter_value", TPMCounterValueCore.CreateFromTPMBlob(_responseBlob));
return new TPMCommandResponse(true, TPMCommandNames.TPM_CMD_ReadCounter, _responseParameters);
}
public override TPMCommandResponse Process()
{
if(_params.GetValueOf<string>("type", "") == "request_prefix")
{
TPMBoundDataCore boundData = TPMBoundDataCore.Encapsulate(new byte[0]);
_responseParameters = new Parameters();
using(TPMBlob blob = new TPMBlob())
{
boundData.WriteToTpmBlob(blob);
_responseParameters.AddPrimitiveType("prefix", blob.ToArray());
}
return new TPMCommandResponse(true, TPMCommandNames.TPM_CMD_Bind, _responseParameters);
}
else
throw new ArgumentException("TPM_Bind: did not find valid type");
}
public override TPMCommandResponse Process()
{
TPMBlob requestBlob = new TPMBlob ();
requestBlob.WriteCmdHeader (TPMCmdTags.TPM_TAG_RQU_COMMAND, TPMOrdinals.TPM_ORD_PcrRead);
requestBlob.WriteUInt32 ((uint)_register);
requestBlob.WriteCmdSize ();
TPMBlob responseBlob = TransmitMe (requestBlob);
Parameters responseParam = new Parameters();
byte[] val = responseBlob.ReadBytes(20);
responseParam.AddPrimitiveType("pcrnum", _register);
responseParam.AddPrimitiveType("value", val);
TPMCommandResponse response = new TPMCommandResponse(true, TPMCommandNames.TPM_CMD_PCRRead, responseParam);
return response;
}
public static ResponseAuthHandleInfo[] ReadAuthHandleInfos(IAuthorizableCommand cmd, TPMBlob blob)
{
long currentIndex = blob.Length;
List<ResponseAuthHandleInfo> responseAuthHandles = new List<ResponseAuthHandleInfo>();
foreach(AuthSessionNum authSession in new AuthSessionNum[]{AuthSessionNum.Auth2, AuthSessionNum.Auth1})
{
HMACKeyInfo keyInfo = cmd.GetKeyInfo(authSession);
if(keyInfo != null)
{
currentIndex -= SINGLE_AUTH_HANDLE_SIZE;
responseAuthHandles.Add(new ResponseAuthHandleInfoCore(blob, currentIndex));
}
}
responseAuthHandles.Reverse();
return responseAuthHandles.ToArray();
}
public override TPMCommandResponse Process()
{
using(TPMBlob requestBlob = new TPMBlob())
{
requestBlob.WriteCmdHeader(TPMCmdTags.TPM_TAG_RQU_COMMAND, TPMOrdinals.TPM_ORD_Extend);
requestBlob.WriteUInt32(_params.GetValueOf<uint>("pcr"));
byte[] digest = _params.GetValueOf<byte[]>("digest");
if(digest.Length != 20)
throw new ArgumentException("Digest needs to be of length '20'");
requestBlob.Write(digest, 0, digest.Length);
_responseBlob = TransmitMe(requestBlob);
}
_responseBlob.SkipHeader();
_responseParameters = new Parameters();
_responseParameters.AddPrimitiveType("pcr_value", _responseBlob.ReadBytes(20));
return new TPMCommandResponse(true, TPMCommandNames.TPM_CMD_Extend, _responseParameters);
}
public void ReadFromTpmBlob(TPMBlob blob)
{
_algorithmId = (TPMAlgorithmId)blob.ReadUInt32 ();
_encScheme = (TPMEncScheme)blob.ReadUInt16 ();
_sigScheme = (TPMSigScheme)blob.ReadUInt16 ();
UInt32 paramsSize = blob.ReadUInt32 ();
byte[] paramsData = new byte[paramsSize];
blob.Read (paramsData, 0, paramsData.Length);
using (TPMBlob paramSrc = new TPMBlob (paramsData))
{
if (_algorithmId == TPMAlgorithmId.TPM_ALG_RSA)
_params = TPMRSAKeyParamsCore.CreateFromTPMBlob(paramSrc);
else if (_algorithmId == TPMAlgorithmId.TPM_ALG_AES128 ||
_algorithmId == TPMAlgorithmId.TPM_ALG_AES192 ||
_algorithmId == TPMAlgorithmId.TPM_ALG_AES256)
//TODO
throw new NotImplementedException ("Symmetric key params not implemented");
}
}
public override TPMCommandResponse Process()
{
ITPMHandle handle = _params.GetValueOf<ITPMHandle> ("handle");
TPMBlob requestBlob = new TPMBlob ();
requestBlob.WriteCmdHeader (TPMCmdTags.TPM_TAG_RQU_COMMAND, TPMOrdinals.TPM_ORD_FlushSpecific);
requestBlob.WriteUInt32 (handle.Handle);
requestBlob.WriteUInt32 ((uint)handle.ResourceType);
requestBlob.WriteCmdSize ();
try
{
TransmitMe(requestBlob);
}
catch(Exception)
{
if(!_params.GetValueOf<bool>("ignore_tpm_error", false))
throw;
}
return new TPMCommandResponse (true, TPMCommandNames.TPM_CMD_FlushSpecific, new Parameters ());
}
public override TPMCommandResponse Process()
{
if(_params.IsDefined<ITPMHandle>("handle") == false ||
_params.IsDefined<byte[]>("context_blob") == false)
return new TPMCommandResponse(false, TPMCommandNames.TPM_CMD_LoadContext, new Parameters());
ITPMHandle handle = _params.GetValueOf<ITPMHandle>("handle");
TPMBlob blob = new TPMBlob();
blob.WriteCmdHeader(TPMCmdTags.TPM_TAG_RQU_COMMAND, TPMOrdinals.TPM_ORD_LoadContext);
blob.WriteUInt32(handle.Handle);
blob.WriteBool(handle.ForceHandle);
blob.WriteUInt32((uint)handle.ContextBlob.Length);
blob.Write(handle.ContextBlob, 0, handle.ContextBlob.Length);
TPMBlob responseBlob = TransmitMe(blob);
responseBlob.SkipHeader();
handle.Handle = responseBlob.ReadUInt32();
Parameters responseParameters = new Parameters();
responseParameters.AddValue("handle", handle);
return new TPMCommandResponse(true, TPMCommandNames.TPM_CMD_LoadContext, responseParameters);
}
protected override TPMCommandResponse InternalProcess()
{
TPMBlob requestBlob = new TPMBlob();
requestBlob.WriteCmdHeader(TPMCmdTags.TPM_TAG_RQU_AUTH1_COMMAND, TPMOrdinals.TPM_ORD_Quote);
//key handle gets inserted later, it may be not available now
requestBlob.WriteUInt32(0);
requestBlob.Write(_nonce, 0, 20);
_pcrSelection.WriteToTpmBlob(requestBlob);
_keyManager.LoadKey(_params.GetValueOf<string>("key"));
AuthorizeMe(requestBlob);
using(_keyManager.AcquireLock())
{
requestBlob.SkipHeader();
requestBlob.WriteUInt32(_keyManager.IdentifierToHandle(_params.GetValueOf<string>("key")).Handle);
_responseBlob = TransmitMe(requestBlob);
}
CheckResponseAuthInfo();
_responseBlob.SkipHeader();
TPMPCRCompositeCore pcrComposite = TPMPCRCompositeCore.CreateFromTPMBlob(_responseBlob);
uint sigSize = _responseBlob.ReadUInt32();
byte[] signature = _responseBlob.ReadBytes((int)sigSize);
// Do signature verification
TPMQuoteInfoCore quoteInfo = TPMQuoteInfoCore.Create(new HashProvider().Hash(new HashTPMBlobWritableDataProvider(pcrComposite)), _nonce);
byte[] signingData;
using (TPMBlob blob = new TPMBlob())
{
quoteInfo.WriteToTpmBlob(blob);
signingData = blob.ToArray();
}
Parameters pubKeyParams = new Parameters();
pubKeyParams.AddPrimitiveType("key", _params.GetValueOf<string>("key"));
TPMCommandRequest pubKeyRequest = new TPMCommandRequest(TPMCommandNames.TPM_CMD_GetPubKey, pubKeyParams);
TPMCommandResponse pubKeyResponse = _tpmWrapper.Process(pubKeyRequest,
_commandAuthHelper, _keyManager);
if (pubKeyResponse.Status == false)
{
_log.FatalFormat("TPM_Quote: Could not retrieve pubkey of key");
return new TPMCommandResponse(false, TPMCommandNames.TPM_CMD_Quote, new Parameters());
}
TPMKey keyInfo = TPMKeyCore.CreateFromBytes(_keyManager.GetKeyBlob(_params.GetValueOf<string>("key")));
TPMPubkey pubkey = pubKeyResponse.Parameters.GetValueOf<TPMPubkey>("pubkey");
if (SignatureVerification.VerifySignature(keyInfo, pubkey, signingData, signature) == false)
{
throw new ArgumentException("The TPM_Quote signature could not be verified");
}
Parameters responseParams = new Parameters();
responseParams.AddValue("pcrData", pcrComposite);
responseParams.AddPrimitiveType("sig", signature);
return new TPMCommandResponse(true, TPMCommandNames.TPM_CMD_Quote, responseParams);
}
public void ReadFromTpmBlob(TPMBlob blob)
{
blob.Read (_digest, 0, _digest.Length);
}
/// <summary>
///
/// </summary>
/// <param name="blob"></param>
/// <param name="digestSize">Digest size in bytes</param>
public Digest(TPMBlob blob, int digestSize)
{
_digest = new byte[digestSize];
ReadFromTpmBlob (blob);
}
