예제 #1
0
int pkha_add(int fd)
{
    int           status, tstat;
    MOD_2OP_REQ   addReq;
    unsigned char p4data[32];

    
    memset(p4data,  0, 32);
    memset(&addReq, 0, sizeof(addReq));


    /* ADD test */
    addReq.opId       = DPD_MM_LDCTX_ADD_ULCTX;
    addReq.bDataBytes = 32;
    addReq.aDataBytes = 32;
    addReq.modBytes   = 32;
    addReq.outBytes   = 32;
    addReq.bData      = (unsigned char *)add_p0data;
    addReq.aData      = (unsigned char *)add_p1data;
    addReq.modData    = (unsigned char *)add_p3data;
    addReq.outData    = p4data;

    status = putKmem(fd, (void *)add_p0data, (void **)&addReq.bData, addReq.bDataBytes);
    if (status)
        return status;
    
    status = putKmem(fd, (void *)add_p1data, (void **)&addReq.aData,  addReq.aDataBytes);
    if (status) {
        freeKmem(fd, (void **)&addReq.bData);
        return status;
    }
    
    status = putKmem(fd, (void *)add_p3data, (void **)&addReq.modData, addReq.modBytes);
    if (status) {
        freeKmem(fd, (void **)&addReq.bData);
        freeKmem(fd, (void **)&addReq.aData);
        return status;
    }

    status = putKmem(fd, NULL, (void **)&addReq.outData, addReq.outBytes);
    if (status) {
        freeKmem(fd, (void **)&addReq.bData);
        freeKmem(fd, (void **)&addReq.aData);
        freeKmem(fd, (void **)&addReq.modData);
        return status;
    }

    armCompletion(&addReq);
    status = ioctl(fd, IOCTL_PROC_REQ, (int)&addReq);

    if ((status = waitCompletion("testPKHA(): modular add test", status, &addReq)))
    {
        freeKmem(fd, (void **)&addReq.bData);
        freeKmem(fd, (void **)&addReq.aData);
        freeKmem(fd, (void **)&addReq.modData);
        freeKmem(fd, (void **)&addReq.outData);
        return status;
    }
    getKmem(fd, p4data, (void **)&addReq.outData, addReq.outBytes);

    freeKmem(fd, (void **)&addReq.bData);
    freeKmem(fd, (void **)&addReq.aData);
    freeKmem(fd, (void **)&addReq.modData);
    freeKmem(fd, (void **)&addReq.outData);


    if (memcmp((unsigned char *)p4data,
               (unsigned char *)add_exp_p4,
               32) != 0)
    {
      dumpm(p4data, 32);
      tstat = -1;
    }
    else
    {
      printf("Results from ADD as expected\n");
      tstat = 0;
    }

    return(tstat);
}
예제 #2
0
int pkha_rrmodp(int fd)
{
    int            status, tstat;
    MOD_RRMODP_REQ rrmodpReq;


    unsigned char p4data[256];


    memset (p4data, 0, 256);
    memset(&rrmodpReq, 0, sizeof(rrmodpReq));


    /* RRMODP test */
    rrmodpReq.opId     = DPD_MM_LDCTX_RRMODP_ULCTX;
    rrmodpReq.nBytes   = 64;
    rrmodpReq.pBytes   = 40;
    rrmodpReq.outBytes = 40;
    rrmodpReq.pData    = (unsigned char *)modp_p3data;
    rrmodpReq.outData  = p4data;

    status = putKmem(fd, (void *)modp_p3data, (void **)&rrmodpReq.pData, rrmodpReq.pBytes);
    if (status)
        return status;
    
    status = putKmem(fd, NULL, (void **)&rrmodpReq.outData,  rrmodpReq.outBytes);
    if (status) {
        freeKmem(fd, (void **)&rrmodpReq.outData);
        return status;
    }
    
    armCompletion(&rrmodpReq);
    status = ioctl(fd, IOCTL_PROC_REQ, (int)&rrmodpReq);

    if ((status = waitCompletion("testPKHA(): RRMODP test", status, &rrmodpReq)))
    {
        freeKmem(fd, (void **)&rrmodpReq.pData);
        freeKmem(fd, (void **)&rrmodpReq.outData);
        return status;
    }
    
    getKmem(fd, p4data, (void **)&rrmodpReq.outData, rrmodpReq.outBytes);

    freeKmem(fd, (void **)&rrmodpReq.pData);
    freeKmem(fd, (void **)&rrmodpReq.outData);

    if (memcmp((unsigned char *)p4data,
               (unsigned char *)modp_exp_p4,
               40) != 0)
    {
      printf("RRMODP result miscompare\n");
      printf("actual result:\n");
      dumpm(p4data, 40);
      printf("expected result:\n");
      dumpm((unsigned char *)modp_exp_p4, 40);
      tstat = -1;
    }
    else
    {
      printf("Results from RRMODP as expected\n");
      tstat = 0;
    }

    return(tstat);
}
예제 #3
0
int pkha_f2m_mult2(int fd)
{
    int         status, tstat;
    MOD_2OP_REQ f2m_mult2Req;

    unsigned char p4data[256];

    memset (p4data, 0, 256);
    memset (&f2m_mult2Req, 0, sizeof(f2m_mult2Req));


    /* F2M MULT2 test */
    f2m_mult2Req.opId       = DPD_POLY_LDCTX_A0_B0_MUL2_ULCTX;
    f2m_mult2Req.bDataBytes = 256;
    f2m_mult2Req.aDataBytes = 256;
    f2m_mult2Req.modBytes   = 24;
    f2m_mult2Req.outBytes   = 24;
    f2m_mult2Req.bData      = (unsigned char *)f2mmul2_p0data;
    f2m_mult2Req.aData      = (unsigned char *)f2mmul2_p1data;
    f2m_mult2Req.modData    = (unsigned char *)f2mmul2_p3data;
    f2m_mult2Req.outData    = p4data;

    status = putKmem(fd, (void *)f2mmul2_p0data, (void **)&f2m_mult2Req.bData, f2m_mult2Req.bDataBytes);
    if (status)
        return status;
    
    status = putKmem(fd, (void *)f2mmul2_p1data, (void **)&f2m_mult2Req.aData,  f2m_mult2Req.aDataBytes);
    if (status) {
        freeKmem(fd, (void **)&f2m_mult2Req.bData);
        return status;
    }
    
    status = putKmem(fd, (void *)f2mmul2_p3data, (void **)&f2m_mult2Req.modData, f2m_mult2Req.modBytes);
    if (status) {
        freeKmem(fd, (void **)&f2m_mult2Req.bData);
        freeKmem(fd, (void **)&f2m_mult2Req.aData);
        return status;
    }

    status = putKmem(fd, NULL, (void **)&f2m_mult2Req.outData, f2m_mult2Req.outBytes);
    if (status) {
        freeKmem(fd, (void **)&f2m_mult2Req.bData);
        freeKmem(fd, (void **)&f2m_mult2Req.aData);
        freeKmem(fd, (void **)&f2m_mult2Req.modData);
        return status;
    }

    
    armCompletion(&f2m_mult2Req);
    status = ioctl(fd, IOCTL_PROC_REQ, (int)&f2m_mult2Req);

    if ((status = waitCompletion("testPKHA(): modular mult test", status, &f2m_mult2Req)))
    {
        freeKmem(fd, (void **)&f2m_mult2Req.bData);
        freeKmem(fd, (void **)&f2m_mult2Req.aData);
        freeKmem(fd, (void **)&f2m_mult2Req.modData);
        freeKmem(fd, (void **)&f2m_mult2Req.outData);
        return status;
    }
    
    getKmem(fd, p4data, (void **)&f2m_mult2Req.outData, f2m_mult2Req.outBytes);

    freeKmem(fd, (void **)&f2m_mult2Req.bData);
    freeKmem(fd, (void **)&f2m_mult2Req.aData);
    freeKmem(fd, (void **)&f2m_mult2Req.modData);
    freeKmem(fd, (void **)&f2m_mult2Req.outData);


    if (memcmp((unsigned char *)p4data,
               (unsigned char *)f2mmul2_exp_p4,
               24) != 0)
    {
      dumpm(p4data, 24);
      tstat = -1;
    }
    else
    {
      printf ("Results from F2M_MULT2 as expected\n");
      tstat = 0;
    }

    return(tstat);
}
예제 #4
0
int pkha_mul2(int fd)
{
    int         status, tstat;
    MOD_2OP_REQ mult2Req;

    unsigned char p4data[MUL2_DATASIZE];

    memset(p4data,    0, MUL2_DATASIZE);
    memset(&mult2Req, 0, sizeof(mult2Req));

    /* MULT2 test */
    mult2Req.opId       = DPD_MM_LDCTX_MUL2_ULCTX;
    mult2Req.bDataBytes = MUL2_DATASIZE;
    mult2Req.aDataBytes = MUL2_DATASIZE;
    mult2Req.modBytes   = MUL2_DATASIZE;
    mult2Req.outBytes   = MUL2_DATASIZE;
    mult2Req.bData      = (unsigned char *)mul2_p0data;
    mult2Req.aData      = (unsigned char *)mul2_p1data;
    mult2Req.modData    = (unsigned char *)mul2_p3data;
    mult2Req.outData    = p4data;

    status = putKmem(fd, (void *)mul2_p0data, (void **)&mult2Req.bData, mult2Req.bDataBytes);
    if (status)
        return status;

    status = putKmem(fd, (void *)mul2_p1data, (void **)&mult2Req.aData,  mult2Req.aDataBytes);
    if (status) {
        freeKmem(fd, (void **)&mult2Req.bData);
        return status;
    }
    
    status = putKmem(fd, (void *)mul2_p3data, (void **)&mult2Req.modData, mult2Req.modBytes);
    if (status) {
        freeKmem(fd, (void **)&mult2Req.bData);
        freeKmem(fd, (void **)&mult2Req.aData);
        return status;
    }

    status = putKmem(fd, NULL, (void **)&mult2Req.outData, mult2Req.outBytes);
    if (status) {
        freeKmem(fd, (void **)&mult2Req.bData);
        freeKmem(fd, (void **)&mult2Req.aData);
        freeKmem(fd, (void **)&mult2Req.modData);
        return status;
    }

    armCompletion(&mult2Req);
    status = ioctl(fd, IOCTL_PROC_REQ, (int)&mult2Req);

    if ((status = waitCompletion("testPKHA(): modular mult test", status, &mult2Req)))
    {
        freeKmem(fd, (void **)&mult2Req.bData);
        freeKmem(fd, (void **)&mult2Req.aData);
        freeKmem(fd, (void **)&mult2Req.modData);
        freeKmem(fd, (void **)&mult2Req.outData);
        return status;
    }
    
    getKmem(fd, p4data, (void **)&mult2Req.outData, mult2Req.outBytes);

    freeKmem(fd, (void **)&mult2Req.bData);
    freeKmem(fd, (void **)&mult2Req.aData);
    freeKmem(fd, (void **)&mult2Req.modData);
    freeKmem(fd, (void **)&mult2Req.outData);


    if (memcmp((unsigned char *)p4data,
               (unsigned char *)mul2_exp_p4,
               MUL2_DATASIZE) != 0)
    {
        dumpm(p4data, MUL2_DATASIZE);
        tstat = -1;
    }
    else
    {
        printf("pkha_mul2(): Results from MULT2 as expected\n");
        tstat = 0;
    }

    return(tstat);
}
예제 #5
0
int pkha_subtract(int fd)
{
    int status, tstat;
    MOD_2OP_REQ   subReq;
    unsigned char p4data[256];

    memset (p4data,  0, 256);
    memset (&subReq, 0, sizeof(subReq));

    /* SUBTRACT test */
    subReq.opId       = DPD_MM_LDCTX_SUB_ULCTX;
    subReq.bDataBytes = 28;
    subReq.aDataBytes = 28;
    subReq.modBytes   = 28;
    subReq.outBytes   = 28;
    subReq.bData      = (unsigned char *)sub_p0data;
    subReq.aData      = (unsigned char *)sub_p1data;
    subReq.modData    = (unsigned char *)sub_p3data;
    subReq.outData    = p4data;

    status = putKmem(fd, (void *)sub_p0data, (void **)&subReq.bData, subReq.bDataBytes);
    if (status)
        return status;
    
    status = putKmem(fd, (void *)sub_p1data, (void **)&subReq.aData,  subReq.aDataBytes);
    if (status) {
        freeKmem(fd, (void **)&subReq.bData);
        return status;
    }
    
    status = putKmem(fd, (void *)sub_p3data, (void **)&subReq.modData, subReq.modBytes);
    if (status) {
        freeKmem(fd, (void **)&subReq.bData);
        freeKmem(fd, (void **)&subReq.aData);
        return status;
    }

    status = putKmem(fd, NULL, (void **)&subReq.outData, subReq.outBytes);
    if (status) {
        freeKmem(fd, (void **)&subReq.bData);
        freeKmem(fd, (void **)&subReq.aData);
        freeKmem(fd, (void **)&subReq.modData);
        return status;
    }

    
    armCompletion(&subReq);
    status = ioctl(fd, IOCTL_PROC_REQ, (int)&subReq);

    if ((status = waitCompletion("testPKHA(): modular subtraction test", status, &subReq)))
    {
        freeKmem(fd, (void **)&subReq.bData);
        freeKmem(fd, (void **)&subReq.aData);
        freeKmem(fd, (void **)&subReq.modData);
        freeKmem(fd, (void **)&subReq.outData);
        return status;
    }
    
    getKmem(fd, p4data, (void **)&subReq.outData, subReq.outBytes);

    freeKmem(fd, (void **)&subReq.bData);
    freeKmem(fd, (void **)&subReq.aData);
    freeKmem(fd, (void **)&subReq.modData);
    freeKmem(fd, (void **)&subReq.outData);

    if (memcmp((unsigned char *)p4data,
               (unsigned char *)sub_exp_p4,
               28) != 0)
    {
      dumpm(p4data, 28);
      tstat = -1;
    }
    else
    {
      printf ("Results from SUBTRACT as expected\n");
      tstat = 0;
    }

    return(tstat);
}
예제 #6
0
int testTLS(int fd)
{
    TLS_BLOCK_OUTBOUND_REQ tlsRq;
    int                    status, fail;

    printf("*** Test TLS Block Outbound  ***\n");
    
    /* clear request block */
    memset(&tlsRq,    0, sizeof(tlsRq));
    memset(packetOut, 0, 256);
    

    /* set up request */
    tlsRq.opId            = DPD_TLS_BLOCK_OUTBOUND_SDES_SHA1;
    
    tlsRq.hashKeyBytes    = 20;
    tlsRq.hashKeyData     = (unsigned char *)authKey;

    tlsRq.ivBytes         = 8;
    tlsRq.ivData          = in_iv;

    tlsRq.cipherKeyBytes  = 8;
    tlsRq.cipherKeyData   = (unsigned char *)EncKey;
    
    tlsRq.ivOutBytes      = 8;
    tlsRq.ivOutData       = outivdata;

    tlsRq.outBytes        = 256;
    tlsRq.outData         = packetOut;

    tlsRq.hashOnlyBytes   = 13;
    tlsRq.mainDataBytes   = 235;
    tlsRq.MACbytes        = 20;
    tlsRq.cipherOnlyBytes = 1;
    tlsRq.hashOnlyData	  = packetIn;


    status = putKmem(fd, (void *)authKey, (void **)&tlsRq.hashKeyData, tlsRq.hashKeyBytes);
    if (status)
        return status;

    status = putKmem(fd, (void *)in_iv, (void **)&tlsRq.ivData, tlsRq.ivBytes);
    if (status) {
        freeKmem(fd, (void **)&tlsRq.hashKeyData);
        return status;
    }
    
    status = putKmem(fd, (void *)EncKey, (void **)&tlsRq.cipherKeyData, tlsRq.cipherKeyBytes);
    if (status) {
        freeKmem(fd, (void **)&tlsRq.hashKeyData);
        freeKmem(fd, (void **)&tlsRq.ivData);
        return status;
    }
    
    status = putKmem(fd, NULL, (void **)&tlsRq.ivOutData, tlsRq.ivOutBytes);
    if (status) {
        freeKmem(fd, (void **)&tlsRq.hashKeyData);
        freeKmem(fd, (void **)&tlsRq.ivData);
        freeKmem(fd, (void **)&tlsRq.cipherKeyData);
        return status;
    }

    status = putKmem(fd, NULL, (void **)&tlsRq.outData, tlsRq.outBytes);
    if (status) {
        freeKmem(fd, (void **)&tlsRq.hashKeyData);
        freeKmem(fd, (void **)&tlsRq.ivData);
        freeKmem(fd, (void **)&tlsRq.cipherKeyData);
        freeKmem(fd, (void **)&tlsRq.ivOutData);
        return status;
    }
    
    status = putKmem(fd, (void *)packetIn, (void **)&tlsRq.hashOnlyData, 284);
    if (status) {
        freeKmem(fd, (void **)&tlsRq.hashKeyData);
        freeKmem(fd, (void **)&tlsRq.ivData);
        freeKmem(fd, (void **)&tlsRq.cipherKeyData);
        freeKmem(fd, (void **)&tlsRq.ivOutData);
        freeKmem(fd, (void **)&tlsRq.outData);
        return status;
    }
    
    tlsRq.cipherOnlyData = &tlsRq.hashOnlyData[268];
    
    armCompletion(&tlsRq);
    status = ioctl(fd, IOCTL_PROC_REQ, (int)&tlsRq);
    
    if ((status = waitCompletion("testTLS(): outbound block test", status, &tlsRq)))
    {
        freeKmem(fd, (void **)&tlsRq.hashKeyData);
        freeKmem(fd, (void **)&tlsRq.ivData);
        freeKmem(fd, (void **)&tlsRq.cipherKeyData);
        freeKmem(fd, (void **)&tlsRq.ivOutData);
        freeKmem(fd, (void **)&tlsRq.outData);
        freeKmem(fd, (void **)&tlsRq.hashOnlyData);
        return status;
    }
        
    getKmem(fd, outivdata, (void **)&tlsRq.ivOutData, tlsRq.ivOutBytes);
    getKmem(fd, packetOut, (void **)&tlsRq.outData, tlsRq.outBytes);
    
    freeKmem(fd, (void **)&tlsRq.hashKeyData);
    freeKmem(fd, (void **)&tlsRq.ivData);
    freeKmem(fd, (void **)&tlsRq.cipherKeyData);
    freeKmem(fd, (void **)&tlsRq.ivOutData);
    freeKmem(fd, (void **)&tlsRq.outData);
    freeKmem(fd, (void **)&tlsRq.hashOnlyData);

    /* run results comparisons */

    fail = 0;

    if ((memcmp(outivdata, exp_iv_out, 8)) != 0)
    {
        printf("cipher context out miscompare\n");
        printf("expected result:\n");
        dumpm((unsigned char *)exp_iv_out, 8);
        printf("actual result:\n");
        dumpm(outivdata, 8);
        fail++;
    }

    if ((memcmp(packetOut, exp_cipher_out, 256)) != 0)
    {
        printf("packet out miscompare\n");
        printf("expected result:\n");
        dumpm((unsigned char *)exp_cipher_out, 256);
        printf("actual result:\n");
        dumpm(packetOut, 256);
        fail++;
    }


    printf("*** Test TLS Block Outbound - ");
    if (fail)
    {
        printf("failed ***\n");
        return(-1);
    }
    else
    {
        printf("passed ***\n");
        return(0);
    }
    
    return 0;
}