#include <security_cdsa_client/cspclient.h>
namespace Security {
namespace CssmClient {
CSPImpl::CSPImpl(const Guid &guid) : AttachmentImpl(guid, CSSM_SERVICE_CSP)
{
}
CSPImpl::CSPImpl(const Module &module) : AttachmentImpl(module, CSSM_SERVICE_CSP)
{
}
CSPImpl::~CSPImpl()
{
}
void CSPImpl::freeKey(CssmKey &key, const AccessCredentials *cred, bool permanent)
{
check(CSSM_FreeKey(handle(), cred, &key, permanent));
}
Context::Context(const CSP &csp, CSSM_ALGORITHMS alg)
: ObjectImpl(csp), mAlgorithm(alg), mStaged(false), mCred(NULL)
{
}
Context::~Context()
{
try
{
deactivate();
} catch(...) {}
}
void Context::init()
{
CssmError::throwMe(CSSM_ERRCODE_FUNCTION_NOT_IMPLEMENTED);
}
void Context::deactivate()
{
StLock<Mutex> _(mActivateMutex);
if (mActive)
{
mActive = false;
check(CSSM_DeleteContext(mHandle));
}
}
void Context::algorithm(CSSM_ALGORITHMS alg)
{
if (isActive())
abort(); mAlgorithm = alg;
}
void Context::cred(const CSSM_ACCESS_CREDENTIALS *cred)
{
mCred = AccessCredentials::overlay(cred);
set(CSSM_ATTRIBUTE_ACCESS_CREDENTIALS, *mCred);
}
uint32 Context::getOutputSize(uint32 inputSize, bool encrypt )
{
CSSM_QUERY_SIZE_DATA data;
data.SizeInputBlock = inputSize;
getOutputSize(data, 1, encrypt);
return data.SizeOutputBlock;
}
void Context::getOutputSize(CSSM_QUERY_SIZE_DATA &sizes, uint32 count, bool encrypt )
{
check(CSSM_QuerySize(handle(), encrypt, count, &sizes));
}
void Context::override(const Security::Context &ctx)
{
if (!isActive()) {
check(CSSM_CSP_CreateDigestContext(attachment()->handle(), CSSM_ALGID_NONE, &mHandle));
}
check(CSSM_SetContext(mHandle, &ctx));
mActive = true; }
const ResourceControlContext &RccBearer::compositeRcc() const
{
if (mRcc)
return *mRcc;
if (mOwner)
mWorkRcc.input() = *mOwner;
else
mWorkRcc.clearPod();
mWorkRcc.credentials(mOpCred);
return mWorkRcc;
}
void RccBearer::owner(const CSSM_ACL_ENTRY_PROTOTYPE *owner)
{
if (owner) {
mWorkInput = *owner;
this->owner(mWorkInput);
} else
this->owner((AclEntryInput*)NULL);
}
void
PassThrough::operator() (uint32 passThroughId, const void *inData, void **outData)
{
check(CSSM_CSP_PassThrough(handle(), passThroughId, inData, outData));
}
void PassThrough::activate()
{
StLock<Mutex> _(mActivateMutex);
if (!mActive) {
check(CSSM_CSP_CreatePassThroughContext(attachment()->handle(), mKey, &mHandle));
mActive = true;
}
}
void Digest::activate()
{
StLock<Mutex> _(mActivateMutex);
if (!mActive) {
check(CSSM_CSP_CreateDigestContext(attachment()->handle(), mAlgorithm, &mHandle));
mActive = true;
}
}
void Digest::digest(const CssmData *data, uint32 count, CssmData &digest)
{
activate();
if (mStaged)
Error::throwMe(CSSMERR_CSP_STAGED_OPERATION_IN_PROGRESS);
check(CSSM_DigestData(handle(), data, count, &digest));
}
void Digest::digest(const CssmData *data, uint32 count)
{
activate();
if (!mStaged) {
check(CSSM_DigestDataInit(handle()));
mStaged = true;
}
check(CSSM_DigestDataUpdate(handle(), data, count));
}
void Digest::operator () (CssmData &digest)
{
if (!mStaged)
Error::throwMe(CSSMERR_CSP_STAGED_OPERATION_NOT_STARTED);
check(CSSM_DigestDataFinal(handle(), &digest));
mStaged = false;
}
void Random::seed(const CssmCryptoData &seedData)
{
mSeed = &seedData;
set(CSSM_ATTRIBUTE_SEED, seedData);
}
void Random::size(uint32 sz)
{
mSize = sz;
set(CSSM_ATTRIBUTE_OUTPUT_SIZE, sz);
}
void Random::activate()
{
StLock<Mutex> _(mActivateMutex);
if (!mActive) {
check(CSSM_CSP_CreateRandomGenContext(attachment()->handle(), mAlgorithm,
mSeed, mSize, &mHandle));
mActive = true;
}
}
void Random::generate(CssmData &data, uint32 newSize)
{
if (newSize)
size(newSize);
activate();
assert(!mStaged); check(CSSM_GenerateRandom(handle(), &data));
}
} }