Skip to content

Commit 5b74804

Browse files
JacobBarthelmehJacobBarthelmeh
authored
Merge pull request #9487 from dgarske/qathash
Fix QAT hash final with no update and fix g++ warnings
2 parents f01c4f1 + 628c1e5 commit 5b74804

1 file changed

Lines changed: 61 additions & 45 deletions

File tree

‎wolfcrypt/src/port/intel/quickassist.c‎

Lines changed: 61 additions & 45 deletions
Original file line numberDiff line numberDiff line change
@@ -473,11 +473,11 @@ int IntelQaHardwareStart(const char* process_name, int limitDevAccess)
473473
}
474474

475475
#if defined(HAVE_ECC) && defined(HAVE_ECC_DHE)
476-
g_qatEcdhY = XMALLOC(MAX_ECC_BYTES, NULL, DYNAMIC_TYPE_ASYNC_NUMA);
476+
g_qatEcdhY = (Cpa8U*)XMALLOC(MAX_ECC_BYTES, NULL, DYNAMIC_TYPE_ASYNC_NUMA);
477477
if (g_qatEcdhY == NULL) {
478478
ret = MEMORY_E; goto error;
479479
}
480-
g_qatEcdhCofactor1 = XMALLOC(MAX_ECC_BYTES, NULL, DYNAMIC_TYPE_ASYNC_NUMA);
480+
g_qatEcdhCofactor1 = (Cpa8U*)XMALLOC(MAX_ECC_BYTES, NULL, DYNAMIC_TYPE_ASYNC_NUMA);
481481
if (g_qatEcdhCofactor1 == NULL) {
482482
ret = MEMORY_E; goto error;
483483
}
@@ -731,7 +731,7 @@ int IntelQaDevCopy(WC_ASYNC_DEV* src, WC_ASYNC_DEV* dst)
731731
if (isHash) {
732732
/* need to duplicate tmpIn */
733733
if (src->qat.op.hash.tmpIn) {
734-
dst->qat.op.hash.tmpIn = XMALLOC(src->qat.op.hash.tmpInBufSz,
734+
dst->qat.op.hash.tmpIn = (byte*)XMALLOC(src->qat.op.hash.tmpInBufSz,
735735
src->heap, DYNAMIC_TYPE_ASYNC_NUMA);
736736
if (dst->qat.op.hash.tmpIn == NULL) {
737737
return MEMORY_E;
@@ -1431,7 +1431,7 @@ int IntelQaRsaKeyGen(WC_ASYNC_DEV* dev, RsaKey* key, int keyBits, long e,
14311431
privateKey,
14321432
publicKey);
14331433
} while (IntelQaHandleCpaStatus(dev, status, &ret, 0,
1434-
callback, &retryCount));
1434+
(void*)callback, &retryCount));
14351435

14361436
exit:
14371437

@@ -1562,11 +1562,11 @@ int IntelQaRsaPrivate(WC_ASYNC_DEV* dev,
15621562
}
15631563

15641564
opData->inputData.dataLenInBytes = inLen;
1565-
opData->inputData.pData = XREALLOC((byte*)in, inLen, dev->heap,
1565+
opData->inputData.pData = (Cpa8U*)XREALLOC((byte*)in, inLen, dev->heap,
15661566
DYNAMIC_TYPE_ASYNC_NUMA);
15671567

15681568
outBuf->dataLenInBytes = *outLen;
1569-
outBuf->pData = XREALLOC(out, *outLen, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
1569+
outBuf->pData = (Cpa8U*)XREALLOC(out, *outLen, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
15701570

15711571
/* check allocations */
15721572
if (opData->inputData.pData == NULL || outBuf->pData == NULL) {
@@ -1592,8 +1592,8 @@ int IntelQaRsaPrivate(WC_ASYNC_DEV* dev,
15921592
dev,
15931593
opData,
15941594
outBuf);
1595-
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_RSA_ASYNC, callback,
1596-
&retryCount));
1595+
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_RSA_ASYNC,
1596+
(void*)callback, &retryCount));
15971597

15981598
if (ret == WC_PENDING_E)
15991599
return ret;
@@ -1667,11 +1667,11 @@ int IntelQaRsaCrtPrivate(WC_ASYNC_DEV* dev,
16671667
*outLen = inLen;
16681668

16691669
opData->inputData.dataLenInBytes = inLen;
1670-
opData->inputData.pData = XREALLOC((byte*)in, inLen, dev->heap,
1670+
opData->inputData.pData = (Cpa8U*)XREALLOC((byte*)in, inLen, dev->heap,
16711671
DYNAMIC_TYPE_ASYNC_NUMA);
16721672

16731673
outBuf->dataLenInBytes = *outLen;
1674-
outBuf->pData = XREALLOC(out, *outLen, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
1674+
outBuf->pData = (Cpa8U*)XREALLOC(out, *outLen, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
16751675

16761676
/* check allocations */
16771677
if (opData->inputData.pData == NULL || outBuf->pData == NULL) {
@@ -1697,8 +1697,8 @@ int IntelQaRsaCrtPrivate(WC_ASYNC_DEV* dev,
16971697
dev,
16981698
opData,
16991699
outBuf);
1700-
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_RSA_ASYNC, callback,
1701-
&retryCount));
1700+
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_RSA_ASYNC,
1701+
(void*)callback, &retryCount));
17021702

17031703
if (ret == WC_PENDING_E)
17041704
return ret;
@@ -1823,11 +1823,11 @@ int IntelQaRsaPublic(WC_ASYNC_DEV* dev,
18231823
*outLen = n->len;
18241824

18251825
opData->inputData.dataLenInBytes = inLen;
1826-
opData->inputData.pData = XREALLOC((byte*)in, inLen, dev->heap,
1826+
opData->inputData.pData = (Cpa8U*)XREALLOC((byte*)in, inLen, dev->heap,
18271827
DYNAMIC_TYPE_ASYNC_NUMA);
18281828

18291829
outBuf->dataLenInBytes = *outLen;
1830-
outBuf->pData = XREALLOC(out, *outLen, dev->heap,
1830+
outBuf->pData = (Cpa8U*)XREALLOC(out, *outLen, dev->heap,
18311831
DYNAMIC_TYPE_ASYNC_NUMA64);
18321832

18331833
/* check allocations */
@@ -1850,8 +1850,8 @@ int IntelQaRsaPublic(WC_ASYNC_DEV* dev,
18501850
dev,
18511851
opData,
18521852
outBuf);
1853-
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_RSA_ASYNC, callback,
1854-
&retryCount));
1853+
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_RSA_ASYNC,
1854+
(void*)callback, &retryCount));
18551855

18561856
if (ret == WC_PENDING_E)
18571857
return ret;
@@ -1963,11 +1963,12 @@ int IntelQaRsaExptMod(WC_ASYNC_DEV* dev,
19631963
}
19641964

19651965
opData->base.dataLenInBytes = inLen;
1966-
opData->base.pData = XREALLOC((byte*)in, inLen, dev->heap,
1966+
opData->base.pData = (Cpa8U*)XREALLOC((byte*)in, inLen, dev->heap,
19671967
DYNAMIC_TYPE_ASYNC_NUMA);
19681968

19691969
target->dataLenInBytes = *outLen;
1970-
target->pData = XREALLOC(out, *outLen, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
1970+
target->pData = (Cpa8U*)XREALLOC(out, *outLen, dev->heap,
1971+
DYNAMIC_TYPE_ASYNC_NUMA);
19711972

19721973
/* check allocations */
19731974
if (opData->base.pData == NULL || target->pData == NULL) {
@@ -1987,7 +1988,7 @@ int IntelQaRsaExptMod(WC_ASYNC_DEV* dev,
19871988
opData,
19881989
target);
19891990
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_EXPTMOD_ASYNC,
1990-
callback, &retryCount));
1991+
(void*)callback, &retryCount));
19911992

