void MD5(sLONG_PTR *pResult, PackagePtr pParams)
{
C_BLOB Param1;
C_LONGINT Param2;
C_TEXT returnValue;
Param1.fromParamAtIndex(pParams, 1);
Param2.fromParamAtIndex(pParams, 2);
uint8_t *buf = (uint8_t *)calloc(16, sizeof(uint8_t));
CC_MD5((unsigned char *)Param1.getBytesPtr(), Param1.getBytesLength(), buf);
C_BLOB temp;
temp.setBytes((const uint8_t *)buf, 16);
switch (Param2.getIntValue())
{
case 1:
temp.toB64Text(&returnValue);
break;
default:
temp.toHexText(&returnValue);
break;
}
free(buf);
returnValue.setReturn(pResult);
}
HashResult MD5CommonCryptoImpl::Calculate(const Aws::String& str)
{
ByteBuffer hash(CC_MD5_DIGEST_LENGTH);
CC_MD5(str.c_str(), static_cast<CC_LONG>(str.length()), hash.GetUnderlyingData());
return HashResult(std::move(hash));
}
CertDataRef createCertDataFromCertificate(SecCertificateRef certificate)
{
CertDataRef pCertData = (CertDataRef)malloc(sizeof(CertData));
pCertData->subject = GetFieldsFromCertificate(certificate, kSecOIDX509V1SubjectName);
pCertData->issuer = GetFieldsFromCertificate(certificate, kSecOIDX509V1IssuerName);
CFDataRef data = SecCertificateCopyData(certificate);
if (data == NULL)
{
warnx("SecCertificateCopyData() returned NULL");
destroyCertData(pCertData);
return NULL;
}
unsigned char sha1[CC_SHA1_DIGEST_LENGTH];
CC_SHA1(CFDataGetBytePtr(data), CFDataGetLength(data), sha1);
pCertData->sha1 = createHexString(sha1, CC_SHA1_DIGEST_LENGTH);
unsigned char md5[CC_MD5_DIGEST_LENGTH];
CC_MD5(CFDataGetBytePtr(data), CFDataGetLength(data), md5);
pCertData->md5 = createHexString((unsigned char*)md5, CC_MD5_DIGEST_LENGTH);
CFDataRef serial = SecCertificateCopySerialNumber(certificate, NULL);
pCertData->serial = createHexString((unsigned char *)CFDataGetBytePtr(serial), CFDataGetLength(serial));
CFRelease(serial);
return pCertData;
}
void Curl_darwinssl_md5sum(unsigned char *tmp, /* input */
size_t tmplen,
unsigned char *md5sum, /* output */
size_t md5len)
{
(void)md5len;
(void)CC_MD5(tmp, tmplen, md5sum);
}
HRESULT CStunMessageBuilder::AddMessageIntegrityLongTerm(const char* pszUserName, const char* pszRealm, const char* pszPassword)
{
HRESULT hr = S_OK;
const size_t MAX_KEY_SIZE = MAX_STUN_AUTH_STRING_SIZE*3 + 2;
uint8_t key[MAX_KEY_SIZE + 1]; // long enough for 64-char strings and two semicolons and a null char for debugging
uint8_t hash[MD5_DIGEST_LENGTH] = {};
uint8_t* pResult = NULL;
uint8_t* pDst = key;
size_t lenUserName = pszUserName ? strlen(pszUserName) : 0;
size_t lenRealm = pszRealm ? strlen(pszRealm) : 0;
size_t lenPassword = pszPassword ? strlen(pszPassword) : 0;
size_t lenTotal = lenUserName + lenRealm + lenPassword + 2; // +2 for the two colons
UNREFERENCED_VARIABLE(pResult);
ChkIfA(lenTotal > MAX_KEY_SIZE, E_INVALIDARG); // if we ever hit this limit, just increase MAX_STUN_AUTH_STRING_SIZE
// too bad CDatastream really only works on refcounted buffers. Otherwise, we wouldn't have to do all this messed up pointer math
// We could create a refcounted buffer in this function, but that would mean a call to "new and delete", and we're trying to avoid memory allocations in
// critical code paths because they are a proven perf hit
// TODO - Fix CDataStream and CBuffer so that "ref counted buffers" are no longer needed
pDst = key;
memcpy(pDst, pszUserName, lenUserName);
pDst += lenUserName;
*pDst = ':';
pDst++;
memcpy(pDst, pszRealm, lenRealm);
pDst += lenRealm;
*pDst = ':';
pDst++;
memcpy(pDst, pszPassword, lenPassword);
pDst += lenPassword;
*pDst ='\0'; // null terminate for debugging (this char doesn not get hashed
ASSERT((pDst-key) == lenTotal);
#ifndef __APPLE__
pResult = MD5(key, lenTotal, hash);
#else
pResult = CC_MD5(key, lenTotal, hash);
#endif
ASSERT(pResult != NULL);
hr= AddMessageIntegrityImpl(hash, MD5_DIGEST_LENGTH);
Cleanup:
return hr;
}
void get_table(const char* key) {
unsigned char *table = encrypt_table;
unsigned char tmp_hash[16];
// tmp_hash = MD5((const unsigned char*)key, strlen(key), NULL);
CC_MD5(key, strlen(key), tmp_hash);
_a = *(unsigned long long *)tmp_hash;
_a = *(uint64_t *)tmp_hash;
uint32_t i;
for(i = 0; i < 256; ++i) {
table[i] = i;
}
for(i = 1; i < 1024; ++i) {
_i = i;
merge_sort(table, 256);
}
for(i = 0; i < 256; ++i) {
// gen decrypt table from encrypt table
decrypt_table[encrypt_table[i]] = i;
}
}
void
NTSessionKey16(const uint8_t * password, uint32_t password_len,
const uint8_t client_challenge[MSCHAP_NT_CHALLENGE_SIZE],
const uint8_t server_response[MSCHAP_NT_RESPONSE_SIZE],
const uint8_t server_challenge[MSCHAP_NT_CHALLENGE_SIZE],
uint8_t key[NT_SESSION_KEY_SIZE])
{
uint8_t input[HASH_INPUT_SIZE];
int offset;
uint8_t unicode_password[NT_MAXPWLEN * 2];
/* add hash of the hash of the unicode password */
offset = 0;
password_len = password_to_unicode(password, password_len, unicode_password);
NTPasswordHashHash(unicode_password, password_len, input);
offset += NT_PASSWORD_HASH_SIZE;
/* add the client challenge */
bcopy(client_challenge, input + offset, MSCHAP_NT_CHALLENGE_SIZE);
offset += MSCHAP_NT_CHALLENGE_SIZE;
/* add the server response */
bcopy(server_response, input + offset, MSCHAP_NT_RESPONSE_SIZE);
offset += MSCHAP_NT_RESPONSE_SIZE;
/* add the server challenge */
bcopy(server_challenge, input + offset, MSCHAP_NT_CHALLENGE_SIZE);
offset += MSCHAP_NT_CHALLENGE_SIZE;
/* compute the client response */
NTChallengeResponse(server_challenge, unicode_password,
password_len, input + offset);
CC_MD5(input, HASH_INPUT_SIZE, key);
return;
}
void px_security_md5_to_buffer(const void *data, size_t length, unsigned char *buffer)
{
CC_MD5(data, (unsigned int)length, buffer);
}
C4Err HASH_DO(HASH_Algorithm algorithm, const unsigned char *in, unsigned long inlen, unsigned long outLen, uint8_t *out)
{
C4Err err = kC4Err_NoErr;
HASH_ContextRef hashRef = kInvalidHASH_ContextRef;
uint8_t hashBuf[128];
uint8_t *p = (outLen < sizeof(hashBuf))?hashBuf:out;
#if _USES_COMMON_CRYPTO_
/* use apple algorithms if possible*/
switch(algorithm)
{
case kHASH_Algorithm_MD5:
CC_MD5(in, (CC_LONG) inlen, hashBuf);
goto complete;
break;
case kHASH_Algorithm_SHA1:
CC_SHA1(in, (CC_LONG) inlen, hashBuf);
goto complete;
break;
case kHASH_Algorithm_SHA224:
CC_SHA224(in, (CC_LONG) inlen, hashBuf);
goto complete;
break;
case kHASH_Algorithm_SHA256:
CC_SHA256(in, (CC_LONG) inlen, hashBuf);
goto complete;
break;
case kHASH_Algorithm_SHA384:
CC_SHA384(in, (CC_LONG) inlen, hashBuf);
goto complete;
break;
case kHASH_Algorithm_SHA512:
CC_SHA512(in, (CC_LONG) inlen, hashBuf);
goto complete;
break;
default:
break;
}
#endif
err = HASH_Init( algorithm, & hashRef); CKERR;
err = HASH_Update( hashRef, in, inlen); CKERR;
err = HASH_Final( hashRef, p); CKERR;
complete:
if((err == kC4Err_NoErr) & (p!= out))
COPY(hashBuf, out, outLen);
done:
if(!IsNull(hashRef))
HASH_Free(hashRef);
return err;
}
CFDataRef WebApiClientMD5DigestCreateWithData(CFDataRef data) {
unsigned char result[CC_MD5_DIGEST_LENGTH];
CC_MD5(CFDataGetBytePtr(data), (CC_LONG)CFDataGetLength(data), result);
return CFDataCreate(kCFAllocatorDefault, result, CC_MD5_DIGEST_LENGTH);
}
