C4Err HASH_Export(HASH_ContextRef ctx, void *outData, size_t bufSize, size_t *datSize)
{
C4Err err = kC4Err_NoErr;
const struct ltc_hash_descriptor* desc = NULL;
validateHASHContext(ctx);
ValidateParam(outData);
ValidateParam(datSize);
desc = sDescriptorForHash(ctx->algor);
if(IsNull(desc))
RETERR( kC4Err_BadHashNumber);
if(sizeof(HASH_Context) > bufSize)
RETERR( kC4Err_BufferTooSmall);
COPY( ctx, outData, sizeof(HASH_Context));
*datSize = sizeof(HASH_Context);
done:
return err;
}
C4Err ECC_SharedSecret(ECC_ContextRef privCtx, ECC_ContextRef pubCtx, void *outData, size_t bufSize, size_t *datSize)
{
C4Err err = kC4Err_NoErr;
unsigned long length = bufSize;
validateECCContext(privCtx);
validateECCContext(pubCtx);
ValidateParam(privCtx->isInited);
ValidateParam(pubCtx->isInited);
// test that both keys are same kind */
ValidateParam(!( !pubCtx->isBLCurve != !privCtx->isBLCurve ));
if(pubCtx->isBLCurve)
err = ecc_bl_shared_secret(&privCtx->key, &pubCtx->key, outData, &length);
else
err = ecc_shared_secret(&privCtx->key, &pubCtx->key, outData, &length);
*datSize = length;
//done:
return (err);
}
C4Err ECC_Sign(ECC_ContextRef privCtx, void *inData, size_t inDataLen, void *outData, size_t bufSize, size_t *outDataLen)
{
C4Err err = kC4Err_NoErr;
int status = CRYPT_OK;
unsigned long length = bufSize;
validateECCContext(privCtx);
ValidateParam(privCtx->isInited);
if(privCtx->isBLCurve)
{
status = ecc_bl_sign_hash(inData, inDataLen, outData, &length,
0, find_prng("sprng"),
&privCtx->key);
}
else
{
status = ecc_sign_hash(inData, inDataLen, outData, &length,
0, find_prng("sprng"),
&privCtx->key);
}
if(status != CRYPT_OK)
{
err = sCrypt2C4Err(status); CKERR;
}
*outDataLen = length;
done:
return err;
}
C4Err HASH_Import(void *inData, size_t bufSize, HASH_ContextRef * ctx)
{
C4Err err = kC4Err_NoErr;
HASH_Context* hashCTX = NULL;
ValidateParam(ctx);
*ctx = NULL;
if(sizeof(HASH_Context) != bufSize)
RETERR( kC4Err_BadParams);
hashCTX = XMALLOC(sizeof (HASH_Context)); CKNULL(hashCTX);
COPY( inData, hashCTX, sizeof(HASH_Context));
validateHASHContext(hashCTX);
*ctx = hashCTX;
done:
if(IsC4Err(err))
{
if(IsntNull(hashCTX))
{
XFREE(hashCTX);
}
}
return err;
}
C4Err HASH_Update(HASH_ContextRef ctx, const void *data, size_t dataLength)
{
int err = kC4Err_NoErr;
// const struct ltc_hash_descriptor* desc = NULL;
validateHASHContext(ctx);
ValidateParam(data);
if(ctx->process)
err = (ctx->process)(&ctx->state, data, dataLength );
//
//
// desc = sDescriptorForHash(ctx->algor);
//
// if(IsNull(desc))
// RETERR( kC4Err_BadHashNumber);
//
// if(desc->process)
// err = (desc->process)(&ctx->state.tc_state,data, dataLength );
// CKERR;
//
//done:
return err;
}
C4Err ECC_Verify(ECC_ContextRef pubCtx, void *sig, size_t sigLen, void *hash, size_t hashLen)
{
C4Err err = kC4Err_NoErr;
int status = CRYPT_OK;
int valid = 0;
validateECCContext(pubCtx);
ValidateParam(pubCtx->isInited);
if(pubCtx->isBLCurve)
{
status = ecc_bl_verify_hash(sig, sigLen, hash, hashLen, &valid, &pubCtx->key);
}
else
{
status = ecc_verify_hash(sig, sigLen, hash, hashLen, &valid, &pubCtx->key);
}
if(status != CRYPT_OK)
{
err = sCrypt2C4Err(status); CKERR;
}
if(!valid) err = kC4Err_BadIntegrity;
done:
return err;
}
C4Err C4_GetVersionString(size_t bufSize, char *outString)
{
C4Err err = kC4Err_NoErr;
ValidateParam(outString);
*outString = 0;
char version_string[128];
snprintf(version_string, sizeof(version_string), "%s%s (%03d) %s",
C4_SHORT_VERSION_STRING,
#if _USES_COMMON_CRYPTO_
"CC",
#else
"",
#endif
C4_BUILD_NUMBER,
GIT_COMMIT_HASH);
if(strlen(version_string) +1 > bufSize)
RETERR (kC4Err_BufferTooSmall);
strcpy(outString, version_string);
done:
return err;
}
ESResult InitEasySetup(OCConnectivityType networkType, const char *ssid, const char *passwd,
bool isSecured,
EventCallback cb)
{
OIC_LOG(INFO, ES_ENROLLEE_TAG, "InitEasySetup IN");
if(!ValidateParam(networkType,ssid,passwd,cb))
{
OIC_LOG(ERROR, ES_ENROLLEE_TAG,
"InitEasySetup::Stopping Easy setup due to invalid parameters");
return ES_ERROR;
}
//Init callback
gEnrolleeStatusCb = cb;
gIsSecured = isSecured;
// TODO : This onboarding state has to be set by lower layer, as they better
// knows when actually on-boarding started.
cb(ES_ERROR,ES_ON_BOARDING_STATE);
OIC_LOG(INFO, ES_ENROLLEE_TAG, "received callback");
OIC_LOG(INFO, ES_ENROLLEE_TAG, "onboarding now..");
if(!ESOnboard(ssid, passwd, OnboardingCallback))
{
OIC_LOG(ERROR, ES_ENROLLEE_TAG, "InitEasySetup::On-boarding failed");
cb(ES_ERROR, ES_INIT_STATE);
return ES_ERROR;
}
OIC_LOG(INFO, ES_ENROLLEE_TAG, "InitEasySetup OUT");
return ES_OK;
}
C4Err ECC_CurveName( ECC_ContextRef ctx, void *outData, size_t bufSize, size_t *outDataLen)
{
C4Err err = kC4Err_NoErr;
validateECCContext(ctx);
ValidateParam(ctx->isInited);
ValidateParam(outData);
char* curveName = ctx->key.dp->name;
if(bufSize < strlen(curveName))
RETERR (kC4Err_BufferTooSmall);
strncpy(outData, curveName, bufSize);
if(outDataLen)
*outDataLen = strlen(curveName);
done:
return err;
}
C4Err ECC_KeySize( ECC_ContextRef ctx, size_t * bits)
{
C4Err err = kC4Err_NoErr;
validateECCContext(ctx);
ValidateParam(ctx->isInited);
*bits = ctx->key.dp->size *8;
//done:
return (err);
}
C4Err ECC_PubKeyHash( ECC_ContextRef ctx, void *outData, size_t bufSize, size_t *outDataLen)
{
C4Err err = kC4Err_NoErr;
HASH_ContextRef hash = kInvalidHASH_ContextRef;
uint8_t pubKey[256];
size_t pubKeyLen = 0;
u08b_t hashBuf[16];
size_t hashBytes = 0;
validateECCContext(ctx);
ValidateParam(ctx->isInited);
ValidateParam(outData);
err = HASH_Init(kHASH_Algorithm_SHA256, &hash); CKERR;
err = ECC_Export_ANSI_X963( ctx, pubKey, sizeof(pubKey), &pubKeyLen);CKERR;
err = HASH_Update(hash, pubKey, pubKeyLen) ;CKERR;
err = HASH_Final(hash,hashBuf);
err = HASH_GetSize(hash, &hashBytes);
hashBytes = bufSize < hashBytes ? bufSize :hashBytes;
memcpy( outData,hashBuf, hashBytes);
if(outDataLen)
*outDataLen = hashBytes;
done:
if(HASH_ContextRefIsValid(hash))
HASH_Free(hash);
return err;
}
C4Err ECC_Export_ANSI_X963(ECC_ContextRef ctx, void *outData, size_t bufSize, size_t *datSize)
{
C4Err err = kC4Err_NoErr;
unsigned long length = bufSize;
validateECCContext(ctx);
ValidateParam(ctx->isInited);
err = ecc_ansi_x963_export(&ctx->key, outData, &length); CKERR;
*datSize = length;
done:
return (err);
}
C4Err ECC_Init(ECC_ContextRef * ctx)
{
C4Err err = kC4Err_NoErr;
ECC_Context* eccCTX = kInvalidECC_ContextRef;
ValidateParam(ctx);
eccCTX = XMALLOC(sizeof (ECC_Context)); CKNULL(eccCTX);
eccCTX->magic = kECC_ContextMagic;
CKERR;
*ctx = eccCTX;
done:
return err;
}
C4Err ECC_Export(ECC_ContextRef ctx, int exportPrivate, void *outData, size_t bufSize, size_t *datSize)
{
C4Err err = kC4Err_NoErr;
unsigned long length = bufSize;
int keyType = PK_PUBLIC;
validateECCContext(ctx);
ValidateParam(ctx->isInited);
keyType = exportPrivate?PK_PRIVATE:PK_PUBLIC;
err = ecc_export(outData, &length, keyType, &ctx->key); CKERR;
*datSize = length;
done:
return (err);
}
C4Err ECC_Encrypt(ECC_ContextRef pubCtx, void *inData, size_t inDataLen, void *outData, size_t bufSize, size_t *outDataLen)
{
C4Err err = kC4Err_NoErr;
int status = CRYPT_OK;
unsigned long length = bufSize;
validateECCContext(pubCtx);
ValidateParam(pubCtx->isInited);
if(pubCtx->isBLCurve)
{
status = ecc_bl_encrypt_key(inData, inDataLen, outData, &length,
NULL,
find_prng("sprng"),
find_hash(inDataLen > 32?"sha512":"sha256"),
&pubCtx->key);
}
else
{
status = ecc_encrypt_key(inData, inDataLen, outData, &length,
NULL,
find_prng("sprng"),
find_hash(inDataLen > 32?"sha512":"sha256"),
&pubCtx->key);
};
if(status != CRYPT_OK)
{
err = sCrypt2C4Err(status); CKERR;
}
*outDataLen = length;
done:
return err;
}
SCLError CCM_Encrypt(uint8_t *key, size_t keyLen,
uint8_t *seq, size_t seqLen,
const uint8_t *in, size_t inLen,
uint8_t **outData, size_t *outSize,
uint8_t *outTag, size_t tagSize)
{
SCLError err = kSCLError_NoErr;
int status = CRYPT_OK;
uint8_t bytes2Pad;
uint8_t *buffer = NULL;
size_t buffLen = 0;
int IVlen = keyLen >>1;
unsigned char T[32];
unsigned long tagLen = 0;
unsigned long tag2Copy = tagSize;
ValidateParam (tagSize <= sizeof(T));
/* calclulate Pad byte */
if(inLen < MIN_MSG_BLOCKSIZE)
{
bytes2Pad = MIN_MSG_BLOCKSIZE - inLen;
}
else
{
bytes2Pad = roundup(inLen, MSG_BLOCKSIZE) + MSG_BLOCKSIZE - inLen;
};
buffLen = inLen + bytes2Pad;
buffer = XMALLOC(buffLen);
memcpy(buffer, in, inLen);
memset(buffer+inLen, bytes2Pad, bytes2Pad);
tagLen = sizeof(T);
status = ccm_memory(find_cipher("aes"),
key, IVlen ,
NULL,
key+ IVlen, IVlen,
seq, seqLen,
buffer, buffLen,
buffer,
T, &tagLen ,
CCM_ENCRYPT); CKSTAT;
*outData = buffer;
*outSize = buffLen;
memcpy(outTag, T, tag2Copy);
done:
if(status != CRYPT_OK)
{
if(buffer)
{
memset(buffer, buffLen, 0);
XFREE(buffer);
}
err = sCrypt2SCLError(status);
}
return err;
}
C4Err HASH_Init(HASH_Algorithm algorithm, HASH_ContextRef * ctx)
{
int err = kC4Err_NoErr;
HASH_Context* hashCTX = NULL;
const struct ltc_hash_descriptor* desc = NULL;
ValidateParam(ctx);
*ctx = NULL;
hashCTX = XMALLOC(sizeof (HASH_Context)); CKNULL(hashCTX);
hashCTX->magic = kHASH_ContextMagic;
hashCTX->algor = algorithm;
#if _USES_COMMON_CRYPTO_
switch(algorithm)
{
case kHASH_Algorithm_MD5:
hashCTX->ccAlgor = kCCHmacAlgMD5;
hashCTX->process = (void*) sCCHashUpdateMD5;
hashCTX->done = (void*) sCCHashFinalMD5;
hashCTX->hashsize = 16;
CC_MD5_Init(&hashCTX->state.ccMD5_state);
break;
case kHASH_Algorithm_SHA1:
hashCTX->ccAlgor = kCCHmacAlgSHA1;
hashCTX->hashsize = 20;
hashCTX->process = (void*) sCCHashUpdateSHA1;
hashCTX->done = (void*) sCCHashFinalSHA1;;
CC_SHA1_Init(&hashCTX->state.ccSHA1_state);
break;
case kHASH_Algorithm_SHA224:
hashCTX->ccAlgor = kCCHmacAlgSHA224;
hashCTX->hashsize = 28;
hashCTX->process = (void*) sCCHashUpdateSHA224;
hashCTX->done = (void*) sCCHashFinalSHA224;
CC_SHA224_Init(&hashCTX->state.ccSHA256_state);
break;
case kHASH_Algorithm_SHA256:
hashCTX->ccAlgor = kCCHmacAlgSHA256;
hashCTX->hashsize = 32;
hashCTX->process = (void*) sCCHashUpdateSHA256;
hashCTX->done = (void*) sCCHashFinalSHA256;;
CC_SHA256_Init(&hashCTX->state.ccSHA256_state);
break;
case kHASH_Algorithm_SHA384:
hashCTX->ccAlgor = kCCHmacAlgSHA384;
hashCTX->hashsize = 48;
hashCTX->process = (void*) sCCHashUpdateSHA384;
hashCTX->done = (void*) sCCHashFinalSHA384;
CC_SHA384_Init(&hashCTX->state.ccSHA512_state);
break;
case kHASH_Algorithm_SHA512:
hashCTX->ccAlgor = kCCHmacAlgSHA512;
hashCTX->hashsize = 64;
hashCTX->process = (void*) sCCHashUpdateSHA512;
hashCTX->done = (void*) sCCHashFinalSHA512;
CC_SHA512_Init(&hashCTX->state.ccSHA512_state);
break;
default:
hashCTX->ccAlgor = kCCHmacAlgInvalid;
break;
}
if(hashCTX->ccAlgor == kCCHmacAlgInvalid)
{
desc = sDescriptorForHash(algorithm);
hashCTX->hashsize = desc->hashsize;
hashCTX->process = (void*) desc->process;
hashCTX->done = (void*) desc->done;
if(IsNull(desc))
RETERR( kC4Err_BadHashNumber);
if(desc->init)
err = (desc->init)(&hashCTX->state.tc_state);
CKERR;
}
#else
desc = sDescriptorForHash(algorithm);
hashCTX->hashsize = desc->hashsize;
hashCTX->process = (void*) desc->process;
hashCTX->done = (void*) desc->done;
if(IsNull(desc))
RETERR( kC4Err_BadHashNumber);
if(desc->init)
err = (desc->init)(&hashCTX->state.tc_state);
CKERR;
#endif
*ctx = hashCTX;
done:
if(IsC4Err(err))
{
if(IsntNull(hashCTX))
{
XFREE(hashCTX);
}
}
return err;
}
ResizeImageTransformer<Dtype>::ResizeImageTransformer(const ResizeTransformParameter& resize_param) :
ImageTransformer<Dtype>(), param_(resize_param) {
ValidateParam();
}
ModeAction ListModeBase::OnModeChange(User* source, User*, Channel* channel, std::string ¶meter, bool adding)
{
// Try and grab the list
ChanData* cd = extItem.get(channel);
if (adding)
{
if (tidy)
ModeParser::CleanMask(parameter);
if (parameter.length() > 250)
return MODEACTION_DENY;
// If there was no list
if (!cd)
{
// Make one
cd = new ChanData;
extItem.set(channel, cd);
}
// Check if the item already exists in the list
for (ModeList::iterator it = cd->list.begin(); it != cd->list.end(); it++)
{
if (parameter == it->mask)
{
/* Give a subclass a chance to error about this */
TellAlreadyOnList(source, channel, parameter);
// it does, deny the change
return MODEACTION_DENY;
}
}
if ((IS_LOCAL(source)) && (cd->list.size() >= GetLimitInternal(channel->name, cd)))
{
/* List is full, give subclass a chance to send a custom message */
TellListTooLong(source, channel, parameter);
return MODEACTION_DENY;
}
/* Ok, it *could* be allowed, now give someone subclassing us
* a chance to validate the parameter.
* The param is passed by reference, so they can both modify it
* and tell us if we allow it or not.
*
* eg, the subclass could:
* 1) allow
* 2) 'fix' parameter and then allow
* 3) deny
*/
if (ValidateParam(source, channel, parameter))
{
// And now add the mask onto the list...
cd->list.push_back(ListItem(parameter, source->nick, ServerInstance->Time()));
return MODEACTION_ALLOW;
}
else
{
/* If they deny it they have the job of giving an error message */
return MODEACTION_DENY;
}
}
else
{
// We're taking the mode off
if (cd)
{
for (ModeList::iterator it = cd->list.begin(); it != cd->list.end(); ++it)
{
if (parameter == it->mask)
{
cd->list.erase(it);
return MODEACTION_ALLOW;
}
}
}
/* Tried to remove something that wasn't set */
TellNotSet(source, channel, parameter);
return MODEACTION_DENY;
}
}
C4Err CBC_Init(Cipher_Algorithm algorithm,
const void *key,
const void *iv,
CBC_ContextRef * ctxOut)
{
int err = kC4Err_NoErr;
CBC_Context* cbcCTX = NULL;
int keylen = 0;
int cipher = -1;
int status = CRYPT_OK;
ValidateParam(ctxOut);
switch(algorithm)
{
case kCipher_Algorithm_AES128:
keylen = 128 >> 3;
cipher = find_cipher("aes");
break;
case kCipher_Algorithm_AES192:
keylen = 192 >> 3;
cipher = find_cipher("aes");
break;
case kCipher_Algorithm_AES256:
keylen = 256 >> 3;
cipher = find_cipher("aes");
break;
case kCipher_Algorithm_2FISH256:
keylen = 256 >> 3;
cipher = find_cipher("twofish");
break;
default:
RETERR(kC4Err_BadCipherNumber);
}
cbcCTX = XMALLOC(sizeof (CBC_Context)); CKNULL(cbcCTX);
cbcCTX->magic = kCBC_ContextMagic;
cbcCTX->algor = algorithm;
status = cbc_start(cipher, iv, key, keylen, 0, &cbcCTX->state); CKSTAT;
*ctxOut = cbcCTX;
done:
if(status != CRYPT_OK)
{
if(cbcCTX)
{
memset(cbcCTX, sizeof (CBC_Context), 0);
XFREE(cbcCTX);
}
err = sCrypt2C4Err(status);
}
return err;
}
C4Err CBC_EncryptPAD(Cipher_Algorithm algorithm,
uint8_t *key, size_t key_len,
const uint8_t *iv,
const uint8_t *in, size_t in_len,
uint8_t **outData, size_t *outSize)
{
C4Err err = kC4Err_NoErr;
CBC_ContextRef cbc = kInvalidCBC_ContextRef;
uint8_t bytes2Pad;
uint8_t *buffer = NULL;
size_t buffLen = 0;
/* check Key length and algorithm */
switch(algorithm)
{
case kCipher_Algorithm_AES128:
ValidateParam (key_len == 16); break;
case kCipher_Algorithm_AES192:
ValidateParam (key_len == 24); break;
case kCipher_Algorithm_AES256:
ValidateParam (key_len == 32); break;
case kCipher_Algorithm_2FISH256:
ValidateParam (key_len == 32); break;
default:
RETERR(kC4Err_BadParams);
}
/* calclulate Pad byte */
if(in_len < MIN_MSG_BLOCKSIZE)
{
bytes2Pad = MIN_MSG_BLOCKSIZE - in_len;
}
else
{
bytes2Pad = roundup(in_len, MSG_BLOCKSIZE) + MSG_BLOCKSIZE - in_len;
};
buffLen = in_len + bytes2Pad;
buffer = XMALLOC(buffLen);
memcpy(buffer, in, in_len);
memset(buffer+in_len, bytes2Pad, bytes2Pad);
err = CBC_Init(algorithm, key, iv, &cbc);CKERR;
err = CBC_Encrypt(cbc, buffer, buffLen, buffer); CKERR;
*outData = buffer;
*outSize = buffLen;
done:
if(IsC4Err(err))
{
if(buffer)
{
memset(buffer, buffLen, 0);
XFREE(buffer);
}
}
CBC_Free(cbc);
return err;
}
C4Err CBC_DecryptPAD(Cipher_Algorithm algorithm,
uint8_t *key, size_t key_len,
const uint8_t *iv,
const uint8_t *in, size_t in_len,
uint8_t **outData, size_t *outSize)
{
C4Err err = kC4Err_NoErr;
CBC_ContextRef cbc = kInvalidCBC_ContextRef;
uint8_t *buffer = NULL;
size_t buffLen = in_len;
uint8_t bytes2Pad = 0;
/* check Key length and algorithm */
switch(algorithm)
{
case kCipher_Algorithm_AES128:
ValidateParam (key_len == 16); break;
case kCipher_Algorithm_AES192:
ValidateParam (key_len == 24); break;
case kCipher_Algorithm_AES256:
ValidateParam (key_len == 32); break;
case kCipher_Algorithm_2FISH256:
ValidateParam (key_len == 32); break;
default:
RETERR(kC4Err_BadParams);
}
buffer = XMALLOC(buffLen);
err = CBC_Init(algorithm, key, iv, &cbc);CKERR;
err = CBC_Decrypt(cbc, in, buffLen, buffer); CKERR;
bytes2Pad = *(buffer+buffLen-1);
if(bytes2Pad > buffLen)
RETERR(kC4Err_CorruptData);
*outData = buffer;
*outSize = buffLen- bytes2Pad;
done:
if(IsC4Err(err))
{
if(buffer)
{
memset(buffer, buffLen, 0);
XFREE(buffer);
}
}
CBC_Free(cbc);
return err;
}