19921993
if (ret == WC_PENDING_E)
19931994
return ret;
@@ -2336,9 +2337,10 @@ static int IntelQaSymCipher(WC_ASYNC_DEV* dev, byte* out, const byte* in,
23362337
opData = &ctx->opData;
23372338
bufferList = &dev->qat.op.cipher.bufferList;
23382339
flatBuffer = &dev->qat.op.cipher.flatBuffer;
2339-
metaBuf = XMALLOC(metaSize, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
2340-
dataBuf = XREALLOC((byte*)in, dataLen, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
2341-
ivBuf = XREALLOC((byte*)iv, AES_BLOCK_SIZE, dev->heap,
2340+
metaBuf = (Cpa8U*)XMALLOC(metaSize, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
2341+
dataBuf = (Cpa8U*)XREALLOC((byte*)in, dataLen, dev->heap,
2342+
DYNAMIC_TYPE_ASYNC_NUMA);
2343+
ivBuf = (Cpa8U*)XREALLOC((byte*)iv, AES_BLOCK_SIZE, dev->heap,
23422344
DYNAMIC_TYPE_ASYNC_NUMA);
23432345

23442346
/* check allocations */
@@ -2354,7 +2356,7 @@ static int IntelQaSymCipher(WC_ASYNC_DEV* dev, byte* out, const byte* in,
23542356
(authInSzAligned % AES_BLOCK_SIZE);
23552357
}
23562358

2357-
authInBuf = XREALLOC((byte*)authIn, authInSzAligned, dev->heap,
2359+
authInBuf = (Cpa8U*)XREALLOC((byte*)authIn, authInSzAligned, dev->heap,
23582360
DYNAMIC_TYPE_ASYNC_NUMA);
23592361
if (authInBuf == NULL) {
23602362
ret = MEMORY_E; goto exit;
@@ -2459,7 +2461,7 @@ static int IntelQaSymCipher(WC_ASYNC_DEV* dev, byte* out, const byte* in,
24592461
bufferList,
24602462
NULL);
24612463
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_CIPHER_ASYNC,
2462-
callback, &retryCount));
2464+
(void*)callback, &retryCount));
24632465

24642466
if (ret == WC_PENDING_E)
24652467
return ret;
@@ -2832,6 +2834,16 @@ static int IntelQaSymHashCache(WC_ASYNC_DEV* dev, byte* out, const byte* in,
28322834
ret = 0; /* success */
28332835
goto exit;
28342836
}
2837+
else if (out != NULL && dev->qat.op.hash.tmpIn == NULL) {
2838+
/* QAT requires an input buffer even for an empty hash */
2839+
dev->qat.op.hash.tmpInSz = 0;
2840+
dev->qat.op.hash.tmpInBufSz = 16; /* use minimum alignment (16 bytes) */
2841+
dev->qat.op.hash.tmpIn = (byte*)XMALLOC(dev->qat.op.hash.tmpInBufSz,
2842+
dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
2843+
if (dev->qat.op.hash.tmpIn == NULL) {
2844+
ret = MEMORY_E; goto exit;
2845+
}
2846+
}
28352847

28362848
/* handle output processing */
28372849
packetType = CPA_CY_SYM_PACKET_TYPE_FULL;
@@ -2846,7 +2858,8 @@ static int IntelQaSymHashCache(WC_ASYNC_DEV* dev, byte* out, const byte* in,
28462858
/* allocate buffer list */
28472859
bufferListSize = sizeof(CpaBufferList) +
28482860
(bufferCount * sizeof(CpaFlatBuffer)) + metaSize;
2849-
srcList = XMALLOC(bufferListSize, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
2861+
srcList = (CpaBufferList*)XMALLOC(bufferListSize, dev->heap,
2862+
DYNAMIC_TYPE_ASYNC_NUMA);
28502863
if (srcList == NULL) {
28512864
ret = MEMORY_E; goto exit;
28522865
}
@@ -2869,7 +2882,8 @@ static int IntelQaSymHashCache(WC_ASYNC_DEV* dev, byte* out, const byte* in,
28692882
/* build output */
28702883
if (out) {
28712884
/* use blockSize for alloc, but we are only returning digestSize */
2872-
digestBuf = XMALLOC(blockSize, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
2885+
digestBuf = (Cpa8U*)XMALLOC(blockSize, dev->heap,
2886+
DYNAMIC_TYPE_ASYNC_NUMA);
28732887
if (digestBuf == NULL) {
28742888
ret = MEMORY_E; goto exit;
28752889
}
@@ -2914,8 +2928,8 @@ static int IntelQaSymHashCache(WC_ASYNC_DEV* dev, byte* out, const byte* in,
29142928
srcList,
29152929
srcList,
29162930
NULL);
2917-
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_HASH_ASYNC, callback,
2918-
&retryCount));
2931+
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_HASH_ASYNC,
2932+
(void*)callback, &retryCount));
29192933

29202934
if (ret == WC_PENDING_E)
29212935
return ret;
@@ -3438,7 +3452,7 @@ int IntelQaSymSha3(WC_ASYNC_DEV* dev, byte* out, const byte* in, word32 sz)
34383452
int ret;
34393453
CpaCySymHashAlgorithm hashAlgorithm;
34403454

3441-
ret = IntelQaHmacGetType(macType, &hashAlgorithm);
3455+
ret = IntelQaHmacGetType(macType, (word32*)&hashAlgorithm);
34423456
if (ret != 0)
34433457
return ret;
34443458

@@ -3615,7 +3629,7 @@ int IntelQaEccPointMul(WC_ASYNC_DEV* dev, WC_BIGINT* k,
36153629
pXk,
36163630
pYk);
36173631
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_ECMUL_ASYNC,
3618-
callback, &retryCount));
3632+
(void*)callback, &retryCount));
36193633

36203634
if (ret == WC_PENDING_E)
36213635
return ret;
@@ -3777,7 +3791,7 @@ int IntelQaEcdh(WC_ASYNC_DEV* dev, WC_BIGINT* k, WC_BIGINT* xG,
37773791
(void)cofactor;
37783792

37793793
pXk->dataLenInBytes = q->len; /* bytes key size / 8 (aligned) */
3780-
pXk->pData = XREALLOC(out, pXk->dataLenInBytes, dev->heap,
3794+
pXk->pData = (Cpa8U*)XREALLOC(out, pXk->dataLenInBytes, dev->heap,
37813795
DYNAMIC_TYPE_ASYNC_NUMA);
37823796
pYk->dataLenInBytes = q->len;
37833797
pYk->pData = g_qatEcdhY;
@@ -3797,7 +3811,7 @@ int IntelQaEcdh(WC_ASYNC_DEV* dev, WC_BIGINT* k, WC_BIGINT* xG,
37973811
pXk,
37983812
pYk);
37993813
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_ECDHE_ASYNC,
3800-
callback, &retryCount));
3814+
(void*)callback, &retryCount));
38013815

