testdes.c

freescale ppc sec2加解密单元驱动

    0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
    0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0x01, 0x23,
    0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
    0x67, 0x89, 0xab, 0xcd, 0xef, 0x01, 0x23, 0x45,
    0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56,
    0x89, 0xab, 0xcd, 0xef, 0x01, 0x23, 0x45, 0x67,
    0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56, 0x78,
    0xab, 0xcd, 0xef, 0x01, 0x23, 0x45, 0x67, 0x89,
    0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56, 0x78, 0x9a,
    0xcd, 0xef, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab,
    0xde, 0xf0, 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,
    0xef, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd,
    0xf0, 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde
};

static const unsigned char desKey[] = {
    0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
    0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10, 
    0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88 
};

static const unsigned char iv_in[] = "abcedf01";

static unsigned char desDecResult[DES_MAXTESTSIZE];
static unsigned char desEncResult[DES_MAXTESTSIZE];
static unsigned char desCtxOut[DES_CTXSIZE];


int testDes(int len, int times)
{
    DES_LOADCTX_CRYPT_REQ desencReq;
    DES_LOADCTX_CRYPT_REQ desdecReq;
    int status;
    int i, a, b;
    unsigned long encryptopId, decryptopId, keyBytes;
    int algoType;    

    if (len > 4096)
    {
        printf("testDes(): test data size limit is %d\n", DES_MAXTESTSIZE);
        return(-1);
    }
    
    for (b=0; b < 2; b++) 
    {
        if (b == 0) 
        {
            printf("\n*** Test TDES CBC *** %d size %d times\n", len, times);
            encryptopId = DPD_TDES_CBC_CTX_ENCRYPT;
            decryptopId = DPD_TDES_CBC_CTX_DECRYPT;
            keyBytes = 24;
        }
        else
        {
            printf("\n*** Test SDES CBC *** %d size %d times\n", len, times);
            encryptopId = DPD_SDES_CBC_CTX_ENCRYPT;
            decryptopId = DPD_SDES_CBC_CTX_DECRYPT;
            keyBytes = 8;
        }
        
        for (a = 0; a < times; a++)
        {    
            memset(&desencReq, 0, sizeof(desencReq));
            memset(&desdecReq, 0, sizeof(desdecReq));
        
            memset(desDecResult, 0, len);
            memset(desEncResult, 0, len);
            memset(desCtxOut,    0, DES_CTXSIZE);
        
            desencReq.opId       = encryptopId;
            desencReq.inIvBytes  = DES_CTXSIZE;
            desencReq.keyBytes   = keyBytes;
            desencReq.outIvBytes = DES_CTXSIZE;
            desencReq.inBytes    = len;
            desencReq.inIvData   = (unsigned char *)iv_in;
            desencReq.keyData    = (unsigned char *)desKey;
            desencReq.inData     = (unsigned char *)desData;
            desencReq.outIvData  = desCtxOut;
            desencReq.outData    = desEncResult;            
            algoType = DRV_IPSEC_DES_ENCRYPT;   
            
            status = SEC2_ioctl(IOCTL_PROC_REQ, (void*)&desencReq);
        
            if (status = waitCompletion("testDes(): CBC encryption test", status, &desencReq))
            {
                return status;
            }
                
        
            desdecReq.opId       = decryptopId;
            desdecReq.inIvBytes  = DES_CTXSIZE;
            desdecReq.outIvBytes = DES_CTXSIZE;
            desdecReq.keyBytes   = keyBytes;
            desdecReq.inBytes    = len;
            desdecReq.inIvData   = (unsigned char *)iv_in;
            desdecReq.keyData    = (unsigned char *)desKey;
            desdecReq.inData     = desEncResult;
            desdecReq.outData    = desDecResult;
            desdecReq.outIvData  = desCtxOut;        
            algoType = DRV_IPSEC_3DES_ENCRYPT;
            
            status = SEC2_ioctl(IOCTL_PROC_REQ, (void*)&desencReq);
        
            if (status = waitCompletion("testDes(): CBC decryption test", status, &desdecReq))
            {
                return status;
            }
               
        
            if ((memcmp(desData, desDecResult, len)) == 0) {
                printf("*** Test DES CBC Passed ***\n");
                status = 0;
            } else {
                printf("*** Test DES CBC Failed ***\n");
                status = -1;
            }
        } /* for a */
    
        printf("*** Test DES CBC Done ***\n");
    } /* for b */
    return status;
}



