testdes.c

来自「freescale ppc sec2加解密单元驱动」· C语言 代码 · 共 792 行 · 第 1/3 页

    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;
}