38023816
if (ret == WC_PENDING_E)
38033817
return ret;
@@ -3935,9 +3949,9 @@ int IntelQaEcdsaSign(WC_ASYNC_DEV* dev,
39353949

39363950
pR->dataLenInBytes = n->len; /* bytes key size / 8 (aligned) */
39373951
pS->dataLenInBytes = n->len;
3938-
pR->pData = XREALLOC(r->buf, pR->dataLenInBytes, dev->heap,
3952+
pR->pData = (Cpa8U*)XREALLOC(r->buf, pR->dataLenInBytes, dev->heap,
39393953
DYNAMIC_TYPE_ASYNC_NUMA);
3940-
pS->pData = XREALLOC(s->buf, pS->dataLenInBytes, dev->heap,
3954+
pS->pData = (Cpa8U*)XREALLOC(s->buf, pS->dataLenInBytes, dev->heap,
39413955
DYNAMIC_TYPE_ASYNC_NUMA);
39423956

39433957
if (pR->pData == NULL || pS->pData == NULL) {
@@ -3959,7 +3973,7 @@ int IntelQaEcdsaSign(WC_ASYNC_DEV* dev,
39593973
pR,
39603974
pS);
39613975
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_ECDSA_ASYNC,
3962-
callback, &retryCount));
3976+
(void*)callback, &retryCount));
39633977

