#include "SSContext.h"
#include "SSCSPSession.h"
#include "SSKey.h"
using namespace SecurityServer;
SSContext::SSContext(SSCSPSession &session)
: mSession(session), mContext(NULL)
{
}
void
SSContext::init(const Context &context,
bool ) {
mContext = &context;
}
SecurityServer::ClientSession &
SSContext::clientSession()
{
return mSession.clientSession();
}
SSRandomContext::SSRandomContext(SSCSPSession &session) : SSContext(session) {}
void
SSRandomContext::init(const Context &context, bool encoding)
{
SSContext::init(context, encoding);
mOutSize = context.getInt(CSSM_ATTRIBUTE_OUTPUT_SIZE, CSSMERR_CSP_MISSING_ATTR_OUTPUT_SIZE);
#if 0
if (const CssmCryptoData *seed = context.get<CssmCryptoData>(CSSM_ATTRIBUTE_SEED)) {
const CssmData &seedValue = (*seed)();
clientSession().seedRandom(seedValue);
}
#endif
}
size_t
SSRandomContext::outputSize(bool final, size_t inSize)
{
return mOutSize;
}
void
SSRandomContext::final(CssmData &out)
{
clientSession().generateRandom(out);
}
SSSignContext::SSSignContext(SSCSPSession &session) : SSContext(session) {}
void
SSSignContext::update(const CssmData &data)
{
}
size_t
SSSignContext::outputSize(bool final, size_t inSize)
{
return 0;
}
void
SSSignContext::final(CssmData &out)
{
}
SSVerifyContext::SSVerifyContext(SSCSPSession &session) : SSContext(session) {}
void
SSVerifyContext::update(const CssmData &data)
{
}
void
SSVerifyContext::final(const CssmData &in)
{
}
SSCryptContext::SSCryptContext(SSCSPSession &session)
: SSContext(session), mKeyHandle(noKey), mCurrent(0), mCapacity(0),
mBuffer(NULL)
{
}
SSCryptContext::~SSCryptContext()
{
freeBuffer();
}
void
SSCryptContext::freeBuffer()
{
if (mBuffer)
{
if (mCapacity )
{
memset(mBuffer, 0, mCapacity);
}
free(mBuffer);
mBuffer = NULL;
mCapacity = 0;
}
}
void
SSCryptContext::init(const Context &context, bool encoding)
{
SSContext::init(context, encoding);
freeBuffer();
mCurrent = 0;
mCapacity = 0;
const CssmKey &keyInContext =
context.get<const CssmKey>(CSSM_ATTRIBUTE_KEY,
CSSMERR_CSP_MISSING_ATTR_KEY);
mKeyHandle = mSession.lookupKey(keyInContext).keyHandle();
}
size_t
SSCryptContext::inputSize(size_t outSize)
{
return UINT_MAX;
}
size_t
SSCryptContext::outputSize(bool final, size_t inSize)
{
if (!final)
{
mCapacity = mCurrent + inSize;
mBuffer = realloc(mBuffer, mCapacity);
return 0;
}
assert(!inSize);
const CssmData in(mBuffer, mCurrent);
CssmData out;
if (encoding())
clientSession().encrypt(*mContext, mKeyHandle, in, out);
else
clientSession().decrypt(*mContext, mKeyHandle, in, out);
freeBuffer();
mBuffer = out.Data;
mCapacity = out.Length;
mCurrent = 0;
return mCapacity;
}
void
SSCryptContext::minimumProgress(size_t &in, size_t &out)
{
assert(false);
}
void
SSCryptContext::update(void *inp, size_t &inSize, void *outp, size_t &outSize)
{
outSize = 0;
assert(inSize);
assert(mCurrent + inSize <= mCapacity);
memcpy(&reinterpret_cast<uint8 *>(mBuffer)[mCurrent], inp, inSize);
mCurrent += inSize;
}
void
SSCryptContext::final(CssmData &out)
{
if(!out.Length) return;
assert(out.Data && out.Length);
uint32 todo = min(out.Length, mCapacity - mCurrent);
memcpy(out.Data, &reinterpret_cast<uint8 *>(mBuffer)[mCurrent], todo);
mCurrent += todo;
out.Length = todo;
freeBuffer();
}
#if 0
SSKeyPairGenContext::SSKeyPairGenContext(SSCSPSession &session)
: SSContext(session) {}
void
SSKeyPairGenContext::generate(const Context &context,
CssmKey &pubKey,
SSKey *pubBinKey,
CssmKey &privKey,
SSKey *privBinKey)
{
}
void
SSKeyPairGenContext::generate(const Context &context,
SSKey &pubBinKey,
SSKey &privBinKey,
uint32 &keySize)
{
}
SSSymmKeyGenContext::SSSymmKeyGenContext(SSCSPSession &session,
uint32 minSize,
uint32 maxSize,
bool byteSized)
: SSContext(session),
minSizeInBits(minSize),
maxSizeInBits(maxSize),
mustBeByteSized(byteSized)
{
}
void
SSSymmKeyGenContext::generateSymKey(const Context &context, CssmKey &cssmKey)
{
}
#endif