mirror of
git://projects.qi-hardware.com/openwrt-xburst.git
synced 2024-12-05 03:42:49 +02:00
94a17b96c4
git-svn-id: svn://svn.openwrt.org/openwrt/trunk@32672 3c298f89-4303-0410-b956-a3cf2f4a3e73
3097 lines
104 KiB
C
3097 lines
104 KiB
C
/*******************************************************************************
|
|
Copyright (C) Marvell International Ltd. and its affiliates
|
|
|
|
This software file (the "File") is owned and distributed by Marvell
|
|
International Ltd. and/or its affiliates ("Marvell") under the following
|
|
alternative licensing terms. Once you have made an election to distribute the
|
|
File under one of the following license alternatives, please (i) delete this
|
|
introductory statement regarding license alternatives, (ii) delete the two
|
|
license alternatives that you have not elected to use and (iii) preserve the
|
|
Marvell copyright notice above.
|
|
|
|
********************************************************************************
|
|
Marvell Commercial License Option
|
|
|
|
If you received this File from Marvell and you have entered into a commercial
|
|
license agreement (a "Commercial License") with Marvell, the File is licensed
|
|
to you under the terms of the applicable Commercial License.
|
|
|
|
********************************************************************************
|
|
Marvell GPL License Option
|
|
|
|
If you received this File from Marvell, you may opt to use, redistribute and/or
|
|
modify this File in accordance with the terms and conditions of the General
|
|
Public License Version 2, June 1991 (the "GPL License"), a copy of which is
|
|
available along with the File in the license.txt file or by writing to the Free
|
|
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 or
|
|
on the worldwide web at http://www.gnu.org/licenses/gpl.txt.
|
|
|
|
THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE IMPLIED
|
|
WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE ARE EXPRESSLY
|
|
DISCLAIMED. The GPL License provides additional details about this warranty
|
|
disclaimer.
|
|
********************************************************************************
|
|
Marvell BSD License Option
|
|
|
|
If you received this File from Marvell, you may opt to use, redistribute and/or
|
|
modify this File under the following licensing terms.
|
|
Redistribution and use in source and binary forms, with or without modification,
|
|
are permitted provided that the following conditions are met:
|
|
|
|
* Redistributions of source code must retain the above copyright notice,
|
|
this list of conditions and the following disclaimer.
|
|
|
|
* Redistributions in binary form must reproduce the above copyright
|
|
notice, this list of conditions and the following disclaimer in the
|
|
documentation and/or other materials provided with the distribution.
|
|
|
|
* Neither the name of Marvell nor the names of its contributors may be
|
|
used to endorse or promote products derived from this software without
|
|
specific prior written permission.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
|
|
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
|
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*******************************************************************************/
|
|
|
|
#include "mvOs.h"
|
|
|
|
#if defined(MV_VXWORKS)
|
|
|
|
#include "sysLib.h"
|
|
#include "logLib.h"
|
|
#include "tickLib.h"
|
|
#include "intLib.h"
|
|
#include "config.h"
|
|
|
|
|
|
SEM_ID cesaSemId = NULL;
|
|
SEM_ID cesaWaitSemId = NULL;
|
|
|
|
#define CESA_TEST_LOCK(flags) flags = intLock()
|
|
#define CESA_TEST_UNLOCK(flags) intUnlock(flags)
|
|
|
|
#define CESA_TEST_WAIT_INIT() cesaWaitSemId = semBCreate(SEM_Q_PRIORITY, SEM_EMPTY)
|
|
#define CESA_TEST_WAKE_UP() semGive(cesaWaitSemId)
|
|
#define CESA_TEST_WAIT(cond, ms) semTake(cesaWaitSemId, (sysClkRateGet()*ms)/1000)
|
|
|
|
#define CESA_TEST_TICK_GET() tickGet()
|
|
#define CESA_TEST_TICK_TO_MS(tick) (((tick)*1000)/sysClkRateGet())
|
|
|
|
#elif defined(MV_LINUX)
|
|
|
|
#include <linux/wait.h>
|
|
wait_queue_head_t cesaTest_waitq;
|
|
spinlock_t cesaLock;
|
|
|
|
#define CESA_TEST_LOCK(flags) spin_lock_irqsave( &cesaLock, flags)
|
|
#define CESA_TEST_UNLOCK(flags) spin_unlock_irqrestore( &cesaLock, flags);
|
|
|
|
#define CESA_TEST_WAIT_INIT() init_waitqueue_head(&cesaTest_waitq)
|
|
#define CESA_TEST_WAKE_UP() wake_up(&cesaTest_waitq)
|
|
#define CESA_TEST_WAIT(cond, ms) wait_event_timeout(cesaTest_waitq, (cond), msecs_to_jiffies(ms))
|
|
|
|
#define CESA_TEST_TICK_GET() jiffies
|
|
#define CESA_TEST_TICK_TO_MS(tick) jiffies_to_msecs(tick)
|
|
|
|
#elif defined(MV_NETBSD)
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/kernel.h>
|
|
static int cesaLock;
|
|
|
|
#define CESA_TEST_LOCK(flags) flags = splnet()
|
|
#define CESA_TEST_UNLOCK(flags) splx(flags)
|
|
|
|
#define CESA_TEST_WAIT_INIT() /* nothing */
|
|
#define CESA_TEST_WAKE_UP() wakeup(&cesaLock)
|
|
#define CESA_TEST_WAIT(cond, ms) \
|
|
do { \
|
|
while (!(cond)) \
|
|
tsleep(&cesaLock, PWAIT, "cesatest",mstohz(ms)); \
|
|
} while (/*CONSTCOND*/0)
|
|
|
|
#define CESA_TEST_TICK_GET() hardclock_ticks
|
|
#define CESA_TEST_TICK_TO_MS(tick) ((1000/hz)*(tick))
|
|
|
|
#define request_irq(i,h,t,n,a) \
|
|
!mv_intr_establish((i),IPL_NET,(int(*)(void *))(h),(a))
|
|
|
|
#else
|
|
#error "Only Linux, VxWorks, or NetBSD OS are supported"
|
|
#endif
|
|
|
|
#include "mvDebug.h"
|
|
|
|
#include "mvSysHwConfig.h"
|
|
#include "boardEnv/mvBoardEnvLib.h"
|
|
#include "ctrlEnv/sys/mvCpuIf.h"
|
|
#include "cntmr/mvCntmr.h"
|
|
#include "cesa/mvCesa.h"
|
|
#include "cesa/mvCesaRegs.h"
|
|
#include "cesa/mvMD5.h"
|
|
#include "cesa/mvSHA1.h"
|
|
|
|
#if defined(CONFIG_MV646xx)
|
|
#include "marvell_pic.h"
|
|
#endif
|
|
|
|
#define MV_CESA_USE_TIMER_ID 0
|
|
#define CESA_DEF_BUF_SIZE 1500
|
|
#define CESA_DEF_BUF_NUM 1
|
|
#define CESA_DEF_SESSION_NUM 32
|
|
|
|
#define CESA_DEF_ITER_NUM 100
|
|
|
|
#define CESA_DEF_REQ_SIZE 256
|
|
|
|
|
|
/* CESA Tests Debug */
|
|
#undef CESA_TEST_DEBUG
|
|
|
|
#ifdef CESA_TEST_DEBUG
|
|
|
|
# define CESA_TEST_DEBUG_PRINT(msg) mvOsPrintf msg
|
|
# define CESA_TEST_DEBUG_CODE(code) code
|
|
|
|
typedef struct
|
|
{
|
|
int type; /* 0 - isrEmpty, 1 - cesaReadyGet, 2 - cesaAction */
|
|
MV_U32 timeStamp;
|
|
MV_U32 cause;
|
|
MV_U32 realCause;
|
|
MV_U32 dmaCause;
|
|
int resources;
|
|
MV_CESA_REQ* pReqReady;
|
|
MV_CESA_REQ* pReqEmpty;
|
|
MV_CESA_REQ* pReqProcess;
|
|
} MV_CESA_TEST_TRACE;
|
|
|
|
#define MV_CESA_TEST_TRACE_SIZE 25
|
|
|
|
static int cesaTestTraceIdx = 0;
|
|
static MV_CESA_TEST_TRACE cesaTestTrace[MV_CESA_TEST_TRACE_SIZE];
|
|
|
|
static void cesaTestTraceAdd(int type, MV_U32 cause)
|
|
{
|
|
cesaTestTrace[cesaTestTraceIdx].type = type;
|
|
cesaTestTrace[cesaTestTraceIdx].cause = cause;
|
|
cesaTestTrace[cesaTestTraceIdx].realCause = MV_REG_READ(MV_CESA_ISR_CAUSE_REG);
|
|
cesaTestTrace[cesaTestTraceIdx].dmaCause = MV_REG_READ(IDMA_CAUSE_REG);
|
|
cesaTestTrace[cesaTestTraceIdx].resources = cesaReqResources;
|
|
cesaTestTrace[cesaTestTraceIdx].pReqReady = pCesaReqReady;
|
|
cesaTestTrace[cesaTestTraceIdx].pReqEmpty = pCesaReqEmpty;
|
|
cesaTestTrace[cesaTestTraceIdx].pReqProcess = pCesaReqProcess;
|
|
cesaTestTrace[cesaTestTraceIdx].timeStamp = mvCntmrRead(MV_CESA_USE_TIMER_ID);
|
|
cesaTestTraceIdx++;
|
|
if(cesaTestTraceIdx == MV_CESA_TEST_TRACE_SIZE)
|
|
cesaTestTraceIdx = 0;
|
|
}
|
|
|
|
#else
|
|
|
|
# define CESA_TEST_DEBUG_PRINT(msg)
|
|
# define CESA_TEST_DEBUG_CODE(code)
|
|
|
|
#endif /* CESA_TEST_DEBUG */
|
|
|
|
int cesaExpReqId=0;
|
|
int cesaCbIter=0;
|
|
|
|
int cesaIdx;
|
|
int cesaIteration;
|
|
int cesaRateSize;
|
|
int cesaReqSize;
|
|
unsigned long cesaTaskId;
|
|
int cesaBufNum;
|
|
int cesaBufSize;
|
|
int cesaCheckOffset;
|
|
int cesaCheckSize;
|
|
int cesaCheckMode;
|
|
int cesaTestIdx;
|
|
int cesaCaseIdx;
|
|
|
|
|
|
MV_U32 cesaTestIsrCount = 0;
|
|
MV_U32 cesaTestIsrMissCount = 0;
|
|
|
|
MV_U32 cesaCryptoError = 0;
|
|
MV_U32 cesaReqIdError = 0;
|
|
MV_U32 cesaError = 0;
|
|
|
|
char* cesaHexBuffer = NULL;
|
|
|
|
char* cesaBinBuffer = NULL;
|
|
char* cesaExpBinBuffer = NULL;
|
|
|
|
char* cesaInputHexStr = NULL;
|
|
char* cesaOutputHexStr = NULL;
|
|
|
|
MV_BUF_INFO cesaReqBufs[CESA_DEF_REQ_SIZE];
|
|
|
|
MV_CESA_COMMAND* cesaCmdRing;
|
|
MV_CESA_RESULT cesaResult;
|
|
|
|
int cesaTestFull = 0;
|
|
|
|
MV_BOOL cesaIsReady = MV_FALSE;
|
|
MV_U32 cesaCycles = 0;
|
|
MV_U32 cesaBeginTicks = 0;
|
|
MV_U32 cesaEndTicks = 0;
|
|
MV_U32 cesaRate = 0;
|
|
MV_U32 cesaRateAfterDot = 0;
|
|
|
|
void *cesaTestOSHandle = NULL;
|
|
|
|
enum
|
|
{
|
|
CESA_FAST_CHECK_MODE = 0,
|
|
CESA_FULL_CHECK_MODE,
|
|
CESA_NULL_CHECK_MODE,
|
|
CESA_SHOW_CHECK_MODE,
|
|
CESA_SW_SHOW_CHECK_MODE,
|
|
CESA_SW_NULL_CHECK_MODE,
|
|
|
|
CESA_MAX_CHECK_MODE
|
|
};
|
|
|
|
enum
|
|
{
|
|
DES_TEST_TYPE = 0,
|
|
TRIPLE_DES_TEST_TYPE = 1,
|
|
AES_TEST_TYPE = 2,
|
|
MD5_TEST_TYPE = 3,
|
|
SHA_TEST_TYPE = 4,
|
|
COMBINED_TEST_TYPE = 5,
|
|
|
|
MAX_TEST_TYPE
|
|
};
|
|
|
|
/* Tests data base */
|
|
typedef struct
|
|
{
|
|
short sid;
|
|
char cryptoAlgorithm; /* DES/3DES/AES */
|
|
char cryptoMode; /* ECB or CBC */
|
|
char macAlgorithm; /* MD5 / SHA1 */
|
|
char operation; /* CRYPTO/HMAC/CRYPTO+HMAC/HMAC+CRYPTO */
|
|
char direction; /* ENCODE(SIGN)/DECODE(VERIFY) */
|
|
unsigned char* pCryptoKey;
|
|
int cryptoKeySize;
|
|
unsigned char* pMacKey;
|
|
int macKeySize;
|
|
const char* name;
|
|
|
|
} MV_CESA_TEST_SESSION;
|
|
|
|
typedef struct
|
|
{
|
|
MV_CESA_TEST_SESSION* pSessions;
|
|
int numSessions;
|
|
|
|
} MV_CESA_TEST_DB_ENTRY;
|
|
|
|
typedef struct
|
|
{
|
|
char* plainHexStr;
|
|
char* cipherHexStr;
|
|
unsigned char* pCryptoIV;
|
|
int cryptoLength;
|
|
int macLength;
|
|
int digestOffset;
|
|
|
|
} MV_CESA_TEST_CASE;
|
|
|
|
typedef struct
|
|
{
|
|
int size;
|
|
const char* outputHexStr;
|
|
|
|
} MV_CESA_SIZE_TEST;
|
|
|
|
static unsigned char cryptoKey1[] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
|
|
0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
|
|
0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef};
|
|
|
|
static unsigned char cryptoKey7[] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef};
|
|
static unsigned char iv1[] = {0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef};
|
|
|
|
|
|
static unsigned char cryptoKey2[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
|
|
0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F};
|
|
|
|
static unsigned char cryptoKey3[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
|
|
0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
|
|
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17};
|
|
|
|
static unsigned char cryptoKey4[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
|
|
0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
|
|
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
|
|
0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f};
|
|
|
|
static unsigned char cryptoKey5[] = {0x56, 0xe4, 0x7a, 0x38, 0xc5, 0x59, 0x89, 0x74,
|
|
0xbc, 0x46, 0x90, 0x3d, 0xba, 0x29, 0x03, 0x49};
|
|
|
|
|
|
static unsigned char key3des1[] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
|
|
0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01,
|
|
0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01, 0x23};
|
|
|
|
/* Input ASCII string: The quick brown fox jump */
|
|
static char plain3des1[] = "54686520717566636B2062726F776E20666F78206A756D70";
|
|
static char cipher3des1[] = "A826FD8CE53B855FCCE21C8112256FE668D5C05DD9B6B900";
|
|
|
|
static unsigned char key3des2[] = {0x62, 0x7f, 0x46, 0x0e, 0x08, 0x10, 0x4a, 0x10,
|
|
0x43, 0xcd, 0x26, 0x5d, 0x58, 0x40, 0xea, 0xf1,
|
|
0x31, 0x3e, 0xdf, 0x97, 0xdf, 0x2a, 0x8a, 0x8c};
|
|
|
|
static unsigned char iv3des2[] = {0x8e, 0x29, 0xf7, 0x5e, 0xa7, 0x7e, 0x54, 0x75};
|
|
|
|
static char plain3des2[] = "326a494cd33fe756";
|
|
|
|
static char cipher3desCbc2[] = "8e29f75ea77e5475"
|
|
"b22b8d66de970692";
|
|
|
|
static unsigned char key3des3[] = {0x37, 0xae, 0x5e, 0xbf, 0x46, 0xdf, 0xf2, 0xdc,
|
|
0x07, 0x54, 0xb9, 0x4f, 0x31, 0xcb, 0xb3, 0x85,
|
|
0x5e, 0x7f, 0xd3, 0x6d, 0xc8, 0x70, 0xbf, 0xae};
|
|
|
|
static unsigned char iv3des3[] = {0x3d, 0x1d, 0xe3, 0xcc, 0x13, 0x2e, 0x3b, 0x65};
|
|
|
|
static char plain3des3[] = "84401f78fe6c10876d8ea23094ea5309";
|
|
|
|
static char cipher3desCbc3[] = "3d1de3cc132e3b65"
|
|
"7b1f7c7e3b1c948ebd04a75ffba7d2f5";
|
|
|
|
static unsigned char iv5[] = {0x8c, 0xe8, 0x2e, 0xef, 0xbe, 0xa0, 0xda, 0x3c,
|
|
0x44, 0x69, 0x9e, 0xd7, 0xdb, 0x51, 0xb7, 0xd9};
|
|
|
|
static unsigned char aesCtrKey[] = {0x76, 0x91, 0xBE, 0x03, 0x5E, 0x50, 0x20, 0xA8,
|
|
0xAC, 0x6E, 0x61, 0x85, 0x29, 0xF9, 0xA0, 0xDC};
|
|
|
|
static unsigned char mdKey1[] = {0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
|
|
0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b};
|
|
|
|
static unsigned char mdKey2[] = {0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
|
|
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa};
|
|
|
|
static unsigned char shaKey1[] = {0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
|
|
0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
|
|
0x0b, 0x0b, 0x0b, 0x0b};
|
|
|
|
static unsigned char shaKey2[] = {0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
|
|
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
|
|
0xaa, 0xaa, 0xaa, 0xaa};
|
|
|
|
static unsigned char mdKey4[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
|
|
0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10};
|
|
|
|
static unsigned char shaKey4[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
|
|
0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
|
|
0x11, 0x12, 0x13, 0x14};
|
|
|
|
|
|
static MV_CESA_TEST_SESSION desTestSessions[] =
|
|
{
|
|
/*000*/ {-1, MV_CESA_CRYPTO_DES, MV_CESA_CRYPTO_ECB,
|
|
MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
|
|
MV_CESA_DIR_ENCODE,
|
|
cryptoKey7, sizeof(cryptoKey7)/sizeof(cryptoKey7[0]),
|
|
NULL, 0,
|
|
"DES ECB encode",
|
|
},
|
|
/*001*/ {-1, MV_CESA_CRYPTO_DES, MV_CESA_CRYPTO_ECB,
|
|
MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
|
|
MV_CESA_DIR_DECODE,
|
|
cryptoKey7, sizeof(cryptoKey7)/sizeof(cryptoKey7[0]),
|
|
NULL, 0,
|
|
"DES ECB decode",
|
|
},
|
|
/*002*/ {-1, MV_CESA_CRYPTO_DES, MV_CESA_CRYPTO_CBC,
|
|
MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
|
|
MV_CESA_DIR_ENCODE,
|
|
cryptoKey7, sizeof(cryptoKey7)/sizeof(cryptoKey7[0]),
|
|
NULL, 0,
|
|
"DES CBC encode"
|
|
},
|
|
/*003*/ {-1, MV_CESA_CRYPTO_DES, MV_CESA_CRYPTO_CBC,
|
|
MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
|
|
MV_CESA_DIR_DECODE,
|
|
cryptoKey7, sizeof(cryptoKey7)/sizeof(cryptoKey7[0]),
|
|
NULL, 0,
|
|
"DES CBC decode"
|
|
},
|
|
/*004*/ {-1, MV_CESA_CRYPTO_NULL, MV_CESA_CRYPTO_ECB,
|
|
MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
|
|
MV_CESA_DIR_ENCODE,
|
|
NULL, 0, NULL, 0,
|
|
"NULL Crypto Algorithm encode"
|
|
},
|
|
};
|
|
|
|
|
|
static MV_CESA_TEST_SESSION tripleDesTestSessions[] =
|
|
{
|
|
/*100*/ {-1, MV_CESA_CRYPTO_3DES, MV_CESA_CRYPTO_ECB,
|
|
MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
|
|
MV_CESA_DIR_ENCODE,
|
|
cryptoKey1, sizeof(cryptoKey1)/sizeof(cryptoKey1[0]),
|
|
NULL, 0,
|
|
"3DES ECB encode",
|
|
},
|
|
/*101*/ {-1, MV_CESA_CRYPTO_3DES, MV_CESA_CRYPTO_ECB,
|
|
MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
|
|
MV_CESA_DIR_DECODE,
|
|
cryptoKey1, sizeof(cryptoKey1)/sizeof(cryptoKey1[0]),
|
|
NULL, 0,
|
|
"3DES ECB decode",
|
|
},
|
|
/*102*/ {-1, MV_CESA_CRYPTO_3DES, MV_CESA_CRYPTO_CBC,
|
|
MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
|
|
MV_CESA_DIR_ENCODE,
|
|
cryptoKey1, sizeof(cryptoKey1)/sizeof(cryptoKey1[0]),
|
|
NULL, 0,
|
|
"3DES CBC encode"
|
|
},
|
|
/*103*/ {-1, MV_CESA_CRYPTO_3DES, MV_CESA_CRYPTO_CBC,
|
|
MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
|
|
MV_CESA_DIR_DECODE,
|
|
cryptoKey1, sizeof(cryptoKey1)/sizeof(cryptoKey1[0]),
|
|
NULL, 0,
|
|
"3DES CBC decode"
|
|
},
|
|
/*104*/ {-1, MV_CESA_CRYPTO_3DES, MV_CESA_CRYPTO_ECB,
|
|
MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
|
|
MV_CESA_DIR_ENCODE,
|
|
key3des1, sizeof(key3des1),
|
|
NULL, 0,
|
|
"3DES ECB encode"
|
|
},
|
|
/*105*/ {-1, MV_CESA_CRYPTO_3DES, MV_CESA_CRYPTO_CBC,
|
|
MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
|
|
MV_CESA_DIR_ENCODE,
|
|
key3des2, sizeof(key3des2),
|
|
NULL, 0,
|
|
"3DES ECB encode"
|
|
},
|
|
/*106*/ {-1, MV_CESA_CRYPTO_3DES, MV_CESA_CRYPTO_CBC,
|
|
MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
|
|
MV_CESA_DIR_ENCODE,
|
|
key3des3, sizeof(key3des3),
|
|
NULL, 0,
|
|
"3DES ECB encode"
|
|
},
|
|
};
|
|
|
|
|
|
static MV_CESA_TEST_SESSION aesTestSessions[] =
|
|
{
|
|
/*200*/ {-1, MV_CESA_CRYPTO_AES, MV_CESA_CRYPTO_ECB,
|
|
MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
|
|
MV_CESA_DIR_ENCODE,
|
|
cryptoKey2, sizeof(cryptoKey2)/sizeof(cryptoKey2[0]),
|
|
NULL, 0,
|
|
"AES-128 ECB encode"
|
|
},
|
|
/*201*/ {-1, MV_CESA_CRYPTO_AES, MV_CESA_CRYPTO_ECB,
|
|
MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
|
|
MV_CESA_DIR_DECODE,
|
|
cryptoKey2, sizeof(cryptoKey2)/sizeof(cryptoKey2[0]),
|
|
NULL, 0,
|
|
"AES-128 ECB decode"
|
|
},
|
|
/*202*/ {-1, MV_CESA_CRYPTO_AES, MV_CESA_CRYPTO_CBC,
|
|
MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
|
|
MV_CESA_DIR_ENCODE,
|
|
cryptoKey5, sizeof(cryptoKey5)/sizeof(cryptoKey5[0]),
|
|
NULL, 0,
|
|
"AES-128 CBC encode"
|
|
},
|
|
/*203*/ {-1, MV_CESA_CRYPTO_AES, MV_CESA_CRYPTO_CBC,
|
|
MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
|
|
MV_CESA_DIR_DECODE,
|
|
cryptoKey5, sizeof(cryptoKey5)/sizeof(cryptoKey5[0]),
|
|
NULL, 0,
|
|
"AES-128 CBC decode"
|
|
},
|
|
/*204*/ {-1, MV_CESA_CRYPTO_AES, MV_CESA_CRYPTO_ECB,
|
|
MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
|
|
MV_CESA_DIR_ENCODE,
|
|
cryptoKey3, sizeof(cryptoKey3)/sizeof(cryptoKey3[0]),
|
|
NULL, 0,
|
|
"AES-192 ECB encode"
|
|
},
|
|
/*205*/ {-1, MV_CESA_CRYPTO_AES, MV_CESA_CRYPTO_ECB,
|
|
MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
|
|
MV_CESA_DIR_DECODE,
|
|
cryptoKey3, sizeof(cryptoKey3)/sizeof(cryptoKey3[0]),
|
|
NULL, 0,
|
|
"AES-192 ECB decode"
|
|
},
|
|
/*206*/ {-1, MV_CESA_CRYPTO_AES, MV_CESA_CRYPTO_ECB,
|
|
MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
|
|
MV_CESA_DIR_ENCODE,
|
|
cryptoKey4, sizeof(cryptoKey4)/sizeof(cryptoKey4[0]),
|
|
NULL, 0,
|
|
"AES-256 ECB encode"
|
|
},
|
|
/*207*/ {-1, MV_CESA_CRYPTO_AES, MV_CESA_CRYPTO_ECB,
|
|
MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
|
|
MV_CESA_DIR_DECODE,
|
|
cryptoKey4, sizeof(cryptoKey4)/sizeof(cryptoKey4[0]),
|
|
NULL, 0,
|
|
"AES-256 ECB decode"
|
|
},
|
|
/*208*/ {-1, MV_CESA_CRYPTO_AES, MV_CESA_CRYPTO_CTR,
|
|
MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
|
|
MV_CESA_DIR_ENCODE,
|
|
aesCtrKey, sizeof(aesCtrKey)/sizeof(aesCtrKey[0]),
|
|
NULL, 0,
|
|
"AES-128 CTR encode"
|
|
},
|
|
};
|
|
|
|
|
|
static MV_CESA_TEST_SESSION md5TestSessions[] =
|
|
{
|
|
/*300*/ {-1, MV_CESA_CRYPTO_NULL, MV_CESA_CRYPTO_ECB,
|
|
MV_CESA_MAC_HMAC_MD5, MV_CESA_MAC_ONLY,
|
|
MV_CESA_DIR_ENCODE,
|
|
NULL, 0,
|
|
mdKey1, sizeof(mdKey1),
|
|
"HMAC-MD5 Generate Signature"
|
|
},
|
|
/*301*/ {-1, MV_CESA_CRYPTO_NULL, MV_CESA_CRYPTO_ECB,
|
|
MV_CESA_MAC_HMAC_MD5, MV_CESA_MAC_ONLY,
|
|
MV_CESA_DIR_DECODE,
|
|
NULL, 0,
|
|
mdKey1, sizeof(mdKey1),
|
|
"HMAC-MD5 Verify Signature"
|
|
},
|
|
/*302*/ {-1, MV_CESA_CRYPTO_NULL, MV_CESA_CRYPTO_ECB,
|
|
MV_CESA_MAC_HMAC_MD5, MV_CESA_MAC_ONLY,
|
|
MV_CESA_DIR_ENCODE,
|
|
NULL, 0,
|
|
mdKey2, sizeof(mdKey2),
|
|
"HMAC-MD5 Generate Signature"
|
|
},
|
|
/*303*/ {-1, MV_CESA_CRYPTO_NULL, MV_CESA_CRYPTO_ECB,
|
|
MV_CESA_MAC_HMAC_MD5, MV_CESA_MAC_ONLY,
|
|
MV_CESA_DIR_DECODE,
|
|
NULL, 0,
|
|
mdKey2, sizeof(mdKey2),
|
|
"HMAC-MD5 Verify Signature"
|
|
},
|
|
/*304*/ {-1, MV_CESA_CRYPTO_NULL, MV_CESA_CRYPTO_ECB,
|
|
MV_CESA_MAC_HMAC_MD5, MV_CESA_MAC_ONLY,
|
|
MV_CESA_DIR_ENCODE,
|
|
NULL, 0,
|
|
mdKey4, sizeof(mdKey4),
|
|
"HMAC-MD5 Generate Signature"
|
|
},
|
|
/*305*/ {-1, MV_CESA_CRYPTO_NULL, MV_CESA_CRYPTO_ECB,
|
|
MV_CESA_MAC_MD5, MV_CESA_MAC_ONLY,
|
|
MV_CESA_DIR_ENCODE,
|
|
NULL, 0,
|
|
NULL, 0,
|
|
"HASH-MD5 Generate Signature"
|
|
},
|
|
};
|
|
|
|
|
|
static MV_CESA_TEST_SESSION shaTestSessions[] =
|
|
{
|
|
/*400*/ {-1, MV_CESA_CRYPTO_NULL, MV_CESA_CRYPTO_ECB,
|
|
MV_CESA_MAC_HMAC_SHA1, MV_CESA_MAC_ONLY,
|
|
MV_CESA_DIR_ENCODE,
|
|
NULL, 0,
|
|
shaKey1, sizeof(shaKey1),
|
|
"HMAC-SHA1 Generate Signature"
|
|
},
|
|
/*401*/ {-1, MV_CESA_CRYPTO_NULL, MV_CESA_CRYPTO_ECB,
|
|
MV_CESA_MAC_HMAC_SHA1, MV_CESA_MAC_ONLY,
|
|
MV_CESA_DIR_DECODE,
|
|
NULL, 0,
|
|
shaKey1, sizeof(shaKey1),
|
|
"HMAC-SHA1 Verify Signature"
|
|
},
|
|
/*402*/ {-1, MV_CESA_CRYPTO_NULL, MV_CESA_CRYPTO_ECB,
|
|
MV_CESA_MAC_HMAC_SHA1, MV_CESA_MAC_ONLY,
|
|
MV_CESA_DIR_ENCODE,
|
|
NULL, 0,
|
|
shaKey2, sizeof(shaKey2),
|
|
"HMAC-SHA1 Generate Signature"
|
|
},
|
|
/*403*/ {-1, MV_CESA_CRYPTO_NULL, MV_CESA_CRYPTO_ECB,
|
|
MV_CESA_MAC_HMAC_SHA1, MV_CESA_MAC_ONLY,
|
|
MV_CESA_DIR_DECODE,
|
|
NULL, 0,
|
|
shaKey2, sizeof(shaKey2),
|
|
"HMAC-SHA1 Verify Signature"
|
|
},
|
|
/*404*/ {-1, MV_CESA_CRYPTO_NULL, MV_CESA_CRYPTO_ECB,
|
|
MV_CESA_MAC_HMAC_SHA1, MV_CESA_MAC_ONLY,
|
|
MV_CESA_DIR_ENCODE,
|
|
NULL, 0,
|
|
shaKey4, sizeof(shaKey4),
|
|
"HMAC-SHA1 Generate Signature"
|
|
},
|
|
/*405*/ {-1, MV_CESA_CRYPTO_NULL, MV_CESA_CRYPTO_ECB,
|
|
MV_CESA_MAC_SHA1, MV_CESA_MAC_ONLY,
|
|
MV_CESA_DIR_ENCODE,
|
|
NULL, 0,
|
|
NULL, 0,
|
|
"HASH-SHA1 Generate Signature"
|
|
},
|
|
};
|
|
|
|
static MV_CESA_TEST_SESSION combinedTestSessions[] =
|
|
{
|
|
/*500*/ {-1, MV_CESA_CRYPTO_DES, MV_CESA_CRYPTO_ECB,
|
|
MV_CESA_MAC_HMAC_MD5, MV_CESA_CRYPTO_THEN_MAC,
|
|
MV_CESA_DIR_ENCODE,
|
|
cryptoKey1, MV_CESA_DES_KEY_LENGTH,
|
|
mdKey4, sizeof(mdKey4),
|
|
"DES + MD5 encode"
|
|
},
|
|
/*501*/ {-1, MV_CESA_CRYPTO_DES, MV_CESA_CRYPTO_ECB,
|
|
MV_CESA_MAC_HMAC_SHA1, MV_CESA_CRYPTO_THEN_MAC,
|
|
MV_CESA_DIR_ENCODE,
|
|
cryptoKey1, MV_CESA_DES_KEY_LENGTH,
|
|
shaKey4, sizeof(shaKey4),
|
|
"DES + SHA1 encode"
|
|
},
|
|
/*502*/ {-1, MV_CESA_CRYPTO_3DES, MV_CESA_CRYPTO_ECB,
|
|
MV_CESA_MAC_HMAC_MD5, MV_CESA_CRYPTO_THEN_MAC,
|
|
MV_CESA_DIR_ENCODE,
|
|
cryptoKey1, sizeof(cryptoKey1)/sizeof(cryptoKey1[0]),
|
|
mdKey4, sizeof(mdKey4),
|
|
"3DES + MD5 encode"
|
|
},
|
|
/*503*/ {-1, MV_CESA_CRYPTO_3DES, MV_CESA_CRYPTO_ECB,
|
|
MV_CESA_MAC_HMAC_SHA1, MV_CESA_CRYPTO_THEN_MAC,
|
|
MV_CESA_DIR_ENCODE,
|
|
cryptoKey1, sizeof(cryptoKey1)/sizeof(cryptoKey1[0]),
|
|
shaKey4, sizeof(shaKey4),
|
|
"3DES + SHA1 encode"
|
|
},
|
|
/*504*/ {-1, MV_CESA_CRYPTO_3DES, MV_CESA_CRYPTO_CBC,
|
|
MV_CESA_MAC_HMAC_MD5, MV_CESA_CRYPTO_THEN_MAC,
|
|
MV_CESA_DIR_ENCODE,
|
|
cryptoKey1, sizeof(cryptoKey1)/sizeof(cryptoKey1[0]),
|
|
mdKey4, sizeof(mdKey4),
|
|
"3DES CBC + MD5 encode"
|
|
},
|
|
/*505*/ {-1, MV_CESA_CRYPTO_3DES, MV_CESA_CRYPTO_CBC,
|
|
MV_CESA_MAC_HMAC_SHA1, MV_CESA_CRYPTO_THEN_MAC,
|
|
MV_CESA_DIR_ENCODE,
|
|
cryptoKey1, sizeof(cryptoKey1)/sizeof(cryptoKey1[0]),
|
|
shaKey4, sizeof(shaKey4),
|
|
"3DES CBC + SHA1 encode"
|
|
},
|
|
/*506*/ {-1, MV_CESA_CRYPTO_AES, MV_CESA_CRYPTO_CBC,
|
|
MV_CESA_MAC_HMAC_MD5, MV_CESA_CRYPTO_THEN_MAC,
|
|
MV_CESA_DIR_ENCODE,
|
|
cryptoKey5, sizeof(cryptoKey5)/sizeof(cryptoKey5[0]),
|
|
mdKey4, sizeof(mdKey4),
|
|
"AES-128 CBC + MD5 encode"
|
|
},
|
|
/*507*/ {-1, MV_CESA_CRYPTO_AES, MV_CESA_CRYPTO_CBC,
|
|
MV_CESA_MAC_HMAC_SHA1, MV_CESA_CRYPTO_THEN_MAC,
|
|
MV_CESA_DIR_ENCODE,
|
|
cryptoKey5, sizeof(cryptoKey5)/sizeof(cryptoKey5[0]),
|
|
shaKey4, sizeof(shaKey4),
|
|
"AES-128 CBC + SHA1 encode"
|
|
},
|
|
/*508*/ {-1, MV_CESA_CRYPTO_3DES, MV_CESA_CRYPTO_ECB,
|
|
MV_CESA_MAC_HMAC_MD5, MV_CESA_MAC_THEN_CRYPTO,
|
|
MV_CESA_DIR_DECODE,
|
|
cryptoKey1, sizeof(cryptoKey1)/sizeof(cryptoKey1[0]),
|
|
mdKey4, sizeof(mdKey4),
|
|
"HMAC-MD5 + 3DES decode"
|
|
},
|
|
};
|
|
|
|
|
|
static MV_CESA_TEST_DB_ENTRY cesaTestsDB[MAX_TEST_TYPE+1] =
|
|
{
|
|
{ desTestSessions, sizeof(desTestSessions)/sizeof(desTestSessions[0]) },
|
|
{ tripleDesTestSessions, sizeof(tripleDesTestSessions)/sizeof(tripleDesTestSessions[0]) },
|
|
{ aesTestSessions, sizeof(aesTestSessions)/sizeof(aesTestSessions[0]) },
|
|
{ md5TestSessions, sizeof(md5TestSessions)/sizeof(md5TestSessions[0]) },
|
|
{ shaTestSessions, sizeof(shaTestSessions)/sizeof(shaTestSessions[0]) },
|
|
{ combinedTestSessions, sizeof(combinedTestSessions)/sizeof(combinedTestSessions[0]) },
|
|
{ NULL, 0 }
|
|
};
|
|
|
|
|
|
char cesaNullPlainHexText[] = "000000000000000000000000000000000000000000000000";
|
|
|
|
char cesaPlainAsciiText[] = "Now is the time for all ";
|
|
char cesaPlainHexEbc[] = "4e6f77206973207468652074696d6520666f7220616c6c20";
|
|
char cesaCipherHexEcb[] = "3fa40e8a984d48156a271787ab8883f9893d51ec4b563b53";
|
|
char cesaPlainHexCbc[] = "1234567890abcdef4e6f77206973207468652074696d6520666f7220616c6c20";
|
|
char cesaCipherHexCbc[] = "1234567890abcdefe5c7cdde872bf27c43e934008c389c0f683788499a7c05f6";
|
|
|
|
char cesaAesPlainHexEcb[] = "000102030405060708090a0b0c0d0e0f";
|
|
char cesaAes128cipherHexEcb[] = "0a940bb5416ef045f1c39458c653ea5a";
|
|
char cesaAes192cipherHexEcb[] = "0060bffe46834bb8da5cf9a61ff220ae";
|
|
char cesaAes256cipherHexEcb[] = "5a6e045708fb7196f02e553d02c3a692";
|
|
|
|
char cesaAsciiStr1[] = "Hi There";
|
|
char cesaDataHexStr1[] = "4869205468657265";
|
|
char cesaHmacMd5digestHex1[] = "9294727a3638bb1c13f48ef8158bfc9d";
|
|
char cesaHmacSha1digestHex1[] = "b617318655057264e28bc0b6fb378c8ef146be00";
|
|
char cesaDataAndMd5digest1[] = "48692054686572659294727a3638bb1c13f48ef8158bfc9d";
|
|
char cesaDataAndSha1digest1[] = "4869205468657265b617318655057264e28bc0b6fb378c8ef146be00";
|
|
|
|
char cesaAesPlainText[] = "a0a1a2a3a4a5a6a7a8a9aaabacadaeaf"
|
|
"b0b1b2b3b4b5b6b7b8b9babbbcbdbebf"
|
|
"c0c1c2c3c4c5c6c7c8c9cacbcccdcecf"
|
|
"d0d1d2d3d4d5d6d7d8d9dadbdcdddedf";
|
|
|
|
char cesaAes128CipherCbc[] = "c30e32ffedc0774e6aff6af0869f71aa"
|
|
"0f3af07a9a31a9c684db207eb0ef8e4e"
|
|
"35907aa632c3ffdf868bb7b29d3d46ad"
|
|
"83ce9f9a102ee99d49a53e87f4c3da55";
|
|
|
|
char cesaAesIvPlainText[] = "8ce82eefbea0da3c44699ed7db51b7d9"
|
|
"a0a1a2a3a4a5a6a7a8a9aaabacadaeaf"
|
|
"b0b1b2b3b4b5b6b7b8b9babbbcbdbebf"
|
|
"c0c1c2c3c4c5c6c7c8c9cacbcccdcecf"
|
|
"d0d1d2d3d4d5d6d7d8d9dadbdcdddedf";
|
|
|
|
char cesaAes128IvCipherCbc[] = "8ce82eefbea0da3c44699ed7db51b7d9"
|
|
"c30e32ffedc0774e6aff6af0869f71aa"
|
|
"0f3af07a9a31a9c684db207eb0ef8e4e"
|
|
"35907aa632c3ffdf868bb7b29d3d46ad"
|
|
"83ce9f9a102ee99d49a53e87f4c3da55";
|
|
|
|
char cesaAesCtrPlain[] = "00E0017B27777F3F4A1786F000000001"
|
|
"000102030405060708090A0B0C0D0E0F"
|
|
"101112131415161718191A1B1C1D1E1F"
|
|
"20212223";
|
|
|
|
char cesaAesCtrCipher[] = "00E0017B27777F3F4A1786F000000001"
|
|
"C1CF48A89F2FFDD9CF4652E9EFDB72D7"
|
|
"4540A42BDE6D7836D59A5CEAAEF31053"
|
|
"25B2072F";
|
|
|
|
|
|
|
|
/* Input cesaHmacHex3 is '0xdd' repeated 50 times */
|
|
char cesaHmacMd5digestHex3[] = "56be34521d144c88dbb8c733f0e8b3f6";
|
|
char cesaHmacSha1digestHex3[] = "125d7342b9ac11cd91a39af48aa17b4f63f175d3";
|
|
char cesaDataHexStr3[50*2+1] = "";
|
|
char cesaDataAndMd5digest3[sizeof(cesaDataHexStr3)+sizeof(cesaHmacMd5digestHex3)+8*2+1] = "";
|
|
char cesaDataAndSha1digest3[sizeof(cesaDataHexStr3)+sizeof(cesaHmacSha1digestHex3)+8*2+1] = "";
|
|
|
|
/* Ascii string is "abc" */
|
|
char hashHexStr3[] = "616263";
|
|
char hashMd5digest3[] = "900150983cd24fb0d6963f7d28e17f72";
|
|
char hashSha1digest3[] = "a9993e364706816aba3e25717850c26c9cd0d89d";
|
|
|
|
char hashHexStr80[] = "31323334353637383930"
|
|
"31323334353637383930"
|
|
"31323334353637383930"
|
|
"31323334353637383930"
|
|
"31323334353637383930"
|
|
"31323334353637383930"
|
|
"31323334353637383930"
|
|
"31323334353637383930";
|
|
|
|
char hashMd5digest80[] = "57edf4a22be3c955ac49da2e2107b67a";
|
|
|
|
char tripleDesThenMd5digest80[] = "b7726a03aad490bd6c5a452a89a1b271";
|
|
char tripleDesThenSha1digest80[] = "b2ddeaca91030eab5b95a234ef2c0f6e738ff883";
|
|
|
|
char cbc3desThenMd5digest80[] = "6f463057e1a90e0e91ae505b527bcec0";
|
|
char cbc3desThenSha1digest80[] = "1b002ed050be743aa98860cf35659646bb8efcc0";
|
|
|
|
char cbcAes128ThenMd5digest80[] = "6b6e863ac5a71d15e3e9b1c86c9ba05f";
|
|
char cbcAes128ThenSha1digest80[] = "13558472d1fc1c90dffec6e5136c7203452d509b";
|
|
|
|
|
|
static MV_CESA_TEST_CASE cesaTestCases[] =
|
|
{
|
|
/* plainHexStr cipherHexStr IV crypto mac digest */
|
|
/* Length Length Offset */
|
|
/*0*/ { NULL, NULL, NULL, 0, 0, -1 },
|
|
/*1*/ { cesaPlainHexEbc, cesaCipherHexEcb, NULL, 24, 0, -1 },
|
|
/*2*/ { cesaPlainHexCbc, cesaCipherHexCbc, NULL, 24, 0, -1 },
|
|
/*3*/ { cesaAesPlainHexEcb, cesaAes128cipherHexEcb, NULL, 16, 0, -1 },
|
|
/*4*/ { cesaAesPlainHexEcb, cesaAes192cipherHexEcb, NULL, 16, 0, -1 },
|
|
/*5*/ { cesaAesPlainHexEcb, cesaAes256cipherHexEcb, NULL, 16, 0, -1 },
|
|
/*6*/ { cesaDataHexStr1, cesaHmacMd5digestHex1, NULL, 0, 8, -1 },
|
|
/*7*/ { NULL, cesaDataAndMd5digest1, NULL, 0, 8, -1 },
|
|
/*8*/ { cesaDataHexStr3, cesaHmacMd5digestHex3, NULL, 0, 50, -1 },
|
|
/*9*/ { NULL, cesaDataAndMd5digest3, NULL, 0, 50, -1 },
|
|
/*10*/ { cesaAesPlainText, cesaAes128IvCipherCbc, iv5, 64, 0, -1 },
|
|
/*11*/ { cesaDataHexStr1, cesaHmacSha1digestHex1, NULL, 0, 8, -1 },
|
|
/*12*/ { NULL, cesaDataAndSha1digest1, NULL, 0, 8, -1 },
|
|
/*13*/ { cesaDataHexStr3, cesaHmacSha1digestHex3, NULL, 0, 50, -1 },
|
|
/*14*/ { NULL, cesaDataAndSha1digest3, NULL, 0, 50, -1 },
|
|
/*15*/ { hashHexStr3, hashMd5digest3, NULL, 0, 3, -1 },
|
|
/*16*/ { hashHexStr3, hashSha1digest3, NULL, 0, 3, -1 },
|
|
/*17*/ { hashHexStr80, tripleDesThenMd5digest80, NULL, 80, 80, -1 },
|
|
/*18*/ { hashHexStr80, tripleDesThenSha1digest80, NULL, 80, 80, -1 },
|
|
/*19*/ { hashHexStr80, cbc3desThenMd5digest80, iv1, 80, 80, -1 },
|
|
/*20*/ { hashHexStr80, cbc3desThenSha1digest80, iv1, 80, 80, -1 },
|
|
/*21*/ { hashHexStr80, cbcAes128ThenMd5digest80, iv5, 80, 80, -1 },
|
|
/*22*/ { hashHexStr80, cbcAes128ThenSha1digest80, iv5, 80, 80, -1 },
|
|
/*23*/ { cesaAesCtrPlain, cesaAesCtrCipher, NULL, 36, 0, -1 },
|
|
/*24*/ { cesaAesIvPlainText, cesaAes128IvCipherCbc, NULL, 64, 0, -1 },
|
|
/*25*/ { plain3des1, cipher3des1, NULL, 0, 0, -1 },
|
|
/*26*/ { plain3des2, cipher3desCbc2, iv3des2,0, 0, -1 },
|
|
/*27*/ { plain3des3, cipher3desCbc3, iv3des3,0, 0, -1 },
|
|
};
|
|
|
|
|
|
/* Key = 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
|
|
* 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa
|
|
* Input 0xdd repeated "size" times
|
|
*/
|
|
static MV_CESA_SIZE_TEST mdMultiSizeTest302[] =
|
|
{
|
|
{ 80, "7a031a640c14a4872814930b1ef3a5b2" },
|
|
{ 512, "5488e6c5a14dc72a79f28312ca5b939b" },
|
|
{ 1000, "d00814f586a8b78a05724239d2531821" },
|
|
{ 1001, "bf07df7b7f49d3f5b5ecacd4e9e63281" },
|
|
{ 1002, "1ed4a1a802e87817a819d4e37bb4d0f7" },
|
|
{ 1003, "5972ab64a4f265ee371dac2f2f137f90" },
|
|
{ 1004, "71f95e7ec3aa7df2548e90898abdb28e" },
|
|
{ 1005, "e082790b4857fcfc266e92e59e608814" },
|
|
{ 1006, "9500f02fd8ac7fde8b10e4fece9a920d" },
|
|
{ 1336, "e42edcce57d0b75b01aa09d71427948b" },
|
|
{ 1344, "bb5454ada0deb49ba0a97ffd60f57071" },
|
|
{ 1399, "0f44d793e744b24d53f44f295082ee8c" },
|
|
{ 1400, "359de8a03a9b707928c6c60e0e8d79f1" },
|
|
{ 1401, "e913858b484cbe2b384099ea88d8855b" },
|
|
{ 1402, "d9848a164af53620e0540c1d7d87629e" },
|
|
{ 1403, "0c9ee1c2c9ef45e9b625c26cbaf3e822" },
|
|
{ 1404, "12edd4f609416e3c936170360561b064" },
|
|
{ 1405, "7fc912718a05446395345009132bf562" },
|
|
{ 1406, "882f17425e579ff0d85a91a59f308aa0" },
|
|
{ 1407, "005cae408630a2fb5db82ad9db7e59da" },
|
|
{ 1408, "64655f8b404b3fea7a3e3e609bc5088f" },
|
|
{ 1409, "4a145284a7f74e01b6bb1a0ec6a0dd80" },
|
|
{ 2048, "67caf64475650732def374ebb8bde3fd" },
|
|
{ 2049, "6c84f11f472825f7e6cd125c2981884b" },
|
|
{ 2050, "8999586754a73a99efbe4dbad2816d41" },
|
|
{ 2051, "ba6946b610e098d286bc81091659dfff" },
|
|
{ 2052, "d0afa01c92d4d13def2b024f36faed83" },
|
|
{ 3072, "61d8beac61806afa2585d74a9a0e6974" },
|
|
{ 3074, "f6501a28dcc24d1e4770505c51a87ed3" },
|
|
{ 3075, "ea4a6929be67e33e61ff475369248b73" },
|
|
{ 4048, "aa8c4d68f282a07e7385acdfa69f4bed" },
|
|
{ 4052, "afb5ed2c0e1d430ea59e59ed5ed6b18a" },
|
|
{ 4058, "9e8553f9bdd43aebe0bd729f0e600c99" },
|
|
{ 6144, "f628f3e5d183fe5cdd3a5abee39cf872" },
|
|
{ 6150, "89a3efcea9a2f25f919168ad4a1fd292" },
|
|
{ 6400, "cdd176b7fb747873efa4da5e32bdf88f" },
|
|
{ 6528, "b1d707b027354aca152c45ee559ccd3f" },
|
|
{ 8192, "c600ea4429ac47f9941f09182166e51a" },
|
|
{16384, "16e8754bfbeb4c649218422792267a37" },
|
|
{18432, "0fd0607521b0aa8b52219cfbe215f63e" },
|
|
{ 0, NULL },
|
|
};
|
|
|
|
/* Key = 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
|
|
* 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10
|
|
* InputHexStr = "31323334353637383930" (ASCII = "1234567890")
|
|
*/
|
|
static MV_CESA_SIZE_TEST mdMultiSizeTest304[] =
|
|
{
|
|
{ 80, "a456c4723fee6068530af5a2afa71627" },
|
|
{ 512, "f85c2a2344f5de68b432208ad13e5794" },
|
|
{ 1000, "35464d6821fd4a293a41eb84e274c8c5" },
|
|
{ 1001, "c08eedbdce60cceb54bc2d732bb32c8b" },
|
|
{ 1002, "5664f71800c011cc311cb6943339c1b8" },
|
|
{ 1003, "779c723b044c585dc7802b13e8501bdc" },
|
|
{ 1004, "55e500766a2c307bc5c5fdd15e4cacd4" },
|
|
{ 1005, "d5f978954f5c38529d1679d2b714f068" },
|
|
{ 1006, "cd3efc827ce628b7281b72172693abf9" },
|
|
{ 1336, "6f04479910785878ae6335b8d1e87edf" },
|
|
{ 1344, "b6d27b50c2bce1ba2a8e1b5cc4324368" },
|
|
{ 1399, "65f70a1d4c86e5eaeb0704c8a7816795" },
|
|
{ 1400, "3394b5adc4cb3ff98843ca260a44a88a" },
|
|
{ 1401, "3a06f3582033a66a4e57e0603ce94e74" },
|
|
{ 1402, "e4d97f5ed51edc48abfa46eeb5c31752" },
|
|
{ 1403, "3d05e40b080ee3bedf293cb87b7140e7" },
|
|
{ 1404, "8cf294fc3cd153ab18dccb2a52cbf244" },
|
|
{ 1405, "d1487bd42f6edd9b4dab316631159221" },
|
|
{ 1406, "0527123b6bf6936cf5d369dc18c6c70f" },
|
|
{ 1407, "3224a06639db70212a0cd1ae1fcc570a" },
|
|
{ 1408, "a9e13335612c0356f5e2c27086e86c43" },
|
|
{ 1409, "a86d1f37d1ed8a3552e9a4f04dceea98" },
|
|
{ 2048, "396905c9b961cd0f6152abfb69c4449c" },
|
|
{ 2049, "49f39bff85d9dcf059fadb89efc4a70f" },
|
|
{ 2050, "3a2b4823bc4d0415656550226a63e34a" },
|
|
{ 2051, "dec60580d406c782540f398ad0bcc7e0" },
|
|
{ 2052, "32f76610a14310309eb748fe025081bf" },
|
|
{ 3072, "45edc1a42bf9d708a621076b63b774da" },
|
|
{ 3074, "9be1b333fe7c0c9f835fb369dc45f778" },
|
|
{ 3075, "8c06fcac7bd0e7b7a17fd6508c09a549" },
|
|
{ 4048, "0ddaef848184bf0ad98507a10f1e90e4" },
|
|
{ 4052, "81976bcaeb274223983996c137875cb8" },
|
|
{ 4058, "0b0a7a1c82bc7cbc64d8b7cd2dc2bb22" },
|
|
{ 6144, "1c24056f52725ede2dff0d7f9fc9855f" },
|
|
{ 6150, "b7f4b65681c4e43ee68ca466ca9ca4ec" },
|
|
{ 6400, "443bbaab9f7331ddd4bf11b659cd43c8" },
|
|
{ 6528, "216f44f23047cfee03a7a64f88f9a995" },
|
|
{ 8192, "ac7a993b2cad54879dba1bde63e39097" },
|
|
{ 8320, "55ed7be9682d6c0025b3221a62088d08" },
|
|
{16384, "c6c722087653b62007aea668277175e5" },
|
|
{18432, "f1faca8e907872c809e14ffbd85792d6" },
|
|
{ 0, NULL },
|
|
};
|
|
|
|
/* HASH-MD5
|
|
* InputHexStr = "31323334353637383930" (ASCII = "1234567890")
|
|
* repeated "size" times
|
|
*/
|
|
static MV_CESA_SIZE_TEST mdMultiSizeTest305[] =
|
|
{
|
|
{ 80, "57edf4a22be3c955ac49da2e2107b67a" },
|
|
{ 512, "c729ae8f0736cc377a9767a660eaa04e" },
|
|
{ 1000, "f1257a8659eb92d36fe14c6bf3852a6a" },
|
|
{ 1001, "f8a46fe8ea04fdc8c7de0e84042d3878" },
|
|
{ 1002, "da188dd67bff87d58aa3c02af2d0cc0f" },
|
|
{ 1003, "961753017feee04c9b93a8e51658a829" },
|
|
{ 1004, "dd68c4338608dcc87807a711636bf2af" },
|
|
{ 1005, "e338d567d3ce66bf69ada29658a8759b" },
|
|
{ 1006, "443c9811e8b92599b0b149e8d7ec700a" },
|
|
{ 1336, "89a98511706008ba4cbd0b4a24fa5646" },
|
|
{ 1344, "335a919805f370b9e402a62c6fe01739" },
|
|
{ 1399, "5d18d0eddcd84212fe28d812b5e80e3b" },
|
|
{ 1400, "6b695c240d2dffd0dffc99459ca76db6" },
|
|
{ 1401, "49590f61298a76719bc93a57a30136f5" },
|
|
{ 1402, "94c2999fa3ef1910a683d69b2b8476f2" },
|
|
{ 1403, "37073a02ab00ecba2645c57c228860db" },
|
|
{ 1404, "1bcd06994fce28b624f0c5fdc2dcdd2b" },
|
|
{ 1405, "11b93671a64c95079e8cf9e7cddc8b3d" },
|
|
{ 1406, "4b6695772a4c66313fa4871017d05f36" },
|
|
{ 1407, "d1539b97fbfda1c075624e958de19c5b" },
|
|
{ 1408, "b801b9b69920907cd018e8063092ede9" },
|
|
{ 1409, "b765f1406cfe78e238273ed01bbcaf7e" },
|
|
{ 2048, "1d7e2c64ac29e2b3fb4c272844ed31f5" },
|
|
{ 2049, "71d38fac49c6b1f4478d8d88447bcdd0" },
|
|
{ 2050, "141c34a5592b1bebfa731e0b23d0cdba" },
|
|
{ 2051, "c5e1853f21c59f5d6039bd13d4b380d8" },
|
|
{ 2052, "dd44a0d128b63d4b5cccd967906472d7" },
|
|
{ 3072, "37d158e33b21390822739d13db7b87fe" },
|
|
{ 3074, "aef3b209d01d39d0597fe03634bbf441" },
|
|
{ 3075, "335ffb428eabf210bada96d74d5a4012" },
|
|
{ 4048, "2434c2b43d798d2819487a886261fc64" },
|
|
{ 4052, "ac2fa84a8a33065b2e92e36432e861f8" },
|
|
{ 4058, "856781f85616c341c3533d090c1e1e84" },
|
|
{ 6144, "e5d134c652c18bf19833e115f7a82e9b" },
|
|
{ 6150, "a09a353be7795fac2401dac5601872e6" },
|
|
{ 6400, "08b9033ac6a1821398f50af75a2dbc83" },
|
|
{ 6528, "3d47aa193a8540c091e7e02f779e6751" },
|
|
{ 8192, "d3164e710c0626f6f395b38f20141cb7" },
|
|
{ 8320, "b727589d9183ff4e8491dd24466974a3" },
|
|
{16384, "3f54d970793d2274d5b20d10a69938ac" },
|
|
{18432, "f558511dcf81985b7a1bb57fad970531" },
|
|
{ 0, NULL },
|
|
};
|
|
|
|
|
|
/* Key = 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
|
|
* 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa
|
|
* 0xaa, 0xaa, 0xaa, 0xaa
|
|
* InputHexStr = "31323334353637383930" (ASCII = "1234567890")
|
|
*/
|
|
static MV_CESA_SIZE_TEST shaMultiSizeTest402[] =
|
|
{
|
|
{ 80, "e812f370e659705a1649940d1f78cd7af18affd3" },
|
|
{ 512, "e547f886b2c15d995ed76a8a924cb408c8080f66" },
|
|
{ 1000, "239443194409f1a5342ecde1a092c8f3a3ed790a" },
|
|
{ 1001, "f278ab9a102850a9f48dc4e9e6822afe2d0c52b5" },
|
|
{ 1002, "8bcc667df5ab6ece988b3af361d09747c77f4e72" },
|
|
{ 1003, "0fae6046c7dc1d3e356b25af836f6077a363f338" },
|
|
{ 1004, "0ea48401cc92ae6bc92ae76685269cb0167fbe1a" },
|
|
{ 1005, "ecbcd7c879b295bafcd8766cbeac58cc371e31d1" },
|
|
{ 1006, "eb4a4a3d07d1e9a15e6f1ab8a9c47f243e27324c" },
|
|
{ 1336, "f5950ee1d77c10e9011d2149699c9366fe52529c" },
|
|
{ 1344, "b04263604a63c351b0b3b9cf1785b4bdba6c8838" },
|
|
{ 1399, "8cb1cff61d5b784045974a2fc69386e3b8d24218" },
|
|
{ 1400, "9bb2f3fcbeddb2b90f0be797cd647334a2816d51" },
|
|
{ 1401, "23ae462a7a0cb440f7445791079a5d75a535dd33" },
|
|
{ 1402, "832974b524a4d3f9cc2f45a3cabf5ccef65cd2aa" },
|
|
{ 1403, "d1c683742fe404c3c20d5704a5430e7832a7ec95" },
|
|
{ 1404, "867c79042e64f310628e219d8b85594cd0c7adc3" },
|
|
{ 1405, "c9d81d49d13d94358f56ccfd61af02b36c69f7c3" },
|
|
{ 1406, "0df43daab2786172f9b8d07d61f14a070cf1287a" },
|
|
{ 1407, "0fd8f3ad7f169534b274d4c66bbddd89f759e391" },
|
|
{ 1408, "3987511182b18473a564436003139b808fa46343" },
|
|
{ 1409, "ef667e063c9e9f539a8987a8d0bd3066ee85d901" },
|
|
{ 2048, "921109c99f3fedaca21727156d5f2b4460175327" },
|
|
{ 2049, "47188600dd165eb45f27c27196d3c46f4f042c1b" },
|
|
{ 2050, "8831939904009338de10e7fa670847041387807d" },
|
|
{ 2051, "2f8ebb5db2997d614e767be1050366f3641e7520" },
|
|
{ 2052, "669e51cd730dae158d3bef8adba075bd95a0d011" },
|
|
{ 3072, "cfee66cfd83abc8451af3c96c6b35a41cc6c55f5" },
|
|
{ 3074, "216ea26f02976a261b7d21a4dd3085157bedfabd" },
|
|
{ 3075, "bd612ebba021fd8e012b14c3bd60c8c5161fabc0" },
|
|
{ 4048, "c2564c1fdf2d5e9d7dde7aace2643428e90662e8" },
|
|
{ 4052, "91ce61fe924b445dfe7b5a1dcd10a27caec16df6" },
|
|
{ 4058, "db2a9be5ee8124f091c7ebd699266c5de223c164" },
|
|
{ 6144, "855109903feae2ba3a7a05a326b8a171116eb368" },
|
|
{ 6150, "37520bb3a668294d9c7b073e7e3daf8fee248a78" },
|
|
{ 6400, "60a353c841b6d2b1a05890349dad2fa33c7536b7" },
|
|
{ 6528, "9e53a43a69bb42d7c8522ca8bd632e421d5edb36" },
|
|
{ 8192, "a918cb0da862eaea0a33ee0efea50243e6b4927c" },
|
|
{ 8320, "29a5dcf55d1db29cd113fcf0572ae414f1c71329" },
|
|
{16384, "6fb27966138e0c8d5a0d65ace817ebd53633cee1" },
|
|
{18432, "ca09900d891c7c9ae2a559b10f63a217003341c1" },
|
|
{ 0, NULL },
|
|
};
|
|
|
|
/* Key = 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
|
|
* 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10
|
|
* 0x11, 0x12, 0x13, 0x14
|
|
* InputHexStr = "31323334353637383930" (ASCII = "1234567890")
|
|
*/
|
|
static MV_CESA_SIZE_TEST shaMultiSizeTest404[] =
|
|
{
|
|
{ 80, "beaf20a34b06a87558d156c0949bc3957d40222e" },
|
|
{ 512, "3353955358d886bc2940a3c7f337ff7dafb59c7b" },
|
|
{ 1000, "8737a542c5e9b2b6244b757ebb69d5bd602a829f" },
|
|
{ 1001, "fd9e7582d8a5d3c9fe3b923e4e6a41b07a1eb4d4" },
|
|
{ 1002, "a146d14a6fc3c274ff600568f4d75b977989e00d" },
|
|
{ 1003, "be22601bbc027ddef2dec97d30b3dc424fd803c5" },
|
|
{ 1004, "3e71fe99b2fe2b7bfdf4dbf0c7f3da25d7ea35e7" },
|
|
{ 1005, "2c422735d7295408fddd76f5e8a83a2a8da13df3" },
|
|
{ 1006, "6d875319049314b61855101a647b9ba3313428e6" },
|
|
{ 1336, "c1631ea80bad9dc43a180712461b65a0598c711c" },
|
|
{ 1344, "816069bf91d34581005746e2e0283d0f9c7b7605" },
|
|
{ 1399, "4e139866dc61cfcb8b67ca2ebd637b3a538593af" },
|
|
{ 1400, "ff2a0f8dd2b02c5417910f6f55d33a78e081a723" },
|
|
{ 1401, "ab00c12be62336964cbce31ae97fe2a0002984d5" },
|
|
{ 1402, "61349e7f999f3a1acc56c3e9a5060a9c4a7b05b6" },
|
|
{ 1403, "3edbc0f61e435bc1317fa27d840076093fb79353" },
|
|
{ 1404, "d052c6dfdbe63d45dab23ef9893e2aa4636aca1e" },
|
|
{ 1405, "0cc16b7388d67bf0add15a31e6e6c753cfae4987" },
|
|
{ 1406, "c96ba7eaad74253c38c22101b558d2850b1d1b90" },
|
|
{ 1407, "3445428a40d2c6556e7c55797ad8d323b61a48d9" },
|
|
{ 1408, "8d6444f937a09317c89834187b8ea9b8d3a8c56b" },
|
|
{ 1409, "c700acd3ecd19014ea2bdb4d42510c467e088475" },
|
|
{ 2048, "ee27d2a0cb77470c2f496212dfd68b5bb7b04e4b" },
|
|
{ 2049, "683762d7a02983b26a6d046e6451d9cd82c25932" },
|
|
{ 2050, "0fd20f1d55a9ee18363c2a6fd54aa13aee69992f" },
|
|
{ 2051, "86c267d8cc4bc8d59090e4f8b303da960fd228b7" },
|
|
{ 2052, "452395ae05b3ec503eea34f86fc0832485ad97c1" },
|
|
{ 3072, "75198e3cfd0b9bcff2dabdf8e38e6fdaa33ca49a" },
|
|
{ 3074, "4e24785ef080141ce4aab4675986d9acea624d7c" },
|
|
{ 3075, "3a20c5978dd637ec0e809bf84f0d9ccf30bc65bf" },
|
|
{ 4048, "3c32da256be7a7554922bf5fed51b0d2d09e59ad" },
|
|
{ 4052, "fff898426ea16e54325ae391a32c6c9bce4c23c0" },
|
|
{ 4058, "c800b9e562e1c91e1310116341a3c91d37f848ec" },
|
|
{ 6144, "d91d509d0cc4376c2d05bf9a5097717a373530e6" },
|
|
{ 6150, "d957030e0f13c5df07d9eec298542d8f94a07f12" },
|
|
{ 6400, "bb745313c3d7dc17b3f955e5534ad500a1082613" },
|
|
{ 6528, "77905f80d9ca82080bbb3e5654896dabfcfd1bdb" },
|
|
{ 8192, "5237fd9a81830c974396f99f32047586612ff3c0" },
|
|
{ 8320, "57668e28d5f2dba0839518a11db0f6af3d7e08bf" },
|
|
{16384, "62e093fde467f0748087beea32e9af97d5c61241" },
|
|
{18432, "845fb33130c7d6ea554fd5aacb9c50cf7ccb5929" },
|
|
{ 0, NULL },
|
|
};
|
|
|
|
/* HASH-SHA1
|
|
* InputHexStr = "31323334353637383930" (ASCII = "1234567890")
|
|
* repeated "size" times
|
|
*/
|
|
static MV_CESA_SIZE_TEST shaMultiSizeTest405[] =
|
|
{
|
|
{ 80, "50abf5706a150990a08b2c5ea40fa0e585554732" },
|
|
{ 512, "f14516a08948fa27917a974d219741a697ba0087" },
|
|
{ 1000, "0bd18c378d5788817eb4f1e5dc07d867efa5cbf4" },
|
|
{ 1001, "ca29b85c35db1b8aef83c977893a11159d1b7aa2" },
|
|
{ 1002, "d83bc973eaaedb8a31437994dabbb3304b0be086" },
|
|
{ 1003, "2cf7bbef0acd6c00536b5c58ca470df9a3a90b6c" },
|
|
{ 1004, "e4375d09b1223385a8a393066f8209acfd936a80" },
|
|
{ 1005, "1029b38043e027745d019ce1d2d68e3d8b9d8f99" },
|
|
{ 1006, "deea16dcebbd8ac137e2b984deb639b9fb5e9680" },
|
|
{ 1336, "ea031b065fff63dcfb6a41956e4777520cdbc55d" },
|
|
{ 1344, "b52096c6445e6c0a8355995c70dc36ae186c863c" },
|
|
{ 1399, "cde2f6f8379870db4b32cf17471dc828a8dbff2b" },
|
|
{ 1400, "e53ff664064bc09fe5054c650806bd42d8179518" },
|
|
{ 1401, "d1156db5ddafcace64cdb510ff0d4af9b9a8ad64" },
|
|
{ 1402, "34ede0e9a909dd84a2ae291539105c0507b958e1" },
|
|
{ 1403, "a772ca3536da77e6ad3251e4f9e1234a4d7b87c0" },
|
|
{ 1404, "29740fd2b04e7a8bfd32242db6233156ad699948" },
|
|
{ 1405, "65b17397495b70ce4865dad93bf991b74c97cce1" },
|
|
{ 1406, "a7ee89cd0754061fdb91af7ea6abad2c69d542e3" },
|
|
{ 1407, "3eebf82f7420188e23d328b7ce93580b279a5715" },
|
|
{ 1408, "e08d3363a8b9a490dfb3a4c453452b8f114deeec" },
|
|
{ 1409, "95d74df739181a4ff30b8c39e28793a36598e924" },
|
|
{ 2048, "aa40262509c2abf84aab0197f83187fc90056d91" },
|
|
{ 2049, "7dec28ef105bc313bade8d9a7cdeac58b99de5ea" },
|
|
{ 2050, "d2e30f77ec81197de20f56588a156094ecb88450" },
|
|
{ 2051, "6b22ccc874833e96551a39da0c0edcaa0d969d92" },
|
|
{ 2052, "f843141e57875cd669af58744bc60aa9ea59549c" },
|
|
{ 3072, "09c5fedeaa62c132e673cc3c608a00142273d086" },
|
|
{ 3074, "b09e95eea9c7b1b007a58accec488301901a7f3d" },
|
|
{ 3075, "e6226b77b4ada287a8c9bbcf4ed71eec5ce632dc" },
|
|
{ 4048, "e99394894f855821951ddddf5bfc628547435f5c" },
|
|
{ 4052, "32d2f1af38be9cfba6cd03d55a254d0b3e1eb382" },
|
|
{ 4058, "d906552a4f2aca3a22e1fecccbcd183d7289d0ef" },
|
|
{ 6144, "2e7f62d35a860988e1224dc0543204af19316041" },
|
|
{ 6150, "d6b89698ee133df46fec9d552fadc328aa5a1b51" },
|
|
{ 6400, "dff50e90c46853988fa3a4b4ce5dda6945aae976" },
|
|
{ 6528, "9e63ec0430b96db02d38bc78357a2f63de2ab7f8" },
|
|
{ 8192, "971eb71ed60394d5ab5abb12e88420bdd41b5992" },
|
|
{ 8320, "91606a31b46afeaac965cecf87297e791b211013" },
|
|
{16384, "547f830a5ec1f5f170ce818f156b1002cabc7569" },
|
|
{18432, "f16f272787f3b8d539652e4dc315af6ab4fda0ef" },
|
|
{ 0, NULL },
|
|
};
|
|
|
|
/* CryptoKey = 0x01234567, 0x89abcdef,
|
|
* 0x01234567, 0x89abcdef,
|
|
* 0x01234567, 0x89abcdef;
|
|
* MacKey = 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
|
|
* 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10
|
|
* InputHexStr = "31323334353637383930" (ASCII = "1234567890")
|
|
* Note: only sizes aligned to 3DES block size (8 bytes) allowed
|
|
*/
|
|
static MV_CESA_SIZE_TEST tripleDesMdMultiSizeTest502[] =
|
|
{
|
|
{ 64, "9586962a2aaaef28803dec2e17807a7f" },
|
|
{ 80, "b7726a03aad490bd6c5a452a89a1b271" },
|
|
{ 352, "f1ed9563aecc3c0d2766eb2bed3b4e4c" },
|
|
{ 512, "0f9decb11ab40fe86f4d4d9397bc020e" },
|
|
{ 1000, "3ba69deac12cab8ff9dff7dbd9669927" },
|
|
{ 1336, "6cf47bf1e80e03e2c1d0945bc50d37d2" },
|
|
{ 1344, "4be388dab21ceb3fa1b8d302e9b821f7" },
|
|
{ 1400, "a58b79fb21dd9bfc6ec93e3b99fb0ef1" },
|
|
{ 1408, "8bc97379fc2ac3237effcdd4f7a86528" },
|
|
{ 2048, "1339f03ab3076f25a20bc4cba16eb5bf" },
|
|
{ 3072, "731204d2d90c4b36ae41f5e1fb874288" },
|
|
{ 4048, "c028d998cfda5642547b7e1ed5ea16e4" },
|
|
{ 6144, "b1b19cd910cc51bd22992f1e59f1e068" },
|
|
{ 6400, "44e4613496ba622deb0e7cb768135a2f" },
|
|
{ 6528, "3b06b0a86f8db9cd67f9448dfcf10549" },
|
|
{ 8192, "d581780b7163138a0f412be681457d82" },
|
|
{16384, "03b8ac05527faaf1bed03df149c65ccf" },
|
|
{18432, "677c8a86a41dab6c5d81b85b8fb10ff6" },
|
|
{ 0, NULL },
|
|
};
|
|
|
|
|
|
/* CryptoKey = 0x01234567, 0x89abcdef,
|
|
* 0x01234567, 0x89abcdef,
|
|
* 0x01234567, 0x89abcdef;
|
|
* MacKey = 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
|
|
* 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10
|
|
* 0x11, 0x12, 0x13, 0x14
|
|
* InputHexStr = "31323334353637383930" (ASCII = "1234567890")
|
|
* Note: only sizes aligned to 3DES block size (8 bytes) allowed
|
|
*/
|
|
static MV_CESA_SIZE_TEST tripleDesShaMultiSizeTest503[] =
|
|
{
|
|
{ 64, "44a1e9bcbfc1429630d9ea68b7a48b0427a684f2" },
|
|
{ 80, "b2ddeaca91030eab5b95a234ef2c0f6e738ff883" },
|
|
{ 352, "4b91864c7ff629bdff75d9726421f76705452aaf" },
|
|
{ 512, "6dd37faceeb2aa98ba74f4242ed6734a4d546af5" },
|
|
{ 1000, "463661c30300be512a9df40904f0757cde5f1141" },
|
|
{ 1336, "b931f831d9034fe59c65176400b039fe9c1f44a5" },
|
|
{ 1344, "af8866b1cd4a4887d6185bfe72470ffdfb3648e1" },
|
|
{ 1400, "49c6caf07296d5e31d2504d088bc5b20c3ee7cdb" },
|
|
{ 1408, "fcae8deedbc6ebf0763575dc7e9de075b448a0f4" },
|
|
{ 2048, "edece5012146c1faa0dd10f50b183ba5d2af58ac" },
|
|
{ 3072, "5b83625adb43a488b8d64fecf39bb766818547b7" },
|
|
{ 4048, "d2c533678d26c970293af60f14c8279dc708bfc9" },
|
|
{ 6144, "b8f67af4f991b08b725f969b049ebf813bfacc5c" },
|
|
{ 6400, "d9a6c7f746ac7a60ef2edbed2841cf851c25cfb0" },
|
|
{ 6528, "376792b8c8d18161d15579fb7829e6e3a27e9946" },
|
|
{ 8192, "d890eabdca195b34ef8724b28360cffa92ae5655" },
|
|
{16384, "a167ee52639ec7bf19aee9c6e8f76667c14134b9" },
|
|
{18432, "e4396ab56f67296b220985a12078f4a0e365d2cc" },
|
|
{ 0, NULL },
|
|
};
|
|
|
|
/* CryptoKey = 0x01234567, 0x89abcdef,
|
|
* 0x01234567, 0x89abcdef,
|
|
* 0x01234567, 0x89abcdef
|
|
* IV = 0x12345678, 0x90abcdef
|
|
* MacKey = 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
|
|
* 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10
|
|
* InputHexStr = "31323334353637383930" (ASCII = "1234567890")
|
|
* Note: only sizes aligned to 3DES block size (8 bytes) allowed
|
|
*/
|
|
static MV_CESA_SIZE_TEST cbc3desMdMultiSizeTest504[] =
|
|
{
|
|
{ 64, "8d10e00802460ede0058c139ba48bd2d" },
|
|
{ 80, "6f463057e1a90e0e91ae505b527bcec0" },
|
|
{ 352, "4938d48bdf86aece2c6851e7c6079788" },
|
|
{ 512, "516705d59f3cf810ebf2a13a23a7d42e" },
|
|
{ 1000, "a5a000ee5c830e67ddc6a2d2e5644b31" },
|
|
{ 1336, "44af60087b74ed07950088efbe3b126a" },
|
|
{ 1344, "1f5b39e0577920af731dabbfcf6dfc2a" },
|
|
{ 1400, "6804ea640e29b9cd39e08bc37dbce734" },
|
|
{ 1408, "4fb436624b02516fc9d1535466574bf9" },
|
|
{ 2048, "c909b0985c423d8d86719f701e9e83db" },
|
|
{ 3072, "cfe0bc34ef97213ee3d3f8b10122db21" },
|
|
{ 4048, "03ea10b5ae4ddeb20aed6af373082ed1" },
|
|
{ 6144, "b9a0ff4f87fc14b3c2dc6f0ed0998fdf" },
|
|
{ 6400, "6995f85d9d4985dd99e974ec7dda9dd6" },
|
|
{ 6528, "bbbb548ce2fa3d58467f6a6a5168a0e6" },
|
|
{ 8192, "afe101fbe745bb449ae4f50d10801456" },
|
|
{16384, "9741706d0b1c923340c4660ff97cacdf" },
|
|
{18432, "b0217becb73cb8f61fd79c7ce9d023fb" },
|
|
{ 0, NULL },
|
|
};
|
|
|
|
|
|
/* CryptoKey = 0x01234567, 0x89abcdef,
|
|
* 0x01234567, 0x89abcdef,
|
|
* 0x01234567, 0x89abcdef;
|
|
* IV = 0x12345678, 0x90abcdef
|
|
* MacKey = 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
|
|
* 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10
|
|
* 0x11, 0x12, 0x13, 0x14
|
|
* InputHexStr = "31323334353637383930" (ASCII = "1234567890")
|
|
* Note: only sizes aligned to 3DES block size (8 bytes) allowed
|
|
*/
|
|
static MV_CESA_SIZE_TEST cbc3desShaMultiSizeTest505[] =
|
|
{
|
|
{ 64, "409187e5bdb0be4a7754ca3747f7433dc4f01b98" },
|
|
{ 80, "1b002ed050be743aa98860cf35659646bb8efcc0" },
|
|
{ 352, "6cbf7ebe50fa4fa6eecc19eca23f9eae553ccfff" },
|
|
{ 512, "cfb5253fb4bf72b743320c30c7e48c54965853b0" },
|
|
{ 1000, "95e04e1ca2937e7c5a9aba9e42d2bcdb8a7af21f" },
|
|
{ 1336, "3b5c1f5eee5837ebf67b83ae01405542d77a6627" },
|
|
{ 1344, "2b3d42ab25615437f98a1ee310b81d07a02badc2" },
|
|
{ 1400, "7f8687df7c1af44e4baf3c934b6cca5ab6bc993e" },
|
|
{ 1408, "473a581c5f04f7527d50793c845471ac87e86430" },
|
|
{ 2048, "e41d20cae7ebe34e6e828ed62b1e5734019037bb" },
|
|
{ 3072, "275664afd7a561d804e6b0d204e53939cde653ae" },
|
|
{ 4048, "0d220cc5b34aeeb46bbbd637dde6290b5a8285a3" },
|
|
{ 6144, "cb393ddcc8b1c206060625b7d822ef9839e67bc5" },
|
|
{ 6400, "dd3317e2a627fc04800f74a4b05bfda00fab0347" },
|
|
{ 6528, "8a74c3b2441ab3f5a7e08895cc432566219a7c41" },
|
|
{ 8192, "b8e6ef3a549ed0e005bd5b8b1a5fe6689e9711a7" },
|
|
{16384, "55f59404008276cdac0e2ba0d193af2d40eac5ce" },
|
|
{18432, "86ae6c4fc72369a54cce39938e2d0296cd9c6ec5" },
|
|
{ 0, NULL },
|
|
};
|
|
|
|
|
|
/* CryptoKey = 0x01234567, 0x89abcdef,
|
|
* 0x01234567, 0x89abcdef,
|
|
* 0x01234567, 0x89abcdef
|
|
* IV = 0x12345678, 0x90abcdef
|
|
* MacKey = 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
|
|
* 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10
|
|
* InputHexStr = "31323334353637383930" (ASCII = "1234567890")
|
|
* Note: only sizes aligned to AES block size (16 bytes) allowed
|
|
*/
|
|
static MV_CESA_SIZE_TEST cbcAes128md5multiSizeTest506[] =
|
|
{
|
|
{ 16, "7ca4c2ba866751598720c5c4aa0d6786" },
|
|
{ 64, "7dba7fb988e80da609b1fea7254bced8" },
|
|
{ 80, "6b6e863ac5a71d15e3e9b1c86c9ba05f" },
|
|
{ 352, "a1ceb9c2e3021002400d525187a9f38c" },
|
|
{ 512, "596c055c1c55db748379223164075641" },
|
|
{ 1008, "f920989c02f3b3603f53c99d89492377" },
|
|
{ 1344, "2e496b73759d77ed32ea222dbd2e7b41" },
|
|
{ 1408, "7178c046b3a8d772efdb6a71c4991ea4" },
|
|
{ 2048, "a917f0099c69eb94079a8421714b6aad" },
|
|
{ 3072, "693cd5033d7f5391d3c958519fa9e934" },
|
|
{ 4048, "139dca91bcff65b3c40771749052906b" },
|
|
{ 6144, "428d9cef6df4fb70a6e9b6bbe4819e55" },
|
|
{ 6400, "9c0b909e76daa811e12b1fc17000a0c4" },
|
|
{ 6528, "ad876f6297186a7be1f1b907ed860eda" },
|
|
{ 8192, "479cbbaca37dd3191ea1f3e8134a0ef4" },
|
|
{16384, "60fda559c74f91df538100c9842f2f15" },
|
|
{18432, "4a3eb1cba1fa45f3981270953f720c42" },
|
|
{ 0, NULL },
|
|
};
|
|
|
|
|
|
/* CryptoKey = 0x01234567, 0x89abcdef,
|
|
* 0x01234567, 0x89abcdef,
|
|
* 0x01234567, 0x89abcdef;
|
|
* IV = 0x12345678, 0x90abcdef
|
|
* MacKey = 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
|
|
* 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10
|
|
* 0x11, 0x12, 0x13, 0x14
|
|
* InputHexStr = "31323334353637383930" (ASCII = "1234567890")
|
|
* Note: only sizes aligned to AES block size (16 bytes) allowed
|
|
*/
|
|
static MV_CESA_SIZE_TEST cbcAes128sha1multiSizeTest507[] =
|
|
{
|
|
{ 16, "9aa8dc1c45f0946daf78057fa978759c625c1fee" },
|
|
{ 64, "9f588fc1ede851e5f8b20256abc9979465ae2189" },
|
|
{ 80, "13558472d1fc1c90dffec6e5136c7203452d509b" },
|
|
{ 352, "6b93518e006cfaa1f7adb24615e7291fb0a27e06" },
|
|
{ 512, "096874951a77fbbf333e49d80c096ee2016e09bd" },
|
|
{ 1008, "696fc203c2e4b5ae0ec5d1db3f623c490bc6dbac" },
|
|
{ 1344, "79bf77509935ccd3528caaac6a5eb6481f74029b" },
|
|
{ 1408, "627f9462b95fc188e8cfa7eec15119bdc5d4fcf1" },
|
|
{ 2048, "3d50d0c005feba92fe41502d609fced9c882b4d1" },
|
|
{ 3072, "758807e5b983e3a91c06fb218fe0f73f77111e94" },
|
|
{ 4048, "ca90e85242e33f005da3504416a52098d0d31fb2" },
|
|
{ 6144, "8044c1d4fd06642dfc46990b4f18b61ef1e972cf" },
|
|
{ 6400, "166f1f4ea57409f04feba9fb1e39af0e00bd6f43" },
|
|
{ 6528, "0389016a39485d6e330f8b4215ddf718b404f7e9" },
|
|
{ 8192, "6df7ee2a8b61d6f7f860ce8dbf778f0c2a5b508b" },
|
|
{16384, "a70a6d8dfa1f91ded621c3dbaed34162bc48783f" },
|
|
{18432, "8dfad627922ce15df1eed10bdbed49244efa57db" },
|
|
{ 0, NULL },
|
|
};
|
|
|
|
|
|
void cesaTestPrintStatus(void);
|
|
|
|
|
|
/*------------------------- LOCAL FUNCTIONs ---------------------------------*/
|
|
MV_STATUS testCmd(int sid, int iter, MV_CESA_COMMAND* pCmd,
|
|
MV_CESA_TEST_SESSION* pTestSession, MV_U8* pIV, int ivSize);
|
|
MV_STATUS testClose(int idx);
|
|
MV_STATUS testOpen(int idx);
|
|
void close_session(int sid);
|
|
void cesaTestCheckReady(const MV_CESA_RESULT *r);
|
|
void cesaCheckReady(MV_CESA_RESULT* r);
|
|
void printTestResults(int idx, MV_STATUS status, int checkMode);
|
|
void cesaLastResult(void);
|
|
void cesaTestPrintReq(int req, int offset, int size);
|
|
|
|
void cesaTestPrintStatus(void);
|
|
void cesaTestPrintSession(int idx);
|
|
void sizeTest(int testIdx, int iter, int checkMode);
|
|
void multiTest(int iter, int reqSize, int checkMode);
|
|
void oneTest(int testIdx, int caseIdx,int iter, int reqSize, int checkMode);
|
|
void multiSizeTest(int idx, int iter, int checkMode, char* inputData);
|
|
void cesaTest(int iter, int reqSize, int checkMode);
|
|
void cesaOneTest(int testIdx, int caseIdx,int iter, int reqSize, int checkMode);
|
|
void combiTest(int iter, int reqSize, int checkMode);
|
|
void shaTest(int iter, int reqSize, int checkMode);
|
|
void mdTest(int iter, int reqSize, int checkMode);
|
|
void aesTest(int iter, int reqSize, int checkMode);
|
|
void tripleDesTest(int iter, int reqSize, int checkMode);
|
|
void desTest(int iter, int reqSize, int checkMode);
|
|
void cesaTestStop(void);
|
|
MV_STATUS testRun(int idx, int caseIdx, int iter,int reqSize, int checkMode);
|
|
void cesaTestStart(int bufNum, int bufSize);
|
|
|
|
|
|
static MV_U32 getRate(MV_U32* remainder)
|
|
{
|
|
MV_U32 kBits, milliSec, rate;
|
|
|
|
milliSec = 0;
|
|
if( (cesaEndTicks - cesaBeginTicks) > 0)
|
|
{
|
|
milliSec = CESA_TEST_TICK_TO_MS(cesaEndTicks - cesaBeginTicks);
|
|
}
|
|
if(milliSec == 0)
|
|
{
|
|
if(remainder != NULL)
|
|
*remainder = 0;
|
|
return 0;
|
|
}
|
|
|
|
kBits = (cesaIteration*cesaRateSize*8)/1000;
|
|
rate = kBits/milliSec;
|
|
if(remainder != NULL)
|
|
*remainder = ((kBits % milliSec)*10)/milliSec;
|
|
|
|
return rate;
|
|
}
|
|
|
|
static char* extractMbuf(MV_CESA_MBUF *pMbuf,
|
|
int offset, int size, char* hexStr)
|
|
{
|
|
mvCesaCopyFromMbuf((MV_U8*)cesaBinBuffer, pMbuf, offset, size);
|
|
mvBinToHex((const MV_U8*)cesaBinBuffer, hexStr, size);
|
|
|
|
return hexStr;
|
|
}
|
|
|
|
static MV_BOOL cesaCheckMbuf(MV_CESA_MBUF *pMbuf,
|
|
const char* hexString, int offset,
|
|
int checkSize)
|
|
{
|
|
MV_BOOL isFailed = MV_FALSE;
|
|
MV_STATUS status;
|
|
int size = strlen(hexString)/2;
|
|
int checkedSize = 0;
|
|
/*
|
|
mvOsPrintf("cesaCheckMbuf: pMbuf=%p, offset=%d, checkSize=%d, mBufSize=%d\n",
|
|
pMbuf, offset, checkSize, pMbuf->mbufSize);
|
|
*/
|
|
if(pMbuf->mbufSize < (checkSize + offset))
|
|
{
|
|
mvOsPrintf("checkSize (%d) is too large: offset=%d, mbufSize=%d\n",
|
|
checkSize, offset, pMbuf->mbufSize);
|
|
return MV_TRUE;
|
|
}
|
|
status = mvCesaCopyFromMbuf((MV_U8*)cesaBinBuffer, pMbuf, offset, checkSize);
|
|
if(status != MV_OK)
|
|
{
|
|
mvOsPrintf("CesaTest: Can't copy %d bytes from Mbuf=%p to checkBuf=%p\n",
|
|
checkSize, pMbuf, cesaBinBuffer);
|
|
return MV_TRUE;
|
|
}
|
|
/*
|
|
mvDebugMemDump(cesaBinBuffer, size, 1);
|
|
*/
|
|
mvHexToBin(hexString, (MV_U8*)cesaExpBinBuffer, size);
|
|
|
|
/* Compare buffers */
|
|
while(checkSize > checkedSize)
|
|
{
|
|
size = MV_MIN(size, (checkSize - checkedSize));
|
|
if(memcmp(cesaExpBinBuffer, &cesaBinBuffer[checkedSize], size) != 0)
|
|
{
|
|
mvOsPrintf("CheckMbuf failed: checkSize=%d, size=%d, checkedSize=%d\n",
|
|
checkSize, size, checkedSize);
|
|
mvDebugMemDump(&cesaBinBuffer[checkedSize], size, 1);
|
|
mvDebugMemDump(cesaExpBinBuffer, size, 1);
|
|
|
|
isFailed = MV_TRUE;
|
|
break;
|
|
}
|
|
checkedSize += size;
|
|
}
|
|
|
|
return isFailed;
|
|
}
|
|
|
|
static MV_STATUS cesaSetMbuf(MV_CESA_MBUF *pMbuf,
|
|
const char* hexString,
|
|
int offset, int reqSize)
|
|
{
|
|
MV_STATUS status = MV_OK;
|
|
int copySize, size = strlen(hexString)/2;
|
|
|
|
mvHexToBin(hexString, (MV_U8*)cesaBinBuffer, size);
|
|
|
|
copySize = 0;
|
|
while(reqSize > copySize)
|
|
{
|
|
size = MV_MIN(size, (reqSize - copySize));
|
|
|
|
status = mvCesaCopyToMbuf((MV_U8*)cesaBinBuffer, pMbuf, offset+copySize, size);
|
|
if(status != MV_OK)
|
|
{
|
|
mvOsPrintf("cesaSetMbuf Error: Copy %d of %d bytes to MBuf\n",
|
|
copySize, reqSize);
|
|
break;
|
|
}
|
|
copySize += size;
|
|
}
|
|
pMbuf->mbufSize = offset+copySize;
|
|
return status;
|
|
}
|
|
|
|
static MV_CESA_TEST_SESSION* getTestSessionDb(int idx, int* pTestIdx)
|
|
{
|
|
int testIdx, dbIdx = idx/100;
|
|
|
|
if(dbIdx > MAX_TEST_TYPE)
|
|
{
|
|
mvOsPrintf("Wrong index %d - No such test type\n", idx);
|
|
return NULL;
|
|
}
|
|
testIdx = idx % 100;
|
|
|
|
if(testIdx >= cesaTestsDB[dbIdx].numSessions)
|
|
{
|
|
mvOsPrintf("Wrong index %d - No such test\n", idx);
|
|
return NULL;
|
|
}
|
|
if(pTestIdx != NULL)
|
|
*pTestIdx = testIdx;
|
|
|
|
return cesaTestsDB[dbIdx].pSessions;
|
|
}
|
|
|
|
/* Debug */
|
|
void cesaTestPrintReq(int req, int offset, int size)
|
|
{
|
|
MV_CESA_MBUF* pMbuf;
|
|
|
|
mvOsPrintf("cesaTestPrintReq: req=%d, offset=%d, size=%d\n",
|
|
req, offset, size);
|
|
mvDebugMemDump(cesaCmdRing, 128, 4);
|
|
|
|
pMbuf = cesaCmdRing[req].pSrc;
|
|
mvCesaDebugMbuf("src", pMbuf, offset,size);
|
|
pMbuf = cesaCmdRing[req].pDst;
|
|
mvCesaDebugMbuf("dst", pMbuf, offset, size);
|
|
|
|
cesaTestPrintStatus();
|
|
}
|
|
|
|
void cesaLastResult(void)
|
|
{
|
|
mvOsPrintf("Last Result: ReqId = %d, SessionId = %d, rc = (%d)\n",
|
|
(MV_U32)cesaResult.pReqPrv, cesaResult.sessionId,
|
|
cesaResult.retCode);
|
|
}
|
|
|
|
void printTestResults(int idx, MV_STATUS status, int checkMode)
|
|
{
|
|
int testIdx;
|
|
MV_CESA_TEST_SESSION* pTestSessions = getTestSessionDb(idx, &testIdx);
|
|
|
|
if(pTestSessions == NULL)
|
|
return;
|
|
|
|
mvOsPrintf("%-35s %4dx%-4d : ", pTestSessions[testIdx].name,
|
|
cesaIteration, cesaReqSize);
|
|
if( (status == MV_OK) &&
|
|
(cesaCryptoError == 0) &&
|
|
(cesaError == 0) &&
|
|
(cesaReqIdError == 0) )
|
|
{
|
|
mvOsPrintf("Passed, Rate=%3u.%u Mbps (%5u cpp)\n",
|
|
cesaRate, cesaRateAfterDot, cesaEndTicks - cesaBeginTicks);
|
|
}
|
|
else
|
|
{
|
|
mvOsPrintf("Failed, Status = 0x%x\n", status);
|
|
if(cesaCryptoError > 0)
|
|
mvOsPrintf("cryptoError : %d\n", cesaCryptoError);
|
|
if(cesaReqIdError > 0)
|
|
mvOsPrintf("reqIdError : %d\n", cesaReqIdError);
|
|
if(cesaError > 0)
|
|
mvOsPrintf("cesaError : %d\n", cesaError);
|
|
}
|
|
if(cesaTestIsrMissCount > 0)
|
|
mvOsPrintf("cesaIsrMissed : %d\n", cesaTestIsrMissCount);
|
|
}
|
|
|
|
void cesaCheckReady(MV_CESA_RESULT* r)
|
|
{
|
|
int reqId;
|
|
MV_CESA_MBUF *pMbuf;
|
|
MV_BOOL isFailed;
|
|
|
|
cesaResult = *r;
|
|
reqId = (int)cesaResult.pReqPrv;
|
|
pMbuf = cesaCmdRing[reqId].pDst;
|
|
|
|
/*
|
|
mvOsPrintf("cesaCheckReady: reqId=%d, checkOffset=%d, checkSize=%d\n",
|
|
reqId, cesaCheckOffset, cesaCheckSize);
|
|
*/
|
|
/* Check expected reqId */
|
|
if(reqId != cesaExpReqId)
|
|
{
|
|
cesaReqIdError++;
|
|
/*
|
|
mvOsPrintf("CESA reqId Error: cbIter=%d (%d), reqId=%d, expReqId=%d\n",
|
|
cesaCbIter, cesaIteration, reqId, cesaExpReqId);
|
|
*/
|
|
}
|
|
else
|
|
{
|
|
if( (cesaCheckMode == CESA_FULL_CHECK_MODE) ||
|
|
(cesaCheckMode == CESA_FAST_CHECK_MODE) )
|
|
{
|
|
if(cesaResult.retCode != MV_OK)
|
|
{
|
|
cesaError++;
|
|
|
|
mvOsPrintf("CESA Error: cbIter=%d (%d), reqId=%d, rc=%d\n",
|
|
cesaCbIter, cesaIteration, reqId, cesaResult.retCode);
|
|
}
|
|
else
|
|
{
|
|
if( (cesaCheckSize > 0) && (cesaOutputHexStr != NULL) )
|
|
{
|
|
/* Check expected output */
|
|
|
|
isFailed = cesaCheckMbuf(pMbuf, cesaOutputHexStr, cesaCheckOffset, cesaCheckSize);
|
|
if(isFailed)
|
|
{
|
|
mvOsPrintf("CESA Crypto Error: cbIter=%d (%d), reqId=%d\n",
|
|
cesaCbIter, cesaIteration, reqId);
|
|
|
|
CESA_TEST_DEBUG_PRINT(("Error: reqId=%d, reqSize=%d, checkOffset=%d, checkSize=%d\n",
|
|
reqId, cesaReqSize, cesaCheckOffset, cesaCheckSize));
|
|
|
|
CESA_TEST_DEBUG_PRINT(("Output str: %s\n", cesaOutputHexStr));
|
|
|
|
CESA_TEST_DEBUG_CODE( mvCesaDebugMbuf("error", pMbuf, 0, cesaCheckOffset+cesaCheckSize) );
|
|
|
|
cesaCryptoError++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(cesaCheckMode == CESA_SHOW_CHECK_MODE)
|
|
{
|
|
extractMbuf(pMbuf, cesaCheckOffset, cesaCheckSize, cesaHexBuffer);
|
|
mvOsPrintf("%4d, %s\n", cesaCheckOffset, cesaHexBuffer);
|
|
}
|
|
|
|
cesaCbIter++;
|
|
if(cesaCbIter >= cesaIteration)
|
|
{
|
|
cesaCbIter = 0;
|
|
cesaExpReqId = 0;
|
|
cesaIsReady = MV_TRUE;
|
|
|
|
cesaEndTicks = CESA_TEST_TICK_GET();
|
|
cesaRate = getRate(&cesaRateAfterDot);
|
|
}
|
|
else
|
|
{
|
|
cesaExpReqId = reqId + 1;
|
|
if(cesaExpReqId == CESA_DEF_REQ_SIZE)
|
|
cesaExpReqId = 0;
|
|
}
|
|
}
|
|
|
|
|
|
#ifdef MV_NETBSD
|
|
static int cesaTestReadyIsr(void *arg)
|
|
#else
|
|
#ifdef __KERNEL__
|
|
static irqreturn_t cesaTestReadyIsr( int irq , void *dev_id)
|
|
#endif
|
|
#ifdef MV_VXWORKS
|
|
void cesaTestReadyIsr(void)
|
|
#endif
|
|
#endif
|
|
{
|
|
MV_U32 cause;
|
|
MV_STATUS status;
|
|
MV_CESA_RESULT result;
|
|
|
|
cesaTestIsrCount++;
|
|
/* Clear cause register */
|
|
cause = MV_REG_READ(MV_CESA_ISR_CAUSE_REG);
|
|
if( (cause & MV_CESA_CAUSE_ACC_DMA_ALL_MASK) == 0)
|
|
{
|
|
mvOsPrintf("cesaTestReadyIsr: cause=0x%x\n", cause);
|
|
#ifdef MV_NETBSD
|
|
return 0;
|
|
#else
|
|
#ifdef __KERNEL__
|
|
return 1;
|
|
#else
|
|
return;
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
MV_REG_WRITE(MV_CESA_ISR_CAUSE_REG, 0);
|
|
|
|
while(MV_TRUE)
|
|
{
|
|
/* Get Ready requests */
|
|
status = mvCesaReadyGet(&result);
|
|
if(status == MV_OK)
|
|
cesaCheckReady(&result);
|
|
|
|
break;
|
|
}
|
|
if( (cesaTestFull == 1) && (status != MV_BUSY) )
|
|
{
|
|
cesaTestFull = 0;
|
|
CESA_TEST_WAKE_UP();
|
|
}
|
|
|
|
#ifdef __KERNEL__
|
|
return 1;
|
|
#endif
|
|
}
|
|
|
|
void
|
|
cesaTestCheckReady(const MV_CESA_RESULT *r)
|
|
{
|
|
MV_CESA_RESULT result = *r;
|
|
|
|
cesaCheckReady(&result);
|
|
|
|
if (cesaTestFull == 1) {
|
|
cesaTestFull = 0;
|
|
CESA_TEST_WAKE_UP();
|
|
}
|
|
}
|
|
|
|
static INLINE int open_session(MV_CESA_OPEN_SESSION* pOs)
|
|
{
|
|
MV_U16 sid;
|
|
MV_STATUS status;
|
|
|
|
status = mvCesaSessionOpen(pOs, (short*)&sid);
|
|
if(status != MV_OK)
|
|
{
|
|
mvOsPrintf("CesaTest: Can't open new session - status = 0x%x\n",
|
|
status);
|
|
return -1;
|
|
}
|
|
|
|
return (int)sid;
|
|
}
|
|
|
|
void close_session(int sid)
|
|
{
|
|
MV_STATUS status;
|
|
|
|
status = mvCesaSessionClose(sid);
|
|
if(status != MV_OK)
|
|
{
|
|
mvOsPrintf("CesaTest: Can't close session %d - status = 0x%x\n",
|
|
sid, status);
|
|
}
|
|
}
|
|
|
|
MV_STATUS testOpen(int idx)
|
|
{
|
|
MV_CESA_OPEN_SESSION os;
|
|
int sid, i, testIdx;
|
|
MV_CESA_TEST_SESSION* pTestSession;
|
|
MV_U16 digestSize = 0;
|
|
|
|
pTestSession = getTestSessionDb(idx, &testIdx);
|
|
if(pTestSession == NULL)
|
|
{
|
|
mvOsPrintf("Test %d is not exist\n", idx);
|
|
return MV_BAD_PARAM;
|
|
}
|
|
pTestSession = &pTestSession[testIdx];
|
|
|
|
if(pTestSession->sid != -1)
|
|
{
|
|
mvOsPrintf("Session for test %d already created: sid=%d\n",
|
|
idx, pTestSession->sid);
|
|
return MV_OK;
|
|
}
|
|
|
|
os.cryptoAlgorithm = pTestSession->cryptoAlgorithm;
|
|
os.macMode = pTestSession->macAlgorithm;
|
|
switch(os.macMode)
|
|
{
|
|
case MV_CESA_MAC_MD5:
|
|
case MV_CESA_MAC_HMAC_MD5:
|
|
digestSize = MV_CESA_MD5_DIGEST_SIZE;
|
|
break;
|
|
|
|
case MV_CESA_MAC_SHA1:
|
|
case MV_CESA_MAC_HMAC_SHA1:
|
|
digestSize = MV_CESA_SHA1_DIGEST_SIZE;
|
|
break;
|
|
|
|
case MV_CESA_MAC_NULL:
|
|
digestSize = 0;
|
|
}
|
|
os.cryptoMode = pTestSession->cryptoMode;
|
|
os.direction = pTestSession->direction;
|
|
os.operation = pTestSession->operation;
|
|
|
|
for(i=0; i<pTestSession->cryptoKeySize; i++)
|
|
os.cryptoKey[i] = pTestSession->pCryptoKey[i];
|
|
|
|
os.cryptoKeyLength = pTestSession->cryptoKeySize;
|
|
|
|
for(i=0; i<pTestSession->macKeySize; i++)
|
|
os.macKey[i] = pTestSession->pMacKey[i];
|
|
|
|
os.macKeyLength = pTestSession->macKeySize;
|
|
os.digestSize = digestSize;
|
|
|
|
sid = open_session(&os);
|
|
if(sid == -1)
|
|
{
|
|
mvOsPrintf("Can't open session for test %d: rc=0x%x\n",
|
|
idx, cesaResult.retCode);
|
|
return cesaResult.retCode;
|
|
}
|
|
CESA_TEST_DEBUG_PRINT(("Opened session: sid = %d\n", sid));
|
|
pTestSession->sid = sid;
|
|
return MV_OK;
|
|
}
|
|
|
|
MV_STATUS testClose(int idx)
|
|
{
|
|
int testIdx;
|
|
MV_CESA_TEST_SESSION* pTestSession;
|
|
|
|
pTestSession = getTestSessionDb(idx, &testIdx);
|
|
if(pTestSession == NULL)
|
|
{
|
|
mvOsPrintf("Test %d is not exist\n", idx);
|
|
return MV_BAD_PARAM;
|
|
}
|
|
pTestSession = &pTestSession[testIdx];
|
|
|
|
if(pTestSession->sid == -1)
|
|
{
|
|
mvOsPrintf("Test session %d is not opened\n", idx);
|
|
return MV_NO_SUCH;
|
|
}
|
|
|
|
close_session(pTestSession->sid);
|
|
pTestSession->sid = -1;
|
|
|
|
return MV_OK;
|
|
}
|
|
|
|
MV_STATUS testCmd(int sid, int iter, MV_CESA_COMMAND* pCmd,
|
|
MV_CESA_TEST_SESSION* pTestSession, MV_U8* pIV, int ivSize)
|
|
{
|
|
int cmdReqId = 0;
|
|
int i;
|
|
MV_STATUS rc = MV_OK;
|
|
char ivZeroHex[] = "0000";
|
|
|
|
if(iter == 0)
|
|
iter = CESA_DEF_ITER_NUM;
|
|
|
|
if(pCmd == NULL)
|
|
{
|
|
mvOsPrintf("testCmd failed: pCmd=NULL\n");
|
|
return MV_BAD_PARAM;
|
|
}
|
|
pCmd->sessionId = sid;
|
|
|
|
cesaCryptoError = 0;
|
|
cesaReqIdError = 0;
|
|
cesaError = 0;
|
|
cesaTestIsrMissCount = 0;
|
|
cesaIsReady = MV_FALSE;
|
|
cesaIteration = iter;
|
|
|
|
if(cesaInputHexStr == NULL)
|
|
cesaInputHexStr = cesaPlainHexEbc;
|
|
|
|
for(i=0; i<CESA_DEF_REQ_SIZE; i++)
|
|
{
|
|
pCmd->pSrc = (MV_CESA_MBUF*)(cesaCmdRing[i].pSrc);
|
|
if(pIV != NULL)
|
|
{
|
|
/* If IV from SA - set IV in Source buffer to zeros */
|
|
cesaSetMbuf(pCmd->pSrc, ivZeroHex, 0, pCmd->cryptoOffset);
|
|
cesaSetMbuf(pCmd->pSrc, cesaInputHexStr, pCmd->cryptoOffset,
|
|
(cesaReqSize - pCmd->cryptoOffset));
|
|
}
|
|
else
|
|
{
|
|
cesaSetMbuf(pCmd->pSrc, cesaInputHexStr, 0, cesaReqSize);
|
|
}
|
|
pCmd->pDst = (MV_CESA_MBUF*)(cesaCmdRing[i].pDst);
|
|
cesaSetMbuf(pCmd->pDst, cesaNullPlainHexText, 0, cesaReqSize);
|
|
|
|
memcpy(&cesaCmdRing[i], pCmd, sizeof(*pCmd));
|
|
}
|
|
|
|
if(cesaCheckMode == CESA_SW_SHOW_CHECK_MODE)
|
|
{
|
|
MV_U8 pDigest[MV_CESA_MAX_DIGEST_SIZE];
|
|
|
|
if(pTestSession->macAlgorithm == MV_CESA_MAC_MD5)
|
|
{
|
|
mvMD5(pCmd->pSrc->pFrags[0].bufVirtPtr, pCmd->macLength, pDigest);
|
|
mvOsPrintf("SW HASH_MD5: reqSize=%d, macLength=%d\n",
|
|
cesaReqSize, pCmd->macLength);
|
|
mvDebugMemDump(pDigest, MV_CESA_MD5_DIGEST_SIZE, 1);
|
|
return MV_OK;
|
|
}
|
|
if(pTestSession->macAlgorithm == MV_CESA_MAC_SHA1)
|
|
{
|
|
mvSHA1(pCmd->pSrc->pFrags[0].bufVirtPtr, pCmd->macLength, pDigest);
|
|
mvOsPrintf("SW HASH_SHA1: reqSize=%d, macLength=%d\n",
|
|
cesaReqSize, pCmd->macLength);
|
|
mvDebugMemDump(pDigest, MV_CESA_SHA1_DIGEST_SIZE, 1);
|
|
return MV_OK;
|
|
}
|
|
}
|
|
|
|
cesaBeginTicks = CESA_TEST_TICK_GET();
|
|
CESA_TEST_DEBUG_CODE( memset(cesaTestTrace, 0, sizeof(cesaTestTrace));
|
|
cesaTestTraceIdx = 0;
|
|
);
|
|
|
|
if(cesaCheckMode == CESA_SW_NULL_CHECK_MODE)
|
|
{
|
|
volatile MV_U8 pDigest[MV_CESA_MAX_DIGEST_SIZE];
|
|
|
|
for(i=0; i<iter; i++)
|
|
{
|
|
if(pTestSession->macAlgorithm == MV_CESA_MAC_MD5)
|
|
{
|
|
mvMD5(pCmd->pSrc->pFrags[0].bufVirtPtr, pCmd->macLength, (unsigned char*)pDigest);
|
|
}
|
|
if(pTestSession->macAlgorithm == MV_CESA_MAC_SHA1)
|
|
{
|
|
mvSHA1(pCmd->pSrc->pFrags[0].bufVirtPtr, pCmd->macLength, (MV_U8 *)pDigest);
|
|
}
|
|
}
|
|
cesaEndTicks = CESA_TEST_TICK_GET();
|
|
cesaRate = getRate(&cesaRateAfterDot);
|
|
cesaIsReady = MV_TRUE;
|
|
|
|
return MV_OK;
|
|
}
|
|
|
|
/*cesaTestIsrCount = 0;*/
|
|
/*mvCesaDebugStatsClear();*/
|
|
|
|
#ifndef MV_NETBSD
|
|
MV_REG_WRITE(MV_CESA_ISR_CAUSE_REG, 0);
|
|
#endif
|
|
|
|
for(i=0; i<iter; i++)
|
|
{
|
|
unsigned long flags;
|
|
|
|
pCmd = &cesaCmdRing[cmdReqId];
|
|
pCmd->pReqPrv = (void*)cmdReqId;
|
|
|
|
CESA_TEST_LOCK(flags);
|
|
|
|
rc = mvCesaAction(pCmd);
|
|
if(rc == MV_NO_RESOURCE)
|
|
cesaTestFull = 1;
|
|
|
|
CESA_TEST_UNLOCK(flags);
|
|
|
|
if(rc == MV_NO_RESOURCE)
|
|
{
|
|
CESA_TEST_LOCK(flags);
|
|
CESA_TEST_WAIT( (cesaTestFull == 0), 100);
|
|
CESA_TEST_UNLOCK(flags);
|
|
if(cesaTestFull == 1)
|
|
{
|
|
mvOsPrintf("CESA Test timeout: i=%d, iter=%d, cesaTestFull=%d\n",
|
|
i, iter, cesaTestFull);
|
|
cesaTestFull = 0;
|
|
return MV_TIMEOUT;
|
|
}
|
|
|
|
CESA_TEST_LOCK(flags);
|
|
|
|
rc = mvCesaAction(pCmd);
|
|
|
|
CESA_TEST_UNLOCK(flags);
|
|
}
|
|
if( (rc != MV_OK) && (rc != MV_NO_MORE) )
|
|
{
|
|
mvOsPrintf("mvCesaAction failed: rc=%d\n", rc);
|
|
return rc;
|
|
}
|
|
|
|
cmdReqId++;
|
|
if(cmdReqId >= CESA_DEF_REQ_SIZE)
|
|
cmdReqId = 0;
|
|
|
|
#ifdef MV_LINUX
|
|
/* Reschedule each 16 requests */
|
|
if( (i & 0xF) == 0)
|
|
schedule();
|
|
#endif
|
|
}
|
|
return MV_OK;
|
|
}
|
|
|
|
void cesaTestStart(int bufNum, int bufSize)
|
|
{
|
|
int i, j, idx;
|
|
MV_CESA_MBUF *pMbufSrc, *pMbufDst;
|
|
MV_BUF_INFO *pFragsSrc, *pFragsDst;
|
|
char *pBuf;
|
|
#ifndef MV_NETBSD
|
|
int numOfSessions, queueDepth;
|
|
char *pSram;
|
|
MV_STATUS status;
|
|
MV_CPU_DEC_WIN addrDecWin;
|
|
#endif
|
|
|
|
cesaCmdRing = mvOsMalloc(sizeof(MV_CESA_COMMAND) * CESA_DEF_REQ_SIZE);
|
|
if(cesaCmdRing == NULL)
|
|
{
|
|
mvOsPrintf("testStart: Can't allocate %ld bytes of memory\n",
|
|
sizeof(MV_CESA_COMMAND) * CESA_DEF_REQ_SIZE);
|
|
return;
|
|
}
|
|
memset(cesaCmdRing, 0, sizeof(MV_CESA_COMMAND) * CESA_DEF_REQ_SIZE);
|
|
|
|
if(bufNum == 0)
|
|
bufNum = CESA_DEF_BUF_NUM;
|
|
|
|
if(bufSize == 0)
|
|
bufSize = CESA_DEF_BUF_SIZE;
|
|
|
|
cesaBufNum = bufNum;
|
|
cesaBufSize = bufSize;
|
|
mvOsPrintf("CESA test started: bufNum = %d, bufSize = %d\n",
|
|
bufNum, bufSize);
|
|
|
|
cesaHexBuffer = mvOsMalloc(2*bufNum*bufSize);
|
|
if(cesaHexBuffer == NULL)
|
|
{
|
|
mvOsPrintf("testStart: Can't malloc %d bytes for cesaHexBuffer.\n",
|
|
2*bufNum*bufSize);
|
|
return;
|
|
}
|
|
memset(cesaHexBuffer, 0, (2*bufNum*bufSize));
|
|
|
|
cesaBinBuffer = mvOsMalloc(bufNum*bufSize);
|
|
if(cesaBinBuffer == NULL)
|
|
{
|
|
mvOsPrintf("testStart: Can't malloc %d bytes for cesaBinBuffer\n",
|
|
bufNum*bufSize);
|
|
return;
|
|
}
|
|
memset(cesaBinBuffer, 0, (bufNum*bufSize));
|
|
|
|
cesaExpBinBuffer = mvOsMalloc(bufNum*bufSize);
|
|
if(cesaExpBinBuffer == NULL)
|
|
{
|
|
mvOsPrintf("testStart: Can't malloc %d bytes for cesaExpBinBuffer\n",
|
|
bufNum*bufSize);
|
|
return;
|
|
}
|
|
memset(cesaExpBinBuffer, 0, (bufNum*bufSize));
|
|
|
|
CESA_TEST_WAIT_INIT();
|
|
|
|
pMbufSrc = mvOsMalloc(sizeof(MV_CESA_MBUF) * CESA_DEF_REQ_SIZE);
|
|
pFragsSrc = mvOsMalloc(sizeof(MV_BUF_INFO) * bufNum * CESA_DEF_REQ_SIZE);
|
|
|
|
pMbufDst = mvOsMalloc(sizeof(MV_CESA_MBUF) * CESA_DEF_REQ_SIZE);
|
|
pFragsDst = mvOsMalloc(sizeof(MV_BUF_INFO) * bufNum * CESA_DEF_REQ_SIZE);
|
|
|
|
if( (pMbufSrc == NULL) || (pFragsSrc == NULL) ||
|
|
(pMbufDst == NULL) || (pFragsDst == NULL) )
|
|
{
|
|
mvOsPrintf("testStart: Can't malloc Src and Dst pMbuf and pFrags structures.\n");
|
|
/* !!!! Dima cesaTestCleanup();*/
|
|
return;
|
|
}
|
|
|
|
memset(pMbufSrc, 0, sizeof(MV_CESA_MBUF) * CESA_DEF_REQ_SIZE);
|
|
memset(pFragsSrc, 0, sizeof(MV_BUF_INFO) * bufNum * CESA_DEF_REQ_SIZE);
|
|
|
|
memset(pMbufDst, 0, sizeof(MV_CESA_MBUF) * CESA_DEF_REQ_SIZE);
|
|
memset(pFragsDst, 0, sizeof(MV_BUF_INFO) * bufNum * CESA_DEF_REQ_SIZE);
|
|
|
|
mvOsPrintf("Cesa Test Start: pMbufSrc=%p, pFragsSrc=%p, pMbufDst=%p, pFragsDst=%p\n",
|
|
pMbufSrc, pFragsSrc, pMbufDst, pFragsDst);
|
|
|
|
idx = 0;
|
|
for(i=0; i<CESA_DEF_REQ_SIZE; i++)
|
|
{
|
|
pBuf = mvOsIoCachedMalloc(cesaTestOSHandle,bufSize * bufNum * 2,
|
|
&cesaReqBufs[i].bufPhysAddr,
|
|
&cesaReqBufs[i].memHandle);
|
|
if(pBuf == NULL)
|
|
{
|
|
mvOsPrintf("testStart: Can't malloc %d bytes for pBuf\n",
|
|
bufSize * bufNum * 2);
|
|
return;
|
|
}
|
|
|
|
memset(pBuf, 0, bufSize * bufNum * 2);
|
|
mvOsCacheFlush(cesaTestOSHandle,pBuf, bufSize * bufNum * 2);
|
|
if(pBuf == NULL)
|
|
{
|
|
mvOsPrintf("cesaTestStart: Can't allocate %d bytes for req_%d buffers\n",
|
|
bufSize * bufNum * 2, i);
|
|
return;
|
|
}
|
|
|
|
cesaReqBufs[i].bufVirtPtr = (MV_U8*)pBuf;
|
|
cesaReqBufs[i].bufSize = bufSize * bufNum * 2;
|
|
|
|
cesaCmdRing[i].pSrc = &pMbufSrc[i];
|
|
cesaCmdRing[i].pSrc->pFrags = &pFragsSrc[idx];
|
|
cesaCmdRing[i].pSrc->numFrags = bufNum;
|
|
cesaCmdRing[i].pSrc->mbufSize = 0;
|
|
|
|
cesaCmdRing[i].pDst = &pMbufDst[i];
|
|
cesaCmdRing[i].pDst->pFrags = &pFragsDst[idx];
|
|
cesaCmdRing[i].pDst->numFrags = bufNum;
|
|
cesaCmdRing[i].pDst->mbufSize = 0;
|
|
|
|
for(j=0; j<bufNum; j++)
|
|
{
|
|
cesaCmdRing[i].pSrc->pFrags[j].bufVirtPtr = (MV_U8*)pBuf;
|
|
cesaCmdRing[i].pSrc->pFrags[j].bufSize = bufSize;
|
|
pBuf += bufSize;
|
|
cesaCmdRing[i].pDst->pFrags[j].bufVirtPtr = (MV_U8*)pBuf;
|
|
cesaCmdRing[i].pDst->pFrags[j].bufSize = bufSize;
|
|
pBuf += bufSize;
|
|
}
|
|
idx += bufNum;
|
|
}
|
|
|
|
#ifndef MV_NETBSD
|
|
if (mvCpuIfTargetWinGet(CRYPT_ENG, &addrDecWin) == MV_OK)
|
|
pSram = (char*)addrDecWin.addrWin.baseLow;
|
|
else
|
|
{
|
|
mvOsPrintf("mvCesaInit: ERR. mvCpuIfTargetWinGet failed\n");
|
|
return;
|
|
}
|
|
|
|
#ifdef MV_CESA_NO_SRAM
|
|
pSram = mvOsMalloc(4*1024+8);
|
|
if(pSram == NULL)
|
|
{
|
|
mvOsPrintf("CesaTest: can't allocate %d bytes for SRAM simulation\n",
|
|
4*1024+8);
|
|
/* !!!! Dima cesaTestCleanup();*/
|
|
return;
|
|
}
|
|
pSram = (MV_U8*)MV_ALIGN_UP((MV_U32)pSram, 8);
|
|
#endif /* MV_CESA_NO_SRAM */
|
|
|
|
numOfSessions = CESA_DEF_SESSION_NUM;
|
|
queueDepth = CESA_DEF_REQ_SIZE - MV_CESA_MAX_CHAN;
|
|
|
|
status = mvCesaInit(numOfSessions, queueDepth, pSram, NULL);
|
|
if(status != MV_OK)
|
|
{
|
|
mvOsPrintf("mvCesaInit is Failed: status = 0x%x\n", status);
|
|
/* !!!! Dima cesaTestCleanup();*/
|
|
return;
|
|
}
|
|
#endif /* !MV_NETBSD */
|
|
|
|
/* Prepare data for tests */
|
|
for(i=0; i<50; i++)
|
|
strcat((char*)cesaDataHexStr3, "dd");
|
|
|
|
strcpy((char*)cesaDataAndMd5digest3, cesaDataHexStr3);
|
|
strcpy((char*)cesaDataAndSha1digest3, cesaDataHexStr3);
|
|
|
|
/* Digest must be 8 byte aligned */
|
|
for(; i<56; i++)
|
|
{
|
|
strcat((char*)cesaDataAndMd5digest3, "00");
|
|
strcat((char*)cesaDataAndSha1digest3, "00");
|
|
}
|
|
strcat((char*)cesaDataAndMd5digest3, cesaHmacMd5digestHex3);
|
|
strcat((char*)cesaDataAndSha1digest3, cesaHmacSha1digestHex3);
|
|
|
|
#ifndef MV_NETBSD
|
|
MV_REG_WRITE( MV_CESA_ISR_CAUSE_REG, 0);
|
|
MV_REG_WRITE( MV_CESA_ISR_MASK_REG, MV_CESA_CAUSE_ACC_DMA_MASK);
|
|
#endif
|
|
|
|
#ifdef MV_VXWORKS
|
|
{
|
|
MV_STATUS status;
|
|
|
|
status = intConnect((VOIDFUNCPTR *)INT_LVL_CESA, cesaTestReadyIsr, (int)NULL);
|
|
if (status != OK)
|
|
{
|
|
mvOsPrintf("CESA: Can't connect CESA (%d) interrupt, status=0x%x \n",
|
|
INT_LVL_CESA, status);
|
|
/* !!!! Dima cesaTestCleanup();*/
|
|
return;
|
|
}
|
|
cesaSemId = semMCreate(SEM_Q_PRIORITY | SEM_INVERSION_SAFE | SEM_DELETE_SAFE);
|
|
if(cesaSemId == NULL)
|
|
{
|
|
mvOsPrintf("cesaTestStart: Can't create semaphore\n");
|
|
return;
|
|
}
|
|
intEnable(INT_LVL_CESA);
|
|
}
|
|
#endif /* MV_VXWORKS */
|
|
|
|
#if !defined(MV_NETBSD) && defined(__KERNEL__)
|
|
if( request_irq(CESA_IRQ, cesaTestReadyIsr, (SA_INTERRUPT) , "cesa_test", NULL ) )
|
|
{
|
|
mvOsPrintf( "cannot assign irq\n" );
|
|
/* !!!! Dima cesaTestCleanup();*/
|
|
return;
|
|
}
|
|
spin_lock_init( &cesaLock );
|
|
#endif
|
|
}
|
|
|
|
MV_STATUS testRun(int idx, int caseIdx, int iter,
|
|
int reqSize, int checkMode)
|
|
{
|
|
int testIdx, count, sid, digestSize;
|
|
int blockSize;
|
|
MV_CESA_TEST_SESSION* pTestSession;
|
|
MV_CESA_COMMAND cmd;
|
|
MV_STATUS status;
|
|
|
|
memset(&cmd, 0, sizeof(cmd));
|
|
|
|
pTestSession = getTestSessionDb(idx, &testIdx);
|
|
if(pTestSession == NULL)
|
|
{
|
|
mvOsPrintf("Test %d is not exist\n", idx);
|
|
return MV_BAD_PARAM;
|
|
}
|
|
pTestSession = &pTestSession[testIdx];
|
|
|
|
sid = pTestSession->sid;
|
|
if(sid == -1)
|
|
{
|
|
mvOsPrintf("Test %d is not opened\n", idx);
|
|
return MV_BAD_STATE;
|
|
}
|
|
switch(pTestSession->cryptoAlgorithm)
|
|
{
|
|
case MV_CESA_CRYPTO_DES:
|
|
case MV_CESA_CRYPTO_3DES:
|
|
blockSize = MV_CESA_DES_BLOCK_SIZE;
|
|
break;
|
|
|
|
case MV_CESA_CRYPTO_AES:
|
|
blockSize = MV_CESA_AES_BLOCK_SIZE;
|
|
break;
|
|
|
|
case MV_CESA_CRYPTO_NULL:
|
|
blockSize = 0;
|
|
break;
|
|
|
|
default:
|
|
mvOsPrintf("cesaTestRun: Bad CryptoAlgorithm=%d\n",
|
|
pTestSession->cryptoAlgorithm);
|
|
return MV_BAD_PARAM;
|
|
}
|
|
switch(pTestSession->macAlgorithm)
|
|
{
|
|
case MV_CESA_MAC_MD5:
|
|
case MV_CESA_MAC_HMAC_MD5:
|
|
digestSize = MV_CESA_MD5_DIGEST_SIZE;
|
|
break;
|
|
|
|
case MV_CESA_MAC_SHA1:
|
|
case MV_CESA_MAC_HMAC_SHA1:
|
|
digestSize = MV_CESA_SHA1_DIGEST_SIZE;
|
|
break;
|
|
default:
|
|
digestSize = 0;
|
|
}
|
|
|
|
if(iter == 0)
|
|
iter = CESA_DEF_ITER_NUM;
|
|
|
|
if(pTestSession->direction == MV_CESA_DIR_ENCODE)
|
|
{
|
|
cesaOutputHexStr = cesaTestCases[caseIdx].cipherHexStr;
|
|
cesaInputHexStr = cesaTestCases[caseIdx].plainHexStr;
|
|
}
|
|
else
|
|
{
|
|
cesaOutputHexStr = cesaTestCases[caseIdx].plainHexStr;
|
|
cesaInputHexStr = cesaTestCases[caseIdx].cipherHexStr;
|
|
}
|
|
|
|
cmd.sessionId = sid;
|
|
if(checkMode == CESA_FAST_CHECK_MODE)
|
|
{
|
|
cmd.cryptoLength = cesaTestCases[caseIdx].cryptoLength;
|
|
cmd.macLength = cesaTestCases[caseIdx].macLength;
|
|
}
|
|
else
|
|
{
|
|
cmd.cryptoLength = reqSize;
|
|
cmd.macLength = reqSize;
|
|
}
|
|
cesaRateSize = cmd.cryptoLength;
|
|
cesaReqSize = cmd.cryptoLength;
|
|
cmd.cryptoOffset = 0;
|
|
if(pTestSession->operation != MV_CESA_MAC_ONLY)
|
|
{
|
|
if( (pTestSession->cryptoMode == MV_CESA_CRYPTO_CBC) ||
|
|
(pTestSession->cryptoMode == MV_CESA_CRYPTO_CTR) )
|
|
{
|
|
cmd.ivOffset = 0;
|
|
cmd.cryptoOffset = blockSize;
|
|
if(cesaTestCases[caseIdx].pCryptoIV == NULL)
|
|
{
|
|
cmd.ivFromUser = 1;
|
|
}
|
|
else
|
|
{
|
|
cmd.ivFromUser = 0;
|
|
mvCesaCryptoIvSet(cesaTestCases[caseIdx].pCryptoIV, blockSize);
|
|
}
|
|
cesaReqSize = cmd.cryptoOffset + cmd.cryptoLength;
|
|
}
|
|
}
|
|
|
|
/*
|
|
mvOsPrintf("ivFromUser=%d, cryptoLength=%d, cesaReqSize=%d, cryptoOffset=%d\n",
|
|
cmd.ivFromUser, cmd.cryptoLength, cesaReqSize, cmd.cryptoOffset);
|
|
*/
|
|
if(pTestSession->operation != MV_CESA_CRYPTO_ONLY)
|
|
{
|
|
cmd.macOffset = cmd.cryptoOffset;
|
|
|
|
if(cesaTestCases[caseIdx].digestOffset == -1)
|
|
{
|
|
cmd.digestOffset = cmd.macOffset + cmd.macLength;
|
|
cmd.digestOffset = MV_ALIGN_UP(cmd.digestOffset, 8);
|
|
}
|
|
else
|
|
{
|
|
cmd.digestOffset = cesaTestCases[caseIdx].digestOffset;
|
|
}
|
|
if( (cmd.digestOffset + digestSize) > cesaReqSize)
|
|
cesaReqSize = cmd.digestOffset + digestSize;
|
|
}
|
|
|
|
cesaCheckMode = checkMode;
|
|
|
|
if(checkMode == CESA_NULL_CHECK_MODE)
|
|
{
|
|
cesaCheckSize = 0;
|
|
cesaCheckOffset = 0;
|
|
}
|
|
else
|
|
{
|
|
if(pTestSession->operation == MV_CESA_CRYPTO_ONLY)
|
|
{
|
|
cesaCheckOffset = 0;
|
|
cesaCheckSize = cmd.cryptoLength;
|
|
}
|
|
else
|
|
{
|
|
cesaCheckSize = digestSize;
|
|
cesaCheckOffset = cmd.digestOffset;
|
|
}
|
|
}
|
|
/*
|
|
mvOsPrintf("reqSize=%d, checkSize=%d, checkOffset=%d, checkMode=%d\n",
|
|
cesaReqSize, cesaCheckSize, cesaCheckOffset, cesaCheckMode);
|
|
|
|
mvOsPrintf("blockSize=%d, ivOffset=%d, ivFromUser=%d, crOffset=%d, crLength=%d\n",
|
|
blockSize, cmd.ivOffset, cmd.ivFromUser,
|
|
cmd.cryptoOffset, cmd.cryptoLength);
|
|
|
|
mvOsPrintf("macOffset=%d, digestOffset=%d, macLength=%d\n",
|
|
cmd.macOffset, cmd.digestOffset, cmd.macLength);
|
|
*/
|
|
status = testCmd(sid, iter, &cmd, pTestSession,
|
|
cesaTestCases[caseIdx].pCryptoIV, blockSize);
|
|
|
|
if(status != MV_OK)
|
|
return status;
|
|
|
|
/* Wait when all callbacks is received */
|
|
count = 0;
|
|
while(cesaIsReady == MV_FALSE)
|
|
{
|
|
mvOsSleep(10);
|
|
count++;
|
|
if(count > 100)
|
|
{
|
|
mvOsPrintf("testRun: Timeout occured\n");
|
|
return MV_TIMEOUT;
|
|
}
|
|
}
|
|
|
|
return MV_OK;
|
|
}
|
|
|
|
|
|
void cesaTestStop(void)
|
|
{
|
|
MV_CESA_MBUF *pMbufSrc, *pMbufDst;
|
|
MV_BUF_INFO *pFragsSrc, *pFragsDst;
|
|
int i;
|
|
|
|
/* Release all allocated memories */
|
|
pMbufSrc = (MV_CESA_MBUF*)(cesaCmdRing[0].pSrc);
|
|
pFragsSrc = cesaCmdRing[0].pSrc->pFrags;
|
|
|
|
pMbufDst = (MV_CESA_MBUF*)(cesaCmdRing[0].pDst);
|
|
pFragsDst = cesaCmdRing[0].pDst->pFrags;
|
|
|
|
mvOsFree(pMbufSrc);
|
|
mvOsFree(pMbufDst);
|
|
mvOsFree(pFragsSrc);
|
|
mvOsFree(pFragsDst);
|
|
|
|
for(i=0; i<CESA_DEF_REQ_SIZE; i++)
|
|
{
|
|
mvOsIoCachedFree(cesaTestOSHandle,cesaReqBufs[i].bufSize,
|
|
cesaReqBufs[i].bufPhysAddr,cesaReqBufs[i].bufVirtPtr,
|
|
cesaReqBufs[i].memHandle);
|
|
}
|
|
cesaDataHexStr3[0] = '\0';
|
|
}
|
|
|
|
void desTest(int iter, int reqSize, int checkMode)
|
|
{
|
|
int mode, i;
|
|
MV_STATUS status;
|
|
|
|
mode = checkMode;
|
|
if(checkMode == CESA_FULL_CHECK_MODE)
|
|
mode = CESA_FAST_CHECK_MODE;
|
|
i = iter;
|
|
if(mode != CESA_NULL_CHECK_MODE)
|
|
i = 1;
|
|
|
|
testOpen(0);
|
|
testOpen(1);
|
|
testOpen(2);
|
|
testOpen(3);
|
|
|
|
/* DES / ECB mode / Encrypt only */
|
|
status = testRun(0, 1, iter, reqSize, checkMode);
|
|
printTestResults(0, status, checkMode);
|
|
|
|
/* DES / ECB mode / Decrypt only */
|
|
status = testRun(1, 1, iter, reqSize, checkMode);
|
|
printTestResults(1, status, checkMode);
|
|
|
|
/* DES / CBC mode / Encrypt only */
|
|
status = testRun(2, 2, i, reqSize, mode);
|
|
printTestResults(2, status, mode);
|
|
|
|
/* DES / CBC mode / Decrypt only */
|
|
status = testRun(3, 2, iter, reqSize, mode);
|
|
printTestResults(3, status, mode);
|
|
|
|
testClose(0);
|
|
testClose(1);
|
|
testClose(2);
|
|
testClose(3);
|
|
}
|
|
|
|
void tripleDesTest(int iter, int reqSize, int checkMode)
|
|
{
|
|
int mode, i;
|
|
MV_STATUS status;
|
|
|
|
mode = checkMode;
|
|
if(checkMode == CESA_FULL_CHECK_MODE)
|
|
mode = CESA_FAST_CHECK_MODE;
|
|
i = iter;
|
|
if(mode != CESA_NULL_CHECK_MODE)
|
|
i = 1;
|
|
|
|
testOpen(100);
|
|
testOpen(101);
|
|
testOpen(102);
|
|
testOpen(103);
|
|
|
|
/* 3DES / ECB mode / Encrypt only */
|
|
status = testRun(100, 1, iter, reqSize, checkMode);
|
|
printTestResults(100, status, checkMode);
|
|
|
|
/* 3DES / ECB mode / Decrypt only */
|
|
status = testRun(101, 1, iter, reqSize, checkMode);
|
|
printTestResults(101, status, checkMode);
|
|
|
|
/* 3DES / CBC mode / Encrypt only */
|
|
status = testRun(102, 2, i, reqSize, mode);
|
|
printTestResults(102, status, mode);
|
|
|
|
/* 3DES / CBC mode / Decrypt only */
|
|
status = testRun(103, 2, iter, reqSize, mode);
|
|
printTestResults(103, status, mode);
|
|
|
|
testClose(100);
|
|
testClose(101);
|
|
testClose(102);
|
|
testClose(103);
|
|
}
|
|
|
|
void aesTest(int iter, int reqSize, int checkMode)
|
|
{
|
|
MV_STATUS status;
|
|
int mode, i;
|
|
|
|
mode = checkMode;
|
|
if(checkMode == CESA_FULL_CHECK_MODE)
|
|
mode = CESA_FAST_CHECK_MODE;
|
|
|
|
i = iter;
|
|
if(mode != CESA_NULL_CHECK_MODE)
|
|
i = 1;
|
|
|
|
testOpen(200);
|
|
testOpen(201);
|
|
testOpen(202);
|
|
testOpen(203);
|
|
testOpen(204);
|
|
testOpen(205);
|
|
testOpen(206);
|
|
testOpen(207);
|
|
testOpen(208);
|
|
|
|
/* AES-128 Encode ECB mode */
|
|
status = testRun(200, 3, iter, reqSize, checkMode);
|
|
printTestResults(200, status, checkMode);
|
|
|
|
/* AES-128 Decode ECB mode */
|
|
status = testRun(201, 3, iter, reqSize, checkMode);
|
|
printTestResults(201, status, checkMode);
|
|
|
|
/* AES-128 Encode CBC mode (IV from SA) */
|
|
status = testRun(202, 10, i, reqSize, mode);
|
|
printTestResults(202, status, mode);
|
|
|
|
/* AES-128 Encode CBC mode (IV from User) */
|
|
status = testRun(202, 24, i, reqSize, mode);
|
|
printTestResults(202, status, mode);
|
|
|
|
/* AES-128 Decode CBC mode */
|
|
status = testRun(203, 24, iter, reqSize, mode);
|
|
printTestResults(203, status, checkMode);
|
|
|
|
/* AES-192 Encode ECB mode */
|
|
status = testRun(204, 4, iter, reqSize, checkMode);
|
|
printTestResults(204, status, checkMode);
|
|
|
|
/* AES-192 Decode ECB mode */
|
|
status = testRun(205, 4, iter, reqSize, checkMode);
|
|
printTestResults(205, status, checkMode);
|
|
|
|
/* AES-256 Encode ECB mode */
|
|
status = testRun(206, 5, iter, reqSize, checkMode);
|
|
printTestResults(206, status, checkMode);
|
|
|
|
/* AES-256 Decode ECB mode */
|
|
status = testRun(207, 5, iter, reqSize, checkMode);
|
|
printTestResults(207, status, checkMode);
|
|
|
|
#if defined(MV_LINUX)
|
|
/* AES-128 Encode CTR mode */
|
|
status = testRun(208, 23, iter, reqSize, mode);
|
|
printTestResults(208, status, checkMode);
|
|
#endif
|
|
testClose(200);
|
|
testClose(201);
|
|
testClose(202);
|
|
testClose(203);
|
|
testClose(204);
|
|
testClose(205);
|
|
testClose(206);
|
|
testClose(207);
|
|
testClose(208);
|
|
}
|
|
|
|
|
|
void mdTest(int iter, int reqSize, int checkMode)
|
|
{
|
|
int mode;
|
|
MV_STATUS status;
|
|
|
|
if(iter == 0)
|
|
iter = CESA_DEF_ITER_NUM;
|
|
|
|
mode = checkMode;
|
|
if(checkMode == CESA_FULL_CHECK_MODE)
|
|
mode = CESA_FAST_CHECK_MODE;
|
|
|
|
testOpen(300);
|
|
testOpen(301);
|
|
testOpen(302);
|
|
testOpen(303);
|
|
testOpen(305);
|
|
|
|
/* HMAC-MD5 Generate signature test */
|
|
status = testRun(300, 6, iter, reqSize, mode);
|
|
printTestResults(300, status, checkMode);
|
|
|
|
/* HMAC-MD5 Verify Signature test */
|
|
status = testRun(301, 7, iter, reqSize, mode);
|
|
printTestResults(301, status, checkMode);
|
|
|
|
/* HMAC-MD5 Generate signature test */
|
|
status = testRun(302, 8, iter, reqSize, mode);
|
|
printTestResults(302, status, checkMode);
|
|
|
|
/* HMAC-MD5 Verify Signature test */
|
|
status = testRun(303, 9, iter, reqSize, mode);
|
|
printTestResults(303, status, checkMode);
|
|
|
|
/* HASH-MD5 Generate signature test */
|
|
status = testRun(305, 15, iter, reqSize, mode);
|
|
printTestResults(305, status, checkMode);
|
|
|
|
testClose(300);
|
|
testClose(301);
|
|
testClose(302);
|
|
testClose(303);
|
|
testClose(305);
|
|
}
|
|
|
|
void shaTest(int iter, int reqSize, int checkMode)
|
|
{
|
|
int mode;
|
|
MV_STATUS status;
|
|
|
|
if(iter == 0)
|
|
iter = CESA_DEF_ITER_NUM;
|
|
|
|
mode = checkMode;
|
|
if(checkMode == CESA_FULL_CHECK_MODE)
|
|
mode = CESA_FAST_CHECK_MODE;
|
|
|
|
testOpen(400);
|
|
testOpen(401);
|
|
testOpen(402);
|
|
testOpen(403);
|
|
testOpen(405);
|
|
|
|
/* HMAC-SHA1 Generate signature test */
|
|
status = testRun(400, 11, iter, reqSize, mode);
|
|
printTestResults(400, status, checkMode);
|
|
|
|
/* HMAC-SHA1 Verify Signature test */
|
|
status = testRun(401, 12, iter, reqSize, mode);
|
|
printTestResults(401, status, checkMode);
|
|
|
|
/* HMAC-SHA1 Generate signature test */
|
|
status = testRun(402, 13, iter, reqSize, mode);
|
|
printTestResults(402, status, checkMode);
|
|
|
|
/* HMAC-SHA1 Verify Signature test */
|
|
status = testRun(403, 14, iter, reqSize, mode);
|
|
printTestResults(403, status, checkMode);
|
|
|
|
/* HMAC-SHA1 Generate signature test */
|
|
status = testRun(405, 16, iter, reqSize, mode);
|
|
printTestResults(405, status, checkMode);
|
|
|
|
testClose(400);
|
|
testClose(401);
|
|
testClose(402);
|
|
testClose(403);
|
|
testClose(405);
|
|
}
|
|
|
|
void combiTest(int iter, int reqSize, int checkMode)
|
|
{
|
|
MV_STATUS status;
|
|
int mode, i;
|
|
|
|
mode = checkMode;
|
|
if(checkMode == CESA_FULL_CHECK_MODE)
|
|
mode = CESA_FAST_CHECK_MODE;
|
|
|
|
if(iter == 0)
|
|
iter = CESA_DEF_ITER_NUM;
|
|
|
|
i = iter;
|
|
if(mode != CESA_NULL_CHECK_MODE)
|
|
i = 1;
|
|
|
|
testOpen(500);
|
|
testOpen(501);
|
|
testOpen(502);
|
|
testOpen(503);
|
|
testOpen(504);
|
|
testOpen(505);
|
|
testOpen(506);
|
|
testOpen(507);
|
|
|
|
/* DES ECB + MD5 encode test */
|
|
status = testRun(500, 17, iter, reqSize, mode);
|
|
printTestResults(500, status, mode);
|
|
|
|
/* DES ECB + SHA1 encode test */
|
|
status = testRun(501, 18, iter, reqSize, mode);
|
|
printTestResults(501, status, mode);
|
|
|
|
/* 3DES ECB + MD5 encode test */
|
|
status = testRun(502, 17, iter, reqSize, mode);
|
|
printTestResults(502, status, mode);
|
|
|
|
/* 3DES ECB + SHA1 encode test */
|
|
status = testRun(503, 18, iter, reqSize, mode);
|
|
printTestResults(503, status, mode);
|
|
|
|
/* 3DES CBC + MD5 encode test */
|
|
status = testRun(504, 19, i, reqSize, mode);
|
|
printTestResults(504, status, mode);
|
|
|
|
/* 3DES CBC + SHA1 encode test */
|
|
status = testRun(505, 20, i, reqSize, mode);
|
|
printTestResults(505, status, mode);
|
|
|
|
/* AES-128 CBC + MD5 encode test */
|
|
status = testRun(506, 21, i, reqSize, mode);
|
|
printTestResults(506, status, mode);
|
|
|
|
/* AES-128 CBC + SHA1 encode test */
|
|
status = testRun(507, 22, i, reqSize, mode);
|
|
printTestResults(507, status, mode);
|
|
|
|
testClose(500);
|
|
testClose(501);
|
|
testClose(502);
|
|
testClose(503);
|
|
testClose(504);
|
|
testClose(505);
|
|
testClose(506);
|
|
testClose(507);
|
|
}
|
|
|
|
void cesaOneTest(int testIdx, int caseIdx,
|
|
int iter, int reqSize, int checkMode)
|
|
{
|
|
MV_STATUS status;
|
|
|
|
if(iter == 0)
|
|
iter = CESA_DEF_ITER_NUM;
|
|
|
|
mvOsPrintf("test=%d, case=%d, size=%d, iter=%d\n",
|
|
testIdx, caseIdx, reqSize, iter);
|
|
|
|
status = testOpen(testIdx);
|
|
|
|
status = testRun(testIdx, caseIdx, iter, reqSize, checkMode);
|
|
printTestResults(testIdx, status, checkMode);
|
|
status = testClose(testIdx);
|
|
|
|
}
|
|
|
|
void cesaTest(int iter, int reqSize, int checkMode)
|
|
{
|
|
if(iter == 0)
|
|
iter = CESA_DEF_ITER_NUM;
|
|
|
|
mvOsPrintf("%d iteration\n", iter);
|
|
mvOsPrintf("%d size\n\n", reqSize);
|
|
|
|
/* DES tests */
|
|
desTest(iter, reqSize, checkMode);
|
|
|
|
/* 3DES tests */
|
|
tripleDesTest(iter, reqSize, checkMode);
|
|
|
|
/* AES tests */
|
|
aesTest(iter, reqSize, checkMode);
|
|
|
|
/* MD5 tests */
|
|
mdTest(iter, reqSize, checkMode);
|
|
|
|
/* SHA-1 tests */
|
|
shaTest(iter, reqSize, checkMode);
|
|
}
|
|
|
|
void multiSizeTest(int idx, int iter, int checkMode, char* inputData)
|
|
{
|
|
MV_STATUS status;
|
|
int i;
|
|
MV_CESA_SIZE_TEST* pMultiTest;
|
|
|
|
if( testOpen(idx) != MV_OK)
|
|
return;
|
|
|
|
if(iter == 0)
|
|
iter = CESA_DEF_ITER_NUM;
|
|
|
|
if(checkMode == CESA_SHOW_CHECK_MODE)
|
|
{
|
|
iter = 1;
|
|
}
|
|
else
|
|
checkMode = CESA_FULL_CHECK_MODE;
|
|
|
|
cesaTestCases[0].plainHexStr = inputData;
|
|
cesaTestCases[0].pCryptoIV = NULL;
|
|
|
|
switch(idx)
|
|
{
|
|
case 302:
|
|
pMultiTest = mdMultiSizeTest302;
|
|
if(inputData == NULL)
|
|
cesaTestCases[0].plainHexStr = cesaDataHexStr3;
|
|
break;
|
|
|
|
case 304:
|
|
pMultiTest = mdMultiSizeTest304;
|
|
if(inputData == NULL)
|
|
cesaTestCases[0].plainHexStr = hashHexStr80;
|
|
break;
|
|
|
|
case 305:
|
|
pMultiTest = mdMultiSizeTest305;
|
|
if(inputData == NULL)
|
|
cesaTestCases[0].plainHexStr = hashHexStr80;
|
|
break;
|
|
|
|
case 402:
|
|
pMultiTest = shaMultiSizeTest402;
|
|
if(inputData == NULL)
|
|
cesaTestCases[0].plainHexStr = hashHexStr80;
|
|
break;
|
|
|
|
case 404:
|
|
pMultiTest = shaMultiSizeTest404;
|
|
if(inputData == NULL)
|
|
cesaTestCases[0].plainHexStr = hashHexStr80;
|
|
break;
|
|
|
|
case 405:
|
|
pMultiTest = shaMultiSizeTest405;
|
|
if(inputData == NULL)
|
|
cesaTestCases[0].plainHexStr = hashHexStr80;
|
|
break;
|
|
|
|
case 502:
|
|
pMultiTest = tripleDesMdMultiSizeTest502;
|
|
if(inputData == NULL)
|
|
cesaTestCases[0].plainHexStr = hashHexStr80;
|
|
break;
|
|
|
|
case 503:
|
|
pMultiTest = tripleDesShaMultiSizeTest503;
|
|
if(inputData == NULL)
|
|
cesaTestCases[0].plainHexStr = hashHexStr80;
|
|
break;
|
|
|
|
case 504:
|
|
iter = 1;
|
|
pMultiTest = cbc3desMdMultiSizeTest504;
|
|
cesaTestCases[0].pCryptoIV = iv1;
|
|
if(inputData == NULL)
|
|
cesaTestCases[0].plainHexStr = hashHexStr80;
|
|
break;
|
|
|
|
case 505:
|
|
iter = 1;
|
|
pMultiTest = cbc3desShaMultiSizeTest505;
|
|
cesaTestCases[0].pCryptoIV = iv1;
|
|
if(inputData == NULL)
|
|
cesaTestCases[0].plainHexStr = hashHexStr80;
|
|
break;
|
|
|
|
case 506:
|
|
iter = 1;
|
|
pMultiTest = cbcAes128md5multiSizeTest506;
|
|
cesaTestCases[0].pCryptoIV = iv5;
|
|
if(inputData == NULL)
|
|
cesaTestCases[0].plainHexStr = hashHexStr80;
|
|
break;
|
|
|
|
case 507:
|
|
iter = 1;
|
|
pMultiTest = cbcAes128sha1multiSizeTest507;
|
|
cesaTestCases[0].pCryptoIV = iv5;
|
|
if(inputData == NULL)
|
|
cesaTestCases[0].plainHexStr = hashHexStr80;
|
|
break;
|
|
|
|
default:
|
|
iter = 1;
|
|
checkMode = CESA_SHOW_CHECK_MODE;
|
|
pMultiTest = mdMultiSizeTest302;
|
|
if(inputData == NULL)
|
|
cesaTestCases[0].plainHexStr = hashHexStr80;
|
|
}
|
|
i = 0;
|
|
while(pMultiTest[i].outputHexStr != NULL)
|
|
{
|
|
cesaTestCases[0].cipherHexStr = (char *)pMultiTest[i].outputHexStr;
|
|
status = testRun(idx, 0, iter, pMultiTest[i].size,
|
|
checkMode);
|
|
if(checkMode != CESA_SHOW_CHECK_MODE)
|
|
{
|
|
cesaReqSize = pMultiTest[i].size;
|
|
printTestResults(idx, status, checkMode);
|
|
}
|
|
if(status != MV_OK)
|
|
break;
|
|
i++;
|
|
}
|
|
testClose(idx);
|
|
/*
|
|
mvCesaDebugStatus();
|
|
cesaTestPrintStatus();
|
|
*/
|
|
}
|
|
|
|
void open_session_test(int idx, int caseIdx, int iter)
|
|
{
|
|
int reqIdError, cryptoError, openErrors, i;
|
|
int openErrDisp[100];
|
|
MV_STATUS status;
|
|
|
|
memset(openErrDisp, 0, sizeof(openErrDisp));
|
|
openErrors = 0;
|
|
reqIdError = 0;
|
|
cryptoError = 0;
|
|
for(i=0; i<iter; i++)
|
|
{
|
|
status = testOpen(idx);
|
|
if(status != MV_OK)
|
|
{
|
|
openErrors++;
|
|
openErrDisp[status]++;
|
|
}
|
|
else
|
|
{
|
|
testRun(idx, caseIdx, 1, 0, CESA_FAST_CHECK_MODE);
|
|
if(cesaCryptoError > 0)
|
|
cryptoError++;
|
|
if(cesaReqIdError > 0)
|
|
reqIdError++;
|
|
|
|
testClose(idx);
|
|
}
|
|
}
|
|
if(cryptoError > 0)
|
|
mvOsPrintf("cryptoError : %d\n", cryptoError);
|
|
if(reqIdError > 0)
|
|
mvOsPrintf("reqIdError : %d\n", reqIdError);
|
|
|
|
if(openErrors > 0)
|
|
{
|
|
mvOsPrintf("Open Errors = %d\n", openErrors);
|
|
for(i=0; i<100; i++)
|
|
{
|
|
if(openErrDisp[i] != 0)
|
|
mvOsPrintf("Error %d - occurs %d times\n", i, openErrDisp[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void loopback_test(int idx, int iter, int size, char* pPlainData)
|
|
{
|
|
}
|
|
|
|
|
|
#if defined(MV_VXWORKS)
|
|
int testMode = 0;
|
|
unsigned __TASKCONV cesaTask(void* args)
|
|
{
|
|
int reqSize = cesaReqSize;
|
|
|
|
if(testMode == 0)
|
|
{
|
|
cesaOneTest(cesaTestIdx, cesaCaseIdx, cesaIteration,
|
|
reqSize, cesaCheckMode);
|
|
}
|
|
else
|
|
{
|
|
if(testMode == 1)
|
|
{
|
|
cesaTest(cesaIteration, reqSize, cesaCheckMode);
|
|
combiTest(cesaIteration, reqSize, cesaCheckMode);
|
|
}
|
|
else
|
|
{
|
|
multiSizeTest(cesaIdx, cesaIteration, cesaCheckMode, NULL);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void oneTest(int testIdx, int caseIdx,
|
|
int iter, int reqSize, int checkMode)
|
|
{
|
|
long rc;
|
|
|
|
cesaIteration = iter;
|
|
cesaReqSize = cesaRateSize = reqSize;
|
|
cesaCheckMode = checkMode;
|
|
testMode = 0;
|
|
cesaTestIdx = testIdx;
|
|
cesaCaseIdx = caseIdx;
|
|
rc = mvOsTaskCreate("CESA_T", 100, 4*1024, cesaTask, NULL, &cesaTaskId);
|
|
if (rc != MV_OK)
|
|
{
|
|
mvOsPrintf("hMW: Can't create CESA multiCmd test task, rc = %ld\n", rc);
|
|
}
|
|
}
|
|
|
|
void multiTest(int iter, int reqSize, int checkMode)
|
|
{
|
|
long rc;
|
|
|
|
cesaIteration = iter;
|
|
cesaCheckMode = checkMode;
|
|
cesaReqSize = reqSize;
|
|
testMode = 1;
|
|
rc = mvOsTaskCreate("CESA_T", 100, 4*1024, cesaTask, NULL, &cesaTaskId);
|
|
if (rc != MV_OK)
|
|
{
|
|
mvOsPrintf("hMW: Can't create CESA multiCmd test task, rc = %ld\n", rc);
|
|
}
|
|
}
|
|
|
|
void sizeTest(int testIdx, int iter, int checkMode)
|
|
{
|
|
long rc;
|
|
|
|
cesaIteration = iter;
|
|
cesaCheckMode = checkMode;
|
|
testMode = 2;
|
|
cesaIdx = testIdx;
|
|
rc = mvOsTaskCreate("CESA_T", 100, 4*1024, cesaTask, NULL, &cesaTaskId);
|
|
if (rc != MV_OK)
|
|
{
|
|
mvOsPrintf("hMW: Can't create CESA test task, rc = %ld\n", rc);
|
|
}
|
|
}
|
|
|
|
#endif /* MV_VXWORKS */
|
|
|
|
extern void mvCesaDebugSA(short sid, int mode);
|
|
void cesaTestPrintSession(int idx)
|
|
{
|
|
int testIdx;
|
|
MV_CESA_TEST_SESSION* pTestSession;
|
|
|
|
pTestSession = getTestSessionDb(idx, &testIdx);
|
|
if(pTestSession == NULL)
|
|
{
|
|
mvOsPrintf("Test %d is not exist\n", idx);
|
|
return;
|
|
}
|
|
pTestSession = &pTestSession[testIdx];
|
|
|
|
if(pTestSession->sid == -1)
|
|
{
|
|
mvOsPrintf("Test session %d is not opened\n", idx);
|
|
return;
|
|
}
|
|
|
|
mvCesaDebugSA(pTestSession->sid, 1);
|
|
}
|
|
|
|
void cesaTestPrintStatus(void)
|
|
{
|
|
mvOsPrintf("\n\t Cesa Test Status\n\n");
|
|
|
|
mvOsPrintf("isrCount=%d\n",
|
|
cesaTestIsrCount);
|
|
|
|
#ifdef CESA_TEST_DEBUG
|
|
{
|
|
int i, j;
|
|
j = cesaTestTraceIdx;
|
|
mvOsPrintf("No Type Cause rCause iCause Res Time pReady pProc pEmpty\n");
|
|
for(i=0; i<MV_CESA_TEST_TRACE_SIZE; i++)
|
|
{
|
|
mvOsPrintf("%02d. %d 0x%04x 0x%04x 0x%04x 0x%02x 0x%02x %02d 0x%06x %p %p %p\n",
|
|
j, cesaTestTrace[j].type, cesaTestTrace[j].cause, cesaTestTrace[j].realCause,
|
|
cesaTestTrace[j].dmaCause, cesaTestTrace[j].resources, cesaTestTrace[j].timeStamp,
|
|
cesaTestTrace[j].pReqReady, cesaTestTrace[j].pReqProcess, cesaTestTrace[j].pReqEmpty);
|
|
j++;
|
|
if(j == MV_CESA_TEST_TRACE_SIZE)
|
|
j = 0;
|
|
}
|
|
}
|
|
#endif /* CESA_TEST_DEBUG */
|
|
}
|