39643978
if (ret == WC_PENDING_E)
39653979
return ret;
@@ -4084,7 +4098,7 @@ int IntelQaEcdsaVerify(WC_ASYNC_DEV* dev, WC_BIGINT* m,
40844098
opData,
40854099
verifyStatus);
40864100
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_ECDSA_ASYNC,
4087-
callback, &retryCount));
4101+
(void*)callback, &retryCount));
40884102

40894103
if (ret == WC_PENDING_E)
40904104
return ret;
@@ -4205,7 +4219,8 @@ int IntelQaDhKeyGen(WC_ASYNC_DEV* dev, WC_BIGINT* p, WC_BIGINT* g,
42054219
ret = BAD_FUNC_ARG; goto exit;
42064220
}
42074221
pOut->dataLenInBytes = p->len;
4208-
pOut->pData = XREALLOC(pub, p->len, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
4222+
pOut->pData = (Cpa8U*)XREALLOC(pub, p->len, dev->heap,
4223+
DYNAMIC_TYPE_ASYNC_NUMA);
42094224
if (pOut->pData == NULL) {
42104225
ret = MEMORY_E; goto exit;
42114226
}
@@ -4223,8 +4238,8 @@ int IntelQaDhKeyGen(WC_ASYNC_DEV* dev, WC_BIGINT* p, WC_BIGINT* g,
42234238
dev,
42244239
opData,
42254240
pOut);
4226-
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_DH_ASYNC, callback,
4227-
&retryCount));
4241+
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_DH_ASYNC,
4242+
(void*)callback, &retryCount));
42284243

