| /*############################################################################ |
| # Copyright 1999-2018 Intel Corporation |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| ############################################################################*/ |
| |
| /* |
| // Intel(R) Performance Primitives. Cryptography Primitives. |
| // Operations over GF(p). |
| // |
| // Context: |
| // ippsGFpGetSize() |
| // ippsGFpInitArbitrary() |
| // ippsGFpInitFixed() |
| // ippsGFpInit() |
| // |
| // ippsGFpElementGetSize() |
| // ippsGFpElementInit() |
| // |
| // ippsGFpSetElement() |
| // ippsGFpSetElementRegular() |
| // ippsGFpSetElementOctString() |
| // ippsGFpSetElementRandom() |
| // ippsGFpSetElementHash() |
| // ippsGFpSetElementHash_rmf |
| // ippsGFpCpyElement() |
| // ippsGFpGetElement() |
| // ippsGFpGetElementOctString() |
| // |
| // ippsGFpCmpElement() |
| // ippsGFpIsZeroElement() |
| // ippsGFpIsUnityElement() |
| // |
| // ippsGFpSetPolyTerm() |
| // ippsGFpGetPolyTerm() |
| // |
| // ippsGFpConj() |
| // ippsGFpNeg() |
| // ippsGFpInv() |
| // ippsGFpSqrt() |
| // ippsGFpAdd() |
| // ippsGFpSub() |
| // ippsGFpMul() |
| // ippsGFpSqr() |
| // ippsGFpExp() |
| // ippsGFpMultiExp() |
| // |
| // ippsGFpAdd_GFpE() |
| // ippsGFpSub_GFpE() |
| // ippsGFpMul_GFpE() |
| // |
| // |
| */ |
| #include "owndefs.h" |
| #include "owncp.h" |
| |
| #include "pcpgfpstuff.h" |
| #include "pcpgfpxstuff.h" |
| #include "pcphash.h" |
| #include "pcphash_rmf.h" |
| #include "pcptool.h" |
| |
| //gres: temporary excluded: #include <assert.h> |
| |
| |
| /* |
| // size of GFp engine context (Montgomery) |
| */ |
| int cpGFpGetSize(int feBitSize, int peBitSize, int numpe) |
| { |
| int ctxSize = 0; |
| int elemLen = BITS_BNU_CHUNK(feBitSize); |
| int pelmLen = BITS_BNU_CHUNK(peBitSize); |
| |
| /* size of GFp engine */ |
| ctxSize = sizeof(gsModEngine) |
| + elemLen*sizeof(BNU_CHUNK_T) /* modulus */ |
| + elemLen*sizeof(BNU_CHUNK_T) /* mont_R */ |
| + elemLen*sizeof(BNU_CHUNK_T) /* mont_R^2 */ |
| + elemLen*sizeof(BNU_CHUNK_T) /* half of modulus */ |
| + elemLen*sizeof(BNU_CHUNK_T) /* quadratic non-residue */ |
| + pelmLen*sizeof(BNU_CHUNK_T)*numpe; /* pool */ |
| |
| ctxSize += sizeof(IppsGFpState); /* size of IppsGFPState */ |
| return ctxSize; |
| } |
| |
| IPPFUN(IppStatus, ippsGFpGetSize,(int feBitSize, int* pSize)) |
| { |
| IPP_BAD_PTR1_RET(pSize); |
| IPP_BADARG_RET((feBitSize < 2) || (feBitSize > GFP_MAX_BITSIZE), ippStsSizeErr); |
| |
| *pSize = cpGFpGetSize(feBitSize, feBitSize+BITSIZE(BNU_CHUNK_T), GFP_POOL_SIZE) |
| + GFP_ALIGNMENT; |
| return ippStsNoErr; |
| } |
| |
| |
| /* |
| // init GFp engine context (Montgomery) |
| */ |
| static void cpGFEInit(gsModEngine* pGFE, int modulusBitSize, int peBitSize, int numpe) |
| { |
| int modLen = BITS_BNU_CHUNK(modulusBitSize); |
| int pelmLen = BITS_BNU_CHUNK(peBitSize); |
| |
| Ipp8u* ptr = (Ipp8u*)pGFE; |
| |
| /* clear whole context */ |
| PaddBlock(0, ptr, sizeof(gsModEngine)); |
| ptr += sizeof(gsModEngine); |
| |
| GFP_PARENT(pGFE) = NULL; |
| GFP_EXTDEGREE(pGFE) = 1; |
| GFP_FEBITLEN(pGFE) = modulusBitSize; |
| GFP_FELEN(pGFE) = modLen; |
| GFP_FELEN32(pGFE) = BITS2WORD32_SIZE(modulusBitSize); |
| GFP_PELEN(pGFE) = pelmLen; |
| //GFP_METHOD(pGFE) = method; |
| GFP_MODULUS(pGFE) = (BNU_CHUNK_T*)(ptr); ptr += modLen*sizeof(BNU_CHUNK_T); |
| GFP_MNT_R(pGFE) = (BNU_CHUNK_T*)(ptr); ptr += modLen*sizeof(BNU_CHUNK_T); |
| GFP_MNT_RR(pGFE) = (BNU_CHUNK_T*)(ptr); ptr += modLen*sizeof(BNU_CHUNK_T); |
| GFP_HMODULUS(pGFE) = (BNU_CHUNK_T*)(ptr); ptr += modLen*sizeof(BNU_CHUNK_T); |
| GFP_QNR(pGFE) = (BNU_CHUNK_T*)(ptr); ptr += modLen*sizeof(BNU_CHUNK_T); |
| GFP_POOL(pGFE) = (BNU_CHUNK_T*)(ptr);/* ptr += modLen*sizeof(BNU_CHUNK_T);*/ |
| GFP_MAXPOOL(pGFE) = numpe; |
| GFP_USEDPOOL(pGFE) = 0; |
| |
| cpGFpElementPadd(GFP_MODULUS(pGFE), modLen, 0); |
| cpGFpElementPadd(GFP_MNT_R(pGFE), modLen, 0); |
| cpGFpElementPadd(GFP_MNT_RR(pGFE), modLen, 0); |
| cpGFpElementPadd(GFP_HMODULUS(pGFE), modLen, 0); |
| cpGFpElementPadd(GFP_QNR(pGFE), modLen, 0); |
| } |
| |
| static void cpGFEqnr(gsModEngine* pGFE) |
| { |
| BNU_CHUNK_T* pQnr = GFP_QNR(pGFE); |
| |
| int elemLen = GFP_FELEN(pGFE); |
| BNU_CHUNK_T* e = cpGFpGetPool(3, pGFE); |
| BNU_CHUNK_T* t = e+elemLen; |
| BNU_CHUNK_T* p1 = t+elemLen; |
| //gres: temporary excluded: assert(NULL!=e); |
| |
| cpGFpElementCopyPadd(p1, elemLen, GFP_MNT_R(pGFE), elemLen); |
| |
| /* (modulus-1)/2 */ |
| cpLSR_BNU(e, GFP_MODULUS(pGFE), elemLen, 1); |
| |
| /* find a non-square g, where g^{(modulus-1)/2} = -1 */ |
| cpGFpElementCopy(pQnr, p1, elemLen); |
| do { |
| cpGFpAdd(pQnr, pQnr, p1, pGFE); |
| cpGFpExp(t, pQnr, e, elemLen, pGFE); |
| cpGFpNeg(t, t, pGFE); |
| } while( !GFP_EQ(p1, t, elemLen) ); |
| |
| cpGFpReleasePool(3, pGFE); |
| } |
| |
| static void cpGFESet(gsModEngine* pGFE, const BNU_CHUNK_T* pPrime, int primeBitSize, const gsModMethod* method) |
| { |
| int primeLen = BITS_BNU_CHUNK(primeBitSize); |
| |
| /* arithmetic methods */ |
| GFP_METHOD(pGFE) = method; |
| |
| /* store modulus */ |
| COPY_BNU(GFP_MODULUS(pGFE), pPrime, primeLen); |
| |
| /* montgomery factor */ |
| GFP_MNT_FACTOR(pGFE) = gsMontFactor(GFP_MODULUS(pGFE)[0]); |
| |
| /* montgomery identity (R) */ |
| ZEXPAND_BNU(GFP_MNT_R(pGFE), 0, primeLen); |
| GFP_MNT_R(pGFE)[primeLen] = 1; |
| cpMod_BNU(GFP_MNT_R(pGFE), primeLen+1, GFP_MODULUS(pGFE), primeLen); |
| |
| /* montgomery domain converter (RR) */ |
| ZEXPAND_BNU(GFP_MNT_RR(pGFE), 0, primeLen); |
| COPY_BNU(GFP_MNT_RR(pGFE)+primeLen, GFP_MNT_R(pGFE), primeLen); |
| cpMod_BNU(GFP_MNT_RR(pGFE), 2*primeLen, GFP_MODULUS(pGFE), primeLen); |
| |
| /* half of modulus */ |
| cpLSR_BNU(GFP_HMODULUS(pGFE), GFP_MODULUS(pGFE), primeLen, 1); |
| |
| /* set qnr value */ |
| cpGFEqnr(pGFE); |
| } |
| |
| IppStatus cpGFpInitGFp(int primeBitSize, IppsGFpState* pGF) |
| { |
| IPP_BADARG_RET((primeBitSize< IPP_MIN_GF_BITSIZE) || (primeBitSize> IPP_MAX_GF_BITSIZE), ippStsSizeErr); |
| IPP_BAD_PTR1_RET(pGF); |
| pGF = (IppsGFpState*)( IPP_ALIGNED_PTR(pGF, GFP_ALIGNMENT) ); |
| |
| { |
| Ipp8u* ptr = (Ipp8u*)pGF; |
| |
| GFP_ID(pGF) = idCtxGFP; |
| GFP_PMA(pGF) = (gsModEngine*)(ptr+sizeof(IppsGFpState)); |
| cpGFEInit(GFP_PMA(pGF), primeBitSize, primeBitSize+BITSIZE(BNU_CHUNK_T), GFP_POOL_SIZE); |
| |
| return ippStsNoErr; |
| } |
| } |
| |
| IppStatus cpGFpSetGFp(const BNU_CHUNK_T* pPrime, int primeBitSize, const IppsGFpMethod* method, IppsGFpState* pGF) |
| { |
| cpGFESet(GFP_PMA(pGF), pPrime, primeBitSize, method->arith); |
| return ippStsNoErr; |
| } |
| |
| /*F* |
| // Name: ippsGFpInitFixed |
| // |
| // Purpose: initializes prime finite field GF(p) |
| // |
| // Returns: Reason: |
| // ippStsNullPtrErr NULL == method |
| // NULL == pGF |
| // |
| // ippStsBadArgErr method != ippsGFpMethod_pXXX() any fixed prime method |
| // primeBitSize != sizeof modulus defined by fixed method |
| // |
| // ippStsNoErr no error |
| // |
| // Parameters: |
| // primeBitSize length of prime in bits |
| // method pointer to the basic arithmetic metods |
| // pGF pointer to Finite Field context is being initialized |
| *F*/ |
| IPPFUN(IppStatus, ippsGFpInitFixed,(int primeBitSize, const IppsGFpMethod* method, IppsGFpState* pGF)) |
| { |
| IPP_BAD_PTR2_RET(method, pGF); |
| pGF = (IppsGFpState*)( IPP_ALIGNED_PTR(pGF, GFP_ALIGNMENT) ); |
| |
| /* test method is prime based */ |
| IPP_BADARG_RET(cpID_Prime!=(method->modulusID & cpID_Prime), ippStsBadArgErr); |
| /* test if method is not prime based arbitrary */ |
| IPP_BADARG_RET(!method->modulus, ippStsBadArgErr); |
| /* size of the underlying prime must be equal to primeBitSize parameter*/ |
| IPP_BADARG_RET(method->modulusBitDeg!=primeBitSize, ippStsBadArgErr); |
| |
| { |
| /* init GF */ |
| IppStatus sts = cpGFpInitGFp(primeBitSize, pGF); |
| |
| /* set up GF engine */ |
| if(ippStsNoErr==sts) { |
| gsModEngine* pGFE = GFP_PMA(pGF); |
| cpGFESet(pGFE, method->modulus, primeBitSize, method->arith); |
| } |
| |
| return sts; |
| } |
| } |
| |
| /*F* |
| // Name: ippsGFpInitArbitrary |
| // |
| // Purpose: initializes prime finite field GF(p) |
| // |
| // Returns: Reason: |
| // ippStsNullPtrErr NULL == pPrime |
| // NULL == pGF |
| // |
| // ippStsSizeErr !(IPP_MIN_GF_BITSIZE <= primeBitSize <=IPP_MAX_GF_BITSIZE) |
| // |
| // ippStsContextMatchErr incorrect pPrime context ID |
| // |
| // ippStsBadArgErr prime <0 |
| // bitsize(prime) != primeBitSize |
| // prime <IPP_MIN_GF_CHAR |
| // prime is even |
| // |
| // ippStsNoErr no error |
| // |
| // Parameters: |
| // pPrimeBN pointer to the prime context |
| // primeBitSize length of prime in bits |
| // pGF pointer to Finite Field context is being initialized |
| *F*/ |
| IPPFUN(IppStatus, ippsGFpInitArbitrary,(const IppsBigNumState* pPrimeBN, int primeBitSize, IppsGFpState* pGF)) |
| { |
| IPP_BAD_PTR1_RET(pGF); |
| pGF = (IppsGFpState*)( IPP_ALIGNED_PTR(pGF, GFP_ALIGNMENT) ); |
| |
| IPP_BADARG_RET((primeBitSize< IPP_MIN_GF_BITSIZE) || (primeBitSize> IPP_MAX_GF_BITSIZE), ippStsSizeErr); |
| |
| IPP_BAD_PTR1_RET(pPrimeBN); |
| pPrimeBN = (IppsBigNumState*)( IPP_ALIGNED_PTR(pPrimeBN, BN_ALIGNMENT) ); |
| IPP_BADARG_RET(!BN_VALID_ID(pPrimeBN), ippStsContextMatchErr); |
| IPP_BADARG_RET(BN_SIGN(pPrimeBN)!= IppsBigNumPOS, ippStsBadArgErr); /* prime is negative */ |
| IPP_BADARG_RET(BITSIZE_BNU(BN_NUMBER(pPrimeBN),BN_SIZE(pPrimeBN)) != primeBitSize, ippStsBadArgErr); /* primeBitSize == bitsize(prime) */ |
| IPP_BADARG_RET((BN_SIZE(pPrimeBN)==1) && (BN_NUMBER(pPrimeBN)[0]<IPP_MIN_GF_CHAR), ippStsBadArgErr); /* prime < 3 */ |
| IPP_BADARG_RET(0==(BN_NUMBER(pPrimeBN)[0] & 1), ippStsBadArgErr); /* prime is even */ |
| |
| { |
| /* init GF */ |
| IppStatus sts = cpGFpInitGFp(primeBitSize, pGF); |
| |
| /* set up GF engine */ |
| if(ippStsNoErr==sts) { |
| gsModEngine* pGFE = GFP_PMA(pGF); |
| cpGFESet(pGFE, BN_NUMBER(pPrimeBN), primeBitSize, ippsGFpMethod_pArb()->arith); |
| } |
| |
| return sts; |
| } |
| } |
| |
| /*F* |
| // Name: ippsGFpInit |
| // |
| // Purpose: initializes prime finite field GF(p) |
| // |
| // Returns: Reason: |
| // ippStsNullPtrErr NULL == method |
| // NULL == pGF |
| // |
| // ippStsSizeErr !(IPP_MIN_GF_BITSIZE <= primeBitSize <=IPP_MAX_GF_BITSIZE |
| // |
| // ippStsContextMatchErr invalid pPrime->idCtx |
| // |
| // ippStsBadArgErr method != ippsGFpMethod_pXXX() or != ippsGFpMethod_pArb() |
| // prime != method->modulus |
| // prime <0 |
| // bitsize(prime) != primeBitSize |
| // prime <IPP_MIN_GF_CHAR |
| // prime is even |
| // |
| // ippStsNoErr no error |
| // |
| // Parameters: |
| // pPrimeBN pointer to the data representation Finite Field element |
| // primeBitSize length of Finite Field data representation array |
| // method pointer to Finite Field Element context |
| // pGF pointer to Finite Field context is being initialized |
| *F*/ |
| IPPFUN(IppStatus, ippsGFpInit,(const IppsBigNumState* pPrimeBN, int primeBitSize, const IppsGFpMethod* method, IppsGFpState* pGF)) |
| { |
| IPP_BADARG_RET(!pPrimeBN && !method, ippStsNullPtrErr); |
| |
| IPP_BADARG_RET((primeBitSize< IPP_MIN_GF_BITSIZE) || (primeBitSize> IPP_MAX_GF_BITSIZE), ippStsSizeErr); |
| |
| /* use ippsGFpInitFixed() if NULL==pPrimeBN */ |
| if(!pPrimeBN) |
| return ippsGFpInitFixed(primeBitSize, method, pGF); |
| |
| /* use ippsGFpInitArbitrary() if NULL==method */ |
| if(!method) |
| return ippsGFpInitArbitrary(pPrimeBN, primeBitSize, pGF); |
| |
| /* test parameters if both pPrimeBN and method are defined */ |
| else { |
| IppStatus sts; |
| |
| /* test input prime */ |
| pPrimeBN = (IppsBigNumState*)( IPP_ALIGNED_PTR(pPrimeBN, BN_ALIGNMENT) ); |
| IPP_BADARG_RET(!BN_VALID_ID(pPrimeBN), ippStsContextMatchErr); |
| IPP_BADARG_RET(BN_SIGN(pPrimeBN)!= IppsBigNumPOS, ippStsBadArgErr); /* prime is negative */ |
| IPP_BADARG_RET(BITSIZE_BNU(BN_NUMBER(pPrimeBN),BN_SIZE(pPrimeBN)) != primeBitSize, ippStsBadArgErr); /* primeBitSize == bitsize(prime) */ |
| IPP_BADARG_RET((BN_SIZE(pPrimeBN)==1) && (BN_NUMBER(pPrimeBN)[0]<IPP_MIN_GF_CHAR), ippStsBadArgErr); /* prime < 3 */ |
| IPP_BADARG_RET(0==(BN_NUMBER(pPrimeBN)[0] & 1), ippStsBadArgErr); /* prime is even */ |
| |
| /* test if method is prime based */ |
| IPP_BADARG_RET(cpID_Prime!=(method->modulusID & cpID_Prime), ippStsBadArgErr); |
| |
| /* test if size of the prime is matched to method's prime */ |
| IPP_BADARG_RET(method->modulusBitDeg && (primeBitSize!=method->modulusBitDeg), ippStsBadArgErr); |
| |
| /* if method assumes fixed prime value */ |
| if(method->modulus) { |
| int primeLen = BITS_BNU_CHUNK(primeBitSize); |
| IPP_BADARG_RET(cpCmp_BNU(BN_NUMBER(pPrimeBN), primeLen, method->modulus, primeLen), ippStsBadArgErr); |
| } |
| |
| /* init GF */ |
| sts = cpGFpInitGFp(primeBitSize, pGF); |
| |
| /* set up GF and find quadratic nonresidue */ |
| if(ippStsNoErr==sts) { |
| gsModEngine* pGFE = GFP_PMA(pGF); |
| cpGFESet(pGFE, BN_NUMBER(pPrimeBN), primeBitSize, method->arith); |
| } |
| |
| return sts; |
| } |
| } |
| |
| IPPFUN(IppStatus, ippsGFpScratchBufferSize,(int nExponents, int ExpBitSize, const IppsGFpState* pGF, int* pBufferSize)) |
| { |
| IPP_BAD_PTR2_RET(pGF, pBufferSize); |
| pGF = (IppsGFpState*)( IPP_ALIGNED_PTR(pGF, GFP_ALIGNMENT) ); |
| IPP_BADARG_RET( !GFP_TEST_ID(pGF), ippStsContextMatchErr ); |
| |
| IPP_BADARG_RET( 0>=nExponents ||nExponents>IPP_MAX_EXPONENT_NUM, ippStsBadArgErr); |
| IPP_BADARG_RET( 0>=ExpBitSize, ippStsBadArgErr); |
| |
| { |
| int elmDataSize = GFP_FELEN(GFP_PMA(pGF))*sizeof(BNU_CHUNK_T); |
| |
| /* get window_size */ |
| int w = (nExponents==1)? cpGFpGetOptimalWinSize(ExpBitSize) : /* use optimal window size, if single-scalar operation */ |
| nExponents; /* or pseudo-oprimal if multi-scalar operation */ |
| |
| /* number of table entries */ |
| int nPrecomputed = 1<<w; |
| |
| *pBufferSize = elmDataSize*nPrecomputed + (CACHE_LINE_SIZE-1); |
| |
| return ippStsNoErr; |
| } |
| } |
| |
| IPPFUN(IppStatus, ippsGFpElementGetSize,(const IppsGFpState* pGF, int* pElementSize)) |
| { |
| IPP_BAD_PTR2_RET(pElementSize, pGF); |
| pGF = (IppsGFpState*)( IPP_ALIGNED_PTR(pGF, GFP_ALIGNMENT) ); |
| IPP_BADARG_RET( !GFP_TEST_ID(pGF), ippStsContextMatchErr ); |
| |
| *pElementSize = sizeof(IppsGFpElement) |
| +GFP_FELEN(GFP_PMA(pGF))*sizeof(BNU_CHUNK_T); |
| return ippStsNoErr; |
| } |
| |
| |
| IPPFUN(IppStatus, ippsGFpElementInit,(const Ipp32u* pA, int nsA, IppsGFpElement* pR, IppsGFpState* pGF)) |
| { |
| IPP_BAD_PTR2_RET(pR, pGF); |
| pGF = (IppsGFpState*)( IPP_ALIGNED_PTR(pGF, GFP_ALIGNMENT) ); |
| IPP_BADARG_RET( !GFP_TEST_ID(pGF), ippStsContextMatchErr ); |
| |
| IPP_BADARG_RET(0>nsA, ippStsSizeErr); |
| |
| { |
| int elemLen = GFP_FELEN(GFP_PMA(pGF)); |
| |
| Ipp8u* ptr = (Ipp8u*)pR; |
| ptr += sizeof(IppsGFpElement); |
| cpGFpElementConstruct(pR, (BNU_CHUNK_T*)ptr, elemLen); |
| return ippsGFpSetElement(pA, nsA, pR, pGF); |
| } |
| } |
| |
| /*F* |
| // Name: ippsGFpSetElement |
| // |
| // Purpose: Set GF Element |
| // |
| // Returns: Reason: |
| // ippStsNullPtrErr NULL == pGF |
| // NULL == pElm |
| // NULL == pDataA && nsA>0 |
| // |
| // ippStsContextMatchErr invalid pGF->idCtx |
| // invalid pElm->idCtx |
| // |
| // ippStsSizeErr pDataA && !(0<=nsA && nsA<GFP_FELEN32()) |
| // |
| // ippStsOutOfRangeErr GFPE_ROOM() != GFP_FELEN() |
| // BNU representation of pDataA[i]..pDataA[i+GFP_FELEN32()-1] >= modulus |
| // |
| // ippStsNoErr no error |
| // |
| // Parameters: |
| // pDataA pointer to the data representation Finite Field element |
| // nsA length of Finite Field data representation array |
| // pElm pointer to Finite Field Element context |
| // pGF pointer to Finite Field context |
| *F*/ |
| IPPFUN(IppStatus, ippsGFpSetElement,(const Ipp32u* pDataA, int nsA, IppsGFpElement* pElm, IppsGFpState* pGF)) |
| { |
| IPP_BAD_PTR2_RET(pElm, pGF); |
| pGF = (IppsGFpState*)( IPP_ALIGNED_PTR(pGF, GFP_ALIGNMENT) ); |
| IPP_BADARG_RET( !GFP_TEST_ID(pGF), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElm), ippStsContextMatchErr ); |
| |
| IPP_BADARG_RET( !pDataA && (0<nsA), ippStsNullPtrErr); |
| IPP_BADARG_RET( pDataA && !(0<=nsA && nsA<=GFP_FELEN32(GFP_PMA(pGF))), ippStsSizeErr ); |
| IPP_BADARG_RET( GFPE_ROOM(pElm)!=GFP_FELEN(GFP_PMA(pGF)), ippStsOutOfRangeErr ); |
| |
| { |
| IppStatus sts = ippStsNoErr; |
| |
| gsModEngine* pGFE = GFP_PMA(pGF); |
| int elemLen = GFP_FELEN(pGFE); |
| BNU_CHUNK_T* pTmp = cpGFpGetPool(1, pGFE); |
| //gres: temporary excluded: assert(NULL!=pTmp); |
| |
| ZEXPAND_BNU(pTmp, 0, elemLen); |
| if(pDataA && nsA) |
| cpGFpxCopyToChunk(pTmp, pDataA, nsA, pGFE); |
| |
| if(!cpGFpxSet(GFPE_DATA(pElm), pTmp, elemLen, pGFE)) |
| sts = ippStsOutOfRangeErr; |
| |
| cpGFpReleasePool(1, pGFE); |
| return sts; |
| } |
| } |
| |
| IPPFUN(IppStatus, ippsGFpSetElementRegular,(const IppsBigNumState* pBN, IppsGFpElement* pElm, IppsGFpState* pGF)) |
| { |
| IPP_BAD_PTR1_RET(pBN); |
| pBN = (IppsBigNumState*)( IPP_ALIGNED_PTR(pBN, BN_ALIGNMENT) ); |
| IPP_BADARG_RET( !BN_VALID_ID(pBN), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !BN_POSITIVE(pBN), ippStsOutOfRangeErr); |
| |
| return ippsGFpSetElement((Ipp32u*)BN_NUMBER(pBN), BITS2WORD32_SIZE( BITSIZE_BNU(BN_NUMBER((pBN)),BN_SIZE((pBN)))), pElm, pGF); |
| } |
| |
| /*F* |
| // Name: ippsGFpSetElementOctString |
| // |
| // Purpose: Set GF Element |
| // |
| // Returns: Reason: |
| // ippStsNullPtrErr NULL == pGF |
| // NULL == pElm |
| // NULL == pStr && strSize>0 |
| // |
| // ippStsContextMatchErr invalid pGF->idCtx |
| // invalid pElm->idCtx |
| // |
| // ippStsSizeErr pDataA && !(0<=nsA && nsA<GFP_FELEN32()) |
| // |
| // ippStsOutOfRangeErr GFPE_ROOM() != GFP_FELEN() |
| // BNU representation of pStr[] >= modulus |
| // |
| // ippStsNoErr no error |
| // |
| // Parameters: |
| // pDataA pointer to the data representation Finite Field element |
| // nsA length of Finite Field data representation array |
| // pElm pointer to Finite Field Element context |
| // pGF pointer to Finite Field context |
| *F*/ |
| IPPFUN(IppStatus, ippsGFpSetElementOctString,(const Ipp8u* pStr, int strSize, IppsGFpElement* pElm, IppsGFpState* pGF)) |
| { |
| IPP_BAD_PTR2_RET(pElm, pGF); |
| pGF = (IppsGFpState*)( IPP_ALIGNED_PTR(pGF, GFP_ALIGNMENT) ); |
| IPP_BADARG_RET( !GFP_TEST_ID(pGF), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElm), ippStsContextMatchErr ); |
| |
| IPP_BADARG_RET( (!pStr && 0<strSize), ippStsNullPtrErr); |
| IPP_BADARG_RET(!(0<strSize && strSize<=(int)(GFP_FELEN32(GFP_PMA(pGF))*sizeof(Ipp32u))), ippStsSizeErr ); |
| |
| IPP_BADARG_RET( GFPE_ROOM(pElm)!=GFP_FELEN(GFP_PMA(pGF)), ippStsOutOfRangeErr); |
| |
| { |
| gsModEngine* pGFE = GFP_PMA(pGF); |
| gsModEngine* pBasicGFE = cpGFpBasic(pGFE); |
| int basicDeg = cpGFpBasicDegreeExtension(pGFE); |
| int basicElemLen = GFP_FELEN(pBasicGFE); |
| int basicSize = BITS2WORD8_SIZE(BITSIZE_BNU(GFP_MODULUS(pBasicGFE),GFP_FELEN(pBasicGFE))); |
| |
| BNU_CHUNK_T* pDataElm = GFPE_DATA(pElm); |
| |
| int deg, error; |
| /* set element to zero */ |
| cpGFpElementPadd(pDataElm, GFP_FELEN(pGFE), 0); |
| |
| /* convert oct string to element (from low to high) */ |
| for(deg=0, error=0; deg<basicDeg && !error; deg++) { |
| int size = IPP_MIN(strSize, basicSize); |
| error = NULL == cpGFpSetOctString(pDataElm, pStr, size, pBasicGFE); |
| |
| pDataElm += basicElemLen; |
| strSize -= size; |
| pStr += size; |
| } |
| |
| return error? ippStsOutOfRangeErr : ippStsNoErr; |
| } |
| } |
| |
| |
| /*F* |
| // Name: ippsGFpSetElementRandom |
| // |
| // Purpose: Set GF Element Random |
| // |
| // Returns: Reason: |
| // ippStsNullPtrErr NULL == pGF |
| // NULL == pElm |
| // NULL == rndFunc |
| // |
| // ippStsContextMatchErr invalid pGF->idCtx |
| // invalid pElm->idCtx |
| // |
| // ippStsOutOfRangeErr GFPE_ROOM() != GFP_FELEN() |
| // |
| // ippStsErr internal error caused by call of rndFunc() |
| // |
| // ippStsNoErr no error |
| // |
| // Parameters: |
| // pDataA pointer to the data representation Finite Field element |
| // nsA length of Finite Field data representation array |
| // pElm pointer to Finite Field Element context |
| // pGF pointer to Finite Field context |
| *F*/ |
| IPPFUN(IppStatus, ippsGFpSetElementRandom,(IppsGFpElement* pElm, IppsGFpState* pGF, |
| IppBitSupplier rndFunc, void* pRndParam)) |
| { |
| IPP_BAD_PTR3_RET(pElm, pGF, rndFunc); |
| pGF = (IppsGFpState*)( IPP_ALIGNED_PTR(pGF, GFP_ALIGNMENT) ); |
| IPP_BADARG_RET( !GFP_TEST_ID(pGF), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElm), ippStsContextMatchErr ); |
| |
| { |
| gsModEngine* pGFE = GFP_PMA(pGF); |
| IPP_BADARG_RET( GFPE_ROOM(pElm)!=GFP_FELEN(pGFE), ippStsOutOfRangeErr); |
| return cpGFpxRand(GFPE_DATA(pElm), pGFE, rndFunc, pRndParam)? ippStsNoErr : ippStsErr; |
| } |
| } |
| |
| IPPFUN(IppStatus, ippsGFpCpyElement, (const IppsGFpElement* pElmA, IppsGFpElement* pElmR, IppsGFpState* pGF)) |
| { |
| IPP_BAD_PTR3_RET(pElmA, pElmR, pGF); |
| pGF = (IppsGFpState*)( IPP_ALIGNED_PTR(pGF, GFP_ALIGNMENT) ); |
| IPP_BADARG_RET( !GFP_TEST_ID(pGF), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmA), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmR), ippStsContextMatchErr ); |
| { |
| gsModEngine* pGFE = GFP_PMA(pGF); |
| IPP_BADARG_RET( (GFPE_ROOM(pElmA)!=GFP_FELEN(pGFE)) || (GFPE_ROOM(pElmR)!=GFP_FELEN(pGFE)), ippStsOutOfRangeErr); |
| cpGFpElementCopy(GFPE_DATA(pElmR), GFPE_DATA(pElmA), GFP_FELEN(pGFE)); |
| return ippStsNoErr; |
| } |
| } |
| |
| IPPFUN(IppStatus, ippsGFpGetElement, (const IppsGFpElement* pElm, Ipp32u* pDataA, int nsA, IppsGFpState* pGF)) |
| { |
| IPP_BAD_PTR3_RET(pElm, pDataA, pGF); |
| pGF = (IppsGFpState*)( IPP_ALIGNED_PTR(pGF, GFP_ALIGNMENT) ); |
| IPP_BADARG_RET( !GFP_TEST_ID(pGF), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElm), ippStsContextMatchErr ); |
| { |
| gsModEngine* pGFE = GFP_PMA(pGF); |
| IPP_BADARG_RET( GFPE_ROOM(pElm)!=GFP_FELEN(pGFE), ippStsOutOfRangeErr); |
| IPP_BADARG_RET( !(0<nsA && nsA>=GFP_FELEN32(pGFE)), ippStsSizeErr ); |
| |
| { |
| int elemLen = GFP_FELEN(pGFE); |
| BNU_CHUNK_T* pTmp = cpGFpGetPool(1, pGFE); |
| //gres: temporary excluded: assert(NULL!=pTmp); |
| |
| cpGFpxGet(pTmp, elemLen, GFPE_DATA(pElm), pGFE); |
| cpGFpxCopyFromChunk(pDataA, pTmp, pGFE); |
| |
| cpGFpReleasePool(1, pGFE); |
| return ippStsNoErr; |
| } |
| } |
| } |
| |
| IPPFUN(IppStatus, ippsGFpGetElementOctString,(const IppsGFpElement* pElm, Ipp8u* pStr, int strSize, IppsGFpState* pGF)) |
| { |
| IPP_BAD_PTR3_RET(pStr, pElm, pGF); |
| pGF = (IppsGFpState*)( IPP_ALIGNED_PTR(pGF, GFP_ALIGNMENT) ); |
| IPP_BADARG_RET( !GFP_TEST_ID(pGF), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElm), ippStsContextMatchErr ); |
| IPP_BADARG_RET( 0>=strSize, ippStsSizeErr ); |
| { |
| gsModEngine* pGFE = GFP_PMA(pGF); |
| IPP_BADARG_RET( GFPE_ROOM(pElm)!=GFP_FELEN(pGFE), ippStsOutOfRangeErr); |
| { |
| gsModEngine* pBasicGFE = cpGFpBasic(pGFE); |
| int basicDeg = cpGFpBasicDegreeExtension(pGFE); |
| int basicElemLen = GFP_FELEN(pBasicGFE); |
| int basicSize = BITS2WORD8_SIZE(BITSIZE_BNU(GFP_MODULUS(pBasicGFE),GFP_FELEN(pBasicGFE))); |
| |
| BNU_CHUNK_T* pDataElm = GFPE_DATA(pElm); |
| int deg; |
| for(deg=0; deg<basicDeg; deg++) { |
| int size = IPP_MIN(strSize, basicSize); |
| cpGFpGetOctString(pStr, size, pDataElm, pBasicGFE); |
| |
| pDataElm += basicElemLen; |
| pStr += size; |
| strSize -= size; |
| } |
| |
| return ippStsNoErr; |
| } |
| } |
| } |
| |
| IPPFUN(IppStatus, ippsGFpCmpElement,(const IppsGFpElement* pElmA, const IppsGFpElement* pElmB, |
| int* pResult, |
| const IppsGFpState* pGF)) |
| { |
| IPP_BAD_PTR4_RET(pElmA, pElmB, pResult, pGF); |
| pGF = (IppsGFpState*)( IPP_ALIGNED_PTR(pGF, GFP_ALIGNMENT) ); |
| IPP_BADARG_RET( !GFP_TEST_ID(pGF), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmA), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmB), ippStsContextMatchErr ); |
| { |
| gsModEngine* pGFE = GFP_PMA(pGF); |
| IPP_BADARG_RET( (GFPE_ROOM(pElmA)!=GFP_FELEN(pGFE)) || (GFPE_ROOM(pElmB)!=GFP_FELEN(pGFE)), ippStsOutOfRangeErr); |
| { |
| int flag = cpGFpElementCmp(GFPE_DATA(pElmA), GFPE_DATA(pElmB), GFP_FELEN(pGFE)); |
| if( GFP_IS_BASIC(pGFE) ) |
| *pResult = (0==flag)? IPP_IS_EQ : (0<flag)? IPP_IS_GT : IPP_IS_LT; |
| else |
| *pResult = (0==flag)? IPP_IS_EQ : IPP_IS_NE; |
| return ippStsNoErr; |
| } |
| } |
| } |
| |
| IPPFUN(IppStatus, ippsGFpIsZeroElement,(const IppsGFpElement* pElmA, |
| int* pResult, |
| const IppsGFpState* pGF)) |
| { |
| IPP_BAD_PTR3_RET(pElmA, pResult, pGF); |
| pGF = (IppsGFpState*)( IPP_ALIGNED_PTR(pGF, GFP_ALIGNMENT) ); |
| IPP_BADARG_RET( !GFP_TEST_ID(pGF), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmA), ippStsContextMatchErr ); |
| { |
| gsModEngine* pGFE = GFP_PMA(pGF); |
| IPP_BADARG_RET( GFPE_ROOM(pElmA)!=GFP_FELEN(pGFE), ippStsOutOfRangeErr); |
| { |
| int flag = GFP_IS_ZERO(GFPE_DATA(pElmA), GFP_FELEN(pGFE)); |
| *pResult = (1==flag)? IPP_IS_EQ : IPP_IS_NE; |
| return ippStsNoErr; |
| } |
| } |
| } |
| |
| IPPFUN(IppStatus, ippsGFpIsUnityElement,(const IppsGFpElement* pElmA, |
| int* pResult, |
| const IppsGFpState* pGF)) |
| { |
| IPP_BAD_PTR3_RET(pElmA, pResult, pGF); |
| pGF = (IppsGFpState*)( IPP_ALIGNED_PTR(pGF, GFP_ALIGNMENT) ); |
| IPP_BADARG_RET( !GFP_TEST_ID(pGF), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmA), ippStsContextMatchErr ); |
| { |
| gsModEngine* pGFE = GFP_PMA(pGF); |
| IPP_BADARG_RET( GFPE_ROOM(pElmA)!=GFP_FELEN(pGFE), ippStsOutOfRangeErr); |
| { |
| gsModEngine* pBasicGFE = cpGFpBasic(pGFE); |
| int basicElmLen = GFP_FELEN(pBasicGFE); |
| BNU_CHUNK_T* pUnity = GFP_MNT_R(pBasicGFE); |
| |
| int elmLen = GFP_FELEN(pGFE); |
| int flag; |
| |
| FIX_BNU(pUnity, basicElmLen); |
| FIX_BNU(GFPE_DATA(pElmA), elmLen); |
| |
| flag = (basicElmLen==elmLen) && (0 == cpGFpElementCmp(GFPE_DATA(pElmA), pUnity, elmLen)); |
| *pResult = (1==flag)? IPP_IS_EQ : IPP_IS_NE; |
| return ippStsNoErr; |
| } |
| } |
| } |
| |
| IPPFUN(IppStatus, ippsGFpConj,(const IppsGFpElement* pElmA, |
| IppsGFpElement* pElmR, IppsGFpState* pGF)) |
| { |
| IPP_BAD_PTR3_RET(pElmA, pElmR, pGF); |
| pGF = (IppsGFpState*)( IPP_ALIGNED_PTR(pGF, GFP_ALIGNMENT) ); |
| IPP_BADARG_RET( !GFP_TEST_ID(pGF), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmA), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmR), ippStsContextMatchErr ); |
| { |
| gsModEngine* pGFE = GFP_PMA(pGF); |
| IPP_BADARG_RET( (GFPE_ROOM(pElmA)!=GFP_FELEN(pGFE)) || (GFPE_ROOM(pElmR)!=GFP_FELEN(pGFE)), ippStsOutOfRangeErr); |
| IPP_BADARG_RET( 2!=GFP_EXTDEGREE(pGFE), ippStsBadArgErr ) |
| |
| cpGFpxConj(GFPE_DATA(pElmR), GFPE_DATA(pElmA), pGFE); |
| return ippStsNoErr; |
| } |
| } |
| |
| IPPFUN(IppStatus, ippsGFpNeg,(const IppsGFpElement* pElmA, |
| IppsGFpElement* pElmR, IppsGFpState* pGF)) |
| { |
| IPP_BAD_PTR3_RET(pElmA, pElmR, pGF); |
| pGF = (IppsGFpState*)( IPP_ALIGNED_PTR(pGF, GFP_ALIGNMENT) ); |
| IPP_BADARG_RET( !GFP_TEST_ID(pGF), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmA), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmR), ippStsContextMatchErr ); |
| { |
| gsModEngine* pGFE = GFP_PMA(pGF); |
| IPP_BADARG_RET( (GFPE_ROOM(pElmA)!=GFP_FELEN(pGFE)) || (GFPE_ROOM(pElmR)!=GFP_FELEN(pGFE)), ippStsOutOfRangeErr); |
| |
| GFP_METHOD(pGFE)->neg(GFPE_DATA(pElmR), GFPE_DATA(pElmA), pGFE); |
| return ippStsNoErr; |
| } |
| } |
| |
| |
| IPPFUN(IppStatus, ippsGFpInv,(const IppsGFpElement* pElmA, |
| IppsGFpElement* pElmR, IppsGFpState* pGF)) |
| { |
| IPP_BAD_PTR3_RET(pElmA, pElmR, pGF); |
| pGF = (IppsGFpState*)( IPP_ALIGNED_PTR(pGF, GFP_ALIGNMENT) ); |
| IPP_BADARG_RET( !GFP_TEST_ID(pGF), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmA), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmR), ippStsContextMatchErr ); |
| { |
| gsModEngine* pGFE = GFP_PMA(pGF); |
| IPP_BADARG_RET( (GFPE_ROOM(pElmA)!=GFP_FELEN(pGFE)) || (GFPE_ROOM(pElmR)!=GFP_FELEN(pGFE)), ippStsOutOfRangeErr); |
| IPP_BADARG_RET( GFP_IS_ZERO(GFPE_DATA(pElmA),GFP_FELEN(pGFE)), ippStsDivByZeroErr ); |
| |
| return NULL != cpGFpxInv(GFPE_DATA(pElmR), GFPE_DATA(pElmA), pGFE)? ippStsNoErr : ippStsBadArgErr; |
| } |
| } |
| |
| |
| IPPFUN(IppStatus, ippsGFpSqrt,(const IppsGFpElement* pElmA, |
| IppsGFpElement* pElmR, IppsGFpState* pGF)) |
| { |
| IPP_BAD_PTR3_RET(pElmA, pElmR, pGF); |
| pGF = (IppsGFpState*)( IPP_ALIGNED_PTR(pGF, GFP_ALIGNMENT) ); |
| IPP_BADARG_RET( !GFP_TEST_ID(pGF), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmA), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmR), ippStsContextMatchErr ); |
| { |
| gsModEngine* pGFE = GFP_PMA(pGF); |
| IPP_BADARG_RET( !GFP_IS_BASIC(pGFE), ippStsBadArgErr ) |
| IPP_BADARG_RET( (GFPE_ROOM(pElmA)!=GFP_FELEN(pGFE)) || (GFPE_ROOM(pElmR)!=GFP_FELEN(pGFE)), ippStsOutOfRangeErr); |
| |
| return cpGFpSqrt(GFPE_DATA(pElmR), GFPE_DATA(pElmA), pGFE)? ippStsNoErr : ippStsQuadraticNonResidueErr; |
| } |
| } |
| |
| |
| IPPFUN(IppStatus, ippsGFpAdd,(const IppsGFpElement* pElmA, const IppsGFpElement* pElmB, |
| IppsGFpElement* pElmR, IppsGFpState* pGF)) |
| { |
| IPP_BAD_PTR4_RET(pElmA, pElmB, pElmR, pGF); |
| pGF = (IppsGFpState*)( IPP_ALIGNED_PTR(pGF, GFP_ALIGNMENT) ); |
| IPP_BADARG_RET( !GFP_TEST_ID(pGF), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmA), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmB), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmR), ippStsContextMatchErr ); |
| { |
| gsModEngine* pGFE = GFP_PMA(pGF); |
| IPP_BADARG_RET( (GFPE_ROOM(pElmA)!=GFP_FELEN(pGFE)) || (GFPE_ROOM(pElmB)!=GFP_FELEN(pGFE)) || (GFPE_ROOM(pElmR)!=GFP_FELEN(pGFE)), ippStsOutOfRangeErr); |
| |
| GFP_METHOD(pGFE)->add(GFPE_DATA(pElmR), GFPE_DATA(pElmA), GFPE_DATA(pElmB), pGFE); |
| return ippStsNoErr; |
| } |
| } |
| |
| |
| IPPFUN(IppStatus, ippsGFpSub,(const IppsGFpElement* pElmA, const IppsGFpElement* pElmB, |
| IppsGFpElement* pElmR, IppsGFpState* pGF)) |
| { |
| IPP_BAD_PTR4_RET(pElmA, pElmB, pElmR, pGF); |
| pGF = (IppsGFpState*)( IPP_ALIGNED_PTR(pGF, GFP_ALIGNMENT) ); |
| IPP_BADARG_RET( !GFP_TEST_ID(pGF), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmA), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmB), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmR), ippStsContextMatchErr ); |
| { |
| gsModEngine* pGFE = GFP_PMA(pGF); |
| IPP_BADARG_RET( (GFPE_ROOM(pElmA)!=GFP_FELEN(pGFE)) || (GFPE_ROOM(pElmB)!=GFP_FELEN(pGFE)) || (GFPE_ROOM(pElmR)!=GFP_FELEN(pGFE)), ippStsOutOfRangeErr); |
| |
| GFP_METHOD(pGFE)->sub(GFPE_DATA(pElmR), GFPE_DATA(pElmA), GFPE_DATA(pElmB), pGFE); |
| return ippStsNoErr; |
| } |
| } |
| |
| IPPFUN(IppStatus, ippsGFpMul,(const IppsGFpElement* pElmA, const IppsGFpElement* pElmB, |
| IppsGFpElement* pElmR, IppsGFpState* pGF)) |
| { |
| IPP_BAD_PTR4_RET(pElmA, pElmB, pElmR, pGF); |
| pGF = (IppsGFpState*)( IPP_ALIGNED_PTR(pGF, GFP_ALIGNMENT) ); |
| IPP_BADARG_RET( !GFP_TEST_ID(pGF), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmA), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmB), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmR), ippStsContextMatchErr ); |
| { |
| gsModEngine* pGFE = GFP_PMA(pGF); |
| IPP_BADARG_RET( (GFPE_ROOM(pElmA)!=GFP_FELEN(pGFE)) || (GFPE_ROOM(pElmB)!=GFP_FELEN(pGFE)) || (GFPE_ROOM(pElmR)!=GFP_FELEN(pGFE)), ippStsOutOfRangeErr); |
| |
| GFP_METHOD(pGFE)->mul(GFPE_DATA(pElmR), GFPE_DATA(pElmA), GFPE_DATA(pElmB),pGFE); |
| return ippStsNoErr; |
| } |
| } |
| |
| IPPFUN(IppStatus, ippsGFpSqr,(const IppsGFpElement* pElmA, |
| IppsGFpElement* pElmR, IppsGFpState* pGF)) |
| { |
| IPP_BAD_PTR3_RET(pElmA, pElmR, pGF); |
| pGF = (IppsGFpState*)( IPP_ALIGNED_PTR(pGF, GFP_ALIGNMENT) ); |
| IPP_BADARG_RET( !GFP_TEST_ID(pGF), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmA), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmR), ippStsContextMatchErr ); |
| { |
| gsModEngine* pGFE = GFP_PMA(pGF); |
| IPP_BADARG_RET( (GFPE_ROOM(pElmA)!=GFP_FELEN(pGFE)) || (GFPE_ROOM(pElmR)!=GFP_FELEN(pGFE)), ippStsOutOfRangeErr); |
| |
| GFP_METHOD(pGFE)->sqr(GFPE_DATA(pElmR), GFPE_DATA(pElmA), pGFE); |
| return ippStsNoErr; |
| } |
| } |
| |
| IPPFUN(IppStatus, ippsGFpAdd_PE,(const IppsGFpElement* pElmA, const IppsGFpElement* pParentElmB, |
| IppsGFpElement* pElmR, IppsGFpState* pGF)) |
| { |
| IPP_BAD_PTR4_RET(pElmA, pParentElmB, pElmR, pGF); |
| pGF = (IppsGFpState*)( IPP_ALIGNED_PTR(pGF, GFP_ALIGNMENT) ); |
| IPP_BADARG_RET( !GFP_TEST_ID(pGF), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmA), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pParentElmB), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmR), ippStsContextMatchErr ); |
| { |
| gsModEngine* pGFE = GFP_PMA(pGF); |
| IPP_BADARG_RET( GFP_IS_BASIC(pGFE), ippStsBadArgErr ) |
| IPP_BADARG_RET( (GFPE_ROOM(pElmA)!=GFP_FELEN(pGFE)) || (GFPE_ROOM(pElmR)!=GFP_FELEN(pGFE)), ippStsOutOfRangeErr); |
| IPP_BADARG_RET( (GFPE_ROOM(pParentElmB)!=GFP_FELEN(GFP_PARENT(pGFE))), ippStsOutOfRangeErr); |
| |
| cpGFpxAdd_GFE(GFPE_DATA(pElmR), GFPE_DATA(pElmA), GFPE_DATA(pParentElmB), pGFE); |
| return ippStsNoErr; |
| } |
| } |
| |
| IPPFUN(IppStatus, ippsGFpSub_PE,(const IppsGFpElement* pElmA, const IppsGFpElement* pParentElmB, |
| IppsGFpElement* pElmR, IppsGFpState* pGF)) |
| { |
| IPP_BAD_PTR4_RET(pElmA, pParentElmB, pElmR, pGF); |
| pGF = (IppsGFpState*)( IPP_ALIGNED_PTR(pGF, GFP_ALIGNMENT) ); |
| IPP_BADARG_RET( !GFP_TEST_ID(pGF), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmA), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pParentElmB), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmR), ippStsContextMatchErr ); |
| { |
| gsModEngine* pGFE = GFP_PMA(pGF); |
| IPP_BADARG_RET( GFP_IS_BASIC(pGFE), ippStsBadArgErr ) |
| IPP_BADARG_RET( (GFPE_ROOM(pElmA)!=GFP_FELEN(pGFE)) || (GFPE_ROOM(pElmR)!=GFP_FELEN(pGFE)), ippStsOutOfRangeErr); |
| IPP_BADARG_RET( (GFPE_ROOM(pParentElmB)!=GFP_FELEN(GFP_PARENT(pGFE))), ippStsOutOfRangeErr); |
| |
| cpGFpxSub_GFE(GFPE_DATA(pElmR), GFPE_DATA(pElmA), GFPE_DATA(pParentElmB), pGFE); |
| return ippStsNoErr; |
| } |
| } |
| |
| IPPFUN(IppStatus, ippsGFpMul_PE,(const IppsGFpElement* pElmA, const IppsGFpElement* pParentElmB, |
| IppsGFpElement* pElmR, IppsGFpState* pGF)) |
| { |
| IPP_BAD_PTR4_RET(pElmA, pParentElmB, pElmR, pGF); |
| pGF = (IppsGFpState*)( IPP_ALIGNED_PTR(pGF, GFP_ALIGNMENT) ); |
| IPP_BADARG_RET( !GFP_TEST_ID(pGF), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmA), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pParentElmB), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmR), ippStsContextMatchErr ); |
| { |
| gsModEngine* pGFE = GFP_PMA(pGF); |
| IPP_BADARG_RET( GFP_IS_BASIC(pGFE), ippStsBadArgErr ) |
| IPP_BADARG_RET( (GFPE_ROOM(pElmA)!=GFP_FELEN(pGFE)) || (GFPE_ROOM(pElmR)!=GFP_FELEN(pGFE)), ippStsOutOfRangeErr); |
| IPP_BADARG_RET( (GFPE_ROOM(pParentElmB)!=GFP_FELEN(GFP_PARENT(pGFE))), ippStsOutOfRangeErr); |
| |
| cpGFpxMul_GFE(GFPE_DATA(pElmR), GFPE_DATA(pElmA), GFPE_DATA(pParentElmB), pGFE); |
| return ippStsNoErr; |
| } |
| } |
| |
| IPPFUN(IppStatus, ippsGFpExp,(const IppsGFpElement* pElmA, const IppsBigNumState* pE, |
| IppsGFpElement* pElmR, IppsGFpState* pGF, |
| Ipp8u* pScratchBuffer)) |
| { |
| IPP_BAD_PTR4_RET(pElmA, pE, pElmR, pGF); |
| pGF = (IppsGFpState*)( IPP_ALIGNED_PTR(pGF, GFP_ALIGNMENT) ); |
| IPP_BADARG_RET( !GFP_TEST_ID(pGF), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmA), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmR), ippStsContextMatchErr ); |
| |
| pE = (IppsBigNumState*)( IPP_ALIGNED_PTR(pE, BN_ALIGNMENT) ); |
| IPP_BADARG_RET( !BN_VALID_ID(pE), ippStsContextMatchErr ); |
| { |
| gsModEngine* pGFE = GFP_PMA(pGF); |
| IPP_BADARG_RET( (GFPE_ROOM(pElmA)!=GFP_FELEN(pGFE)) || (GFPE_ROOM(pElmR)!=GFP_FELEN(pGFE)), ippStsOutOfRangeErr); |
| |
| cpGFpxExp(GFPE_DATA(pElmR), GFPE_DATA(pElmA), BN_NUMBER(pE), BN_SIZE(pE), pGFE, pScratchBuffer); |
| return ippStsNoErr; |
| } |
| } |
| |
| IPPFUN(IppStatus, ippsGFpMultiExp,(const IppsGFpElement* const ppElmA[], const IppsBigNumState* const ppE[], int nItems, |
| IppsGFpElement* pElmR, IppsGFpState* pGF, |
| Ipp8u* pScratchBuffer)) |
| { |
| IPP_BAD_PTR2_RET(ppElmA, ppE); |
| |
| if(nItems==1) |
| return ippsGFpExp(ppElmA[0], ppE[0], pElmR, pGF, pScratchBuffer); |
| |
| else { |
| /* test number of exponents */ |
| IPP_BADARG_RET(1>nItems || nItems>IPP_MAX_EXPONENT_NUM, ippStsBadArgErr); |
| |
| IPP_BAD_PTR2_RET(pElmR, pGF); |
| |
| pGF = (IppsGFpState*)( IPP_ALIGNED_PTR(pGF, GFP_ALIGNMENT) ); |
| IPP_BADARG_RET( !GFP_TEST_ID(pGF), ippStsContextMatchErr ); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmR), ippStsContextMatchErr ); |
| { |
| int n; |
| |
| gsModEngine* pGFE = GFP_PMA(pGF); |
| IPP_BADARG_RET( GFPE_ROOM(pElmR)!=GFP_FELEN(pGFE), ippStsOutOfRangeErr); |
| |
| /* test all ppElmA[] and ppE[] pairs */ |
| for(n=0; n<nItems; n++) { |
| const IppsGFpElement* pElmA = ppElmA[n]; |
| const IppsBigNumState* pE = ppE[n]; |
| IPP_BAD_PTR2_RET(pElmA, pE); |
| |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElmA), ippStsContextMatchErr ); |
| pE = (IppsBigNumState*)( IPP_ALIGNED_PTR(pE, BN_ALIGNMENT) ); |
| IPP_BADARG_RET( !BN_VALID_ID(pE), ippStsContextMatchErr ); |
| |
| IPP_BADARG_RET( (GFPE_ROOM(pElmA)!=GFP_FELEN(pGFE)) || (GFPE_ROOM(pElmR)!=GFP_FELEN(pGFE)), ippStsOutOfRangeErr); |
| } |
| |
| if(NULL==pScratchBuffer) { |
| mod_mul mulF = GFP_METHOD(pGFE)->mul; |
| |
| BNU_CHUNK_T* pTmpR = cpGFpGetPool(1, pGFE); |
| //gres: temporary excluded: assert(NULL!=pTmpR); |
| |
| cpGFpxExp(GFPE_DATA(pElmR), GFPE_DATA(ppElmA[0]), BN_NUMBER(ppE[0]), BN_SIZE(ppE[0]), pGFE, 0); |
| for(n=1; n<nItems; n++) { |
| cpGFpxExp(pTmpR, GFPE_DATA(ppElmA[n]), BN_NUMBER(ppE[n]), BN_SIZE(ppE[n]), pGFE, 0); |
| mulF(GFPE_DATA(pElmR), GFPE_DATA(pElmR), pTmpR, pGFE); |
| } |
| |
| cpGFpReleasePool(1, pGFE); |
| } |
| |
| else { |
| const BNU_CHUNK_T* ppAdata[IPP_MAX_EXPONENT_NUM]; |
| const BNU_CHUNK_T* ppEdata[IPP_MAX_EXPONENT_NUM]; |
| int nsEdataLen[IPP_MAX_EXPONENT_NUM]; |
| for(n=0; n<nItems; n++) { |
| ppAdata[n] = GFPE_DATA(ppElmA[n]); |
| ppEdata[n] = BN_NUMBER(ppE[n]); |
| nsEdataLen[n] = BN_SIZE(ppE[n]); |
| } |
| cpGFpxMultiExp(GFPE_DATA(pElmR), ppAdata, ppEdata, nsEdataLen, nItems, pGFE, pScratchBuffer); |
| } |
| |
| return ippStsNoErr; |
| } |
| } |
| } |
| |
| /*F* |
| // Name: ippsGFpSetElementHash |
| // |
| // Purpose: Set GF Element Hash of the Message |
| // |
| // Returns: Reason: |
| // ippStsNullPtrErr NULL == pGF |
| // NULL == pElm |
| // NULL == pMsg if msgLen>0 |
| // |
| // ippStsNotSupportedModeErr hashID is not supported |
| // |
| // ippStsContextMatchErr invalid pGF->idCtx |
| // invalid pElm->idCtx |
| // |
| // ippStsOutOfRangeErr GFPE_ROOM() != GFP_FELEN() |
| // |
| // ippStsNoErr no error |
| // |
| // Parameters: |
| // pMsg pointer to the message is beinh hashed |
| // msgLen length of the message above |
| // pElm pointer to Finite Field Element context |
| // pGF pointer to Finite Field context |
| // hashID applied hash algothith ID |
| *F*/ |
| IPPFUN(IppStatus, ippsGFpSetElementHash,(const Ipp8u* pMsg, int msgLen, IppsGFpElement* pElm, IppsGFpState* pGF, IppHashAlgId hashID)) |
| { |
| /* get algorithm id */ |
| hashID = cpValidHashAlg(hashID); |
| IPP_BADARG_RET(ippHashAlg_Unknown==hashID, ippStsNotSupportedModeErr); |
| |
| /* test message length and pointer */ |
| IPP_BADARG_RET((msgLen<0), ippStsLengthErr); |
| IPP_BADARG_RET((msgLen && !pMsg), ippStsNullPtrErr); |
| |
| IPP_BAD_PTR2_RET(pElm, pGF); |
| pGF = (IppsGFpState*)( IPP_ALIGNED_PTR(pGF, GFP_ALIGNMENT) ); |
| IPP_BADARG_RET( !GFP_TEST_ID(pGF), ippStsContextMatchErr); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElm), ippStsContextMatchErr); |
| { |
| gsModEngine* pGFE = GFP_PMA(pGF); |
| IPP_BADARG_RET( !GFP_IS_BASIC(pGFE), ippStsBadArgErr); |
| IPP_BADARG_RET( GFPE_ROOM(pElm)!=GFP_FELEN(pGFE), ippStsOutOfRangeErr); |
| |
| { |
| Ipp8u md[MAX_HASH_SIZE]; |
| BNU_CHUNK_T hashVal[(MAX_HASH_SIZE*8)/BITSIZE(BNU_CHUNK_T)+1]; /* +1 to meet cpMod_BNU() implementtaion specific */ |
| IppStatus sts = ippsHashMessage(pMsg, msgLen, md, hashID); |
| |
| if(ippStsNoErr==sts) { |
| int elemLen = GFP_FELEN(pGFE); |
| int hashLen = cpHashAlgAttr[hashID].hashSize; |
| int hashValLen = cpFromOctStr_BNU(hashVal, md, hashLen); |
| hashValLen = cpMod_BNU(hashVal, hashValLen, GFP_MODULUS(pGFE), elemLen); |
| cpGFpSet(GFPE_DATA(pElm), hashVal, hashValLen, pGFE); |
| } |
| |
| return sts; |
| } |
| } |
| } |
| |
| IPPFUN(IppStatus, ippsGFpSetElementHash_rmf,(const Ipp8u* pMsg, int msgLen, IppsGFpElement* pElm, IppsGFpState* pGF, const IppsHashMethod* pMethod)) |
| { |
| /* test method pointer */ |
| IPP_BAD_PTR1_RET(pMethod); |
| |
| /* test message length and pointer */ |
| IPP_BADARG_RET((msgLen<0), ippStsLengthErr); |
| IPP_BADARG_RET((msgLen && !pMsg), ippStsNullPtrErr); |
| |
| IPP_BAD_PTR2_RET(pElm, pGF); |
| pGF = (IppsGFpState*)( IPP_ALIGNED_PTR(pGF, GFP_ALIGNMENT) ); |
| IPP_BADARG_RET( !GFP_TEST_ID(pGF), ippStsContextMatchErr); |
| IPP_BADARG_RET( !GFPE_TEST_ID(pElm), ippStsContextMatchErr); |
| { |
| gsModEngine* pGFE = GFP_PMA(pGF); |
| IPP_BADARG_RET( !GFP_IS_BASIC(pGFE), ippStsBadArgErr); |
| IPP_BADARG_RET( GFPE_ROOM(pElm)!=GFP_FELEN(pGFE), ippStsOutOfRangeErr); |
| |
| { |
| Ipp8u md[MAX_HASH_SIZE]; |
| BNU_CHUNK_T hashVal[(MAX_HASH_SIZE*8)/BITSIZE(BNU_CHUNK_T)+1]; /* +1 to meet cpMod_BNU() implementtaion specific */ |
| IppStatus sts = ippsHashMessage_rmf(pMsg, msgLen, md, pMethod); |
| |
| if(ippStsNoErr==sts) { |
| int elemLen = GFP_FELEN(pGFE); |
| int hashLen = pMethod->hashLen; |
| int hashValLen = cpFromOctStr_BNU(hashVal, md, hashLen); |
| hashValLen = cpMod_BNU(hashVal, hashValLen, GFP_MODULUS(pGFE), elemLen); |
| cpGFpSet(GFPE_DATA(pElm), hashVal, hashValLen, pGFE); |
| } |
| |
| return sts; |
| } |
| } |
| } |
