+++ /dev/null
-/*******************************************************************************
-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 */
-}
projects / openwrt / svn-archive / archive.git / blobdiff