42294244
if (ret == WC_PENDING_E)
42304245
return ret;
@@ -4356,13 +4371,14 @@ int IntelQaDhAgree(WC_ASYNC_DEV* dev, WC_BIGINT* p,
43564371
}
43574372

43584373
opData->remoteOctetStringPV.dataLenInBytes = pubSz;
4359-
opData->remoteOctetStringPV.pData = XREALLOC((byte*)otherPub, pubSz,
4374+
opData->remoteOctetStringPV.pData = (Cpa8U*)XREALLOC((byte*)otherPub, pubSz,
43604375
dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
43614376
opData->privateValueX.dataLenInBytes = privSz;
4362-
opData->privateValueX.pData = XREALLOC((byte*)priv, privSz, dev->heap,
4363-
DYNAMIC_TYPE_ASYNC_NUMA);
4377+
opData->privateValueX.pData = (Cpa8U*)XREALLOC((byte*)priv, privSz,
4378+
dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
43644379
pOut->dataLenInBytes = p->len;
4365-
pOut->pData = XREALLOC(agree, p->len, dev->heap, DYNAMIC_TYPE_ASYNC_NUMA);
4380+
pOut->pData = (Cpa8U*)XREALLOC(agree, p->len, dev->heap,
4381+
DYNAMIC_TYPE_ASYNC_NUMA);
43664382

43674383
if (opData->remoteOctetStringPV.pData == NULL ||
43684384
opData->privateValueX.pData == NULL || pOut->pData == NULL) {
@@ -4381,8 +4397,8 @@ int IntelQaDhAgree(WC_ASYNC_DEV* dev, WC_BIGINT* p,
43814397
dev,
43824398
opData,
43834399
pOut);
4384-
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_DH_ASYNC, callback,
4385-
&retryCount));
4400+
} while (IntelQaHandleCpaStatus(dev, status, &ret, QAT_DH_ASYNC,
4401+
(void*)callback, &retryCount));
43864402

43874403
if (ret == WC_PENDING_E)
43884404
return ret;

0 commit comments

Comments
 (0)