int testDesECB(int fd, int len, int times)
{
    DES_CRYPT_REQ desencReq;
    DES_CRYPT_REQ desdecReq;
    int           device=0, status;
    int           a, b;
    unsigned long encryptopId, decryptopId, keyBytes;
    
    for (b=0; b < 2; b++) 
    {
        if (b == 0) 
        {
            printf("\n*** Test TDES ECB Mode *** %d size %d times\n", len, times);
            encryptopId = DPD_TDES_ECB_ENCRYPT;
            decryptopId = DPD_TDES_ECB_DECRYPT;
            keyBytes = 24;
        }
        else
        {
            printf("\n*** Test SDES ECB Mode *** %d size %d times\n", len, times);
            encryptopId = DPD_SDES_ECB_ENCRYPT;
            decryptopId = DPD_SDES_ECB_DECRYPT;
            keyBytes = 8;
        }
        

        for (a = 0; a < times; a++)
        {
            memset(&desencReq,   0, sizeof(desencReq));
            memset(&desdecReq,   0, sizeof(desdecReq));
            memset(desDecResult, 0, len);
            memset(desEncResult, 0, len);
        
            desencReq.opId     = encryptopId;
            desencReq.keyBytes = keyBytes;
            desencReq.inBytes  = len;
            desencReq.keyData  = (unsigned char *)desKey;
            desencReq.inData   = (unsigned char *)desData;
            desencReq.outData  = desEncResult;
        
        
            status = putKmem(fd, desKey, &desencReq.keyData, desencReq.keyBytes);
            if (status)
                return status;
        
            status = putKmem(fd, desData, &desencReq.inData, desencReq.inBytes);
            if (status) {
                freeKmem(fd, &desencReq.keyData);
                return status;
            }
        
            status = putKmem(fd, NULL, &desencReq.outData, desencReq.inBytes);
            if (status) {
                freeKmem(fd, &desencReq.keyData);
                freeKmem(fd, &desencReq.inData);
            }
        
        
            armCompletion(&desencReq);
            status = ioctl(fd, IOCTL_PROC_REQ, (int)&desencReq);
        
            if (status = waitCompletion("testDes(): CBC encryption test", status, &desencReq))
            {
                freeKmem(fd, &desencReq.keyData);
                freeKmem(fd, &desencReq.inData);
                freeKmem(fd, &desencReq.outData);
                return status;
            }
        
            getKmem(fd, desEncResult, &desencReq.outData, desencReq.inBytes);
        
            freeKmem(fd, &desencReq.keyData);
            freeKmem(fd, &desencReq.inData);
            freeKmem(fd, &desencReq.outData);
        
            desdecReq.opId     = decryptopId;
            desdecReq.keyBytes = keyBytes;
            desdecReq.inBytes  = len;
            desdecReq.keyData  = (unsigned char *)desKey;
            desdecReq.inData   = desEncResult;
            desdecReq.outData  = desDecResult;
        
        
            status = putKmem(fd, desKey, &desdecReq.keyData, desdecReq.keyBytes);
            if (status)
                return status;
        
            status = putKmem(fd, desEncResult, &desdecReq.inData, desdecReq.inBytes);
            if (status) {
                freeKmem(fd, &desdecReq.keyData);
                return status;
            }
        
            status = putKmem(fd, NULL, &desdecReq.outData, desdecReq.inBytes);
            if (status) {
                freeKmem(fd, &desdecReq.keyData);
                freeKmem(fd, &desdecReq.inData);
            }
        
        
       
            armCompletion(&desdecReq);
            status = ioctl(fd, IOCTL_PROC_REQ, (int)&desdecReq);
        
            if (status = waitCompletion("testDes(): CBC decryption test", status, &desdecReq))
            {
                freeKmem(fd, &desdecReq.keyData);
                freeKmem(fd, &desdecReq.inData);
                freeKmem(fd, &desdecReq.outData);
                return status;
            }
        
            getKmem(fd, desDecResult, &desdecReq.outData, desdecReq.inBytes);
        
            freeKmem(fd, &desdecReq.keyData);
            freeKmem(fd, &desdecReq.inData);
            freeKmem(fd, &desdecReq.outData);
        
        
        
            if ((memcmp(desData, desDecResult, len)) == 0) {
                printf("*** Test DES ECB Passed ***\n");
                status = 0;
            } else {
                printf("*** Test DES ECB Failed ***\n");
                status = -1;
            }
        }
        printf("*** Test DES ECB Done ***\n");
    }
    
    return status;
}