rijndael.c

IBM的Linux上的PKCS#11实现

        CK_KEY_TYPE             key_type = CKK_AES;
        CK_UTF8CHAR             label[] = "AES secret key object";
        CK_BBOOL                true = TRUE;

        CK_ATTRIBUTE            template[] = {
                {CKA_CLASS,     &class,         sizeof(class)},
                {CKA_KEY_TYPE,  &key_type,      sizeof(key_type)},
                {CKA_TOKEN,     &true,          sizeof(true)},
                {CKA_LABEL,     label,          sizeof(label)-1},
                {CKA_ENCRYPT,   &true,          sizeof(true)},
                {CKA_VALUE,     key256,         sizeof(key256)},
                {CKA_VALUE_LEN, &key_size,      sizeof(key_size)}
        };

        CK_OBJECT_HANDLE        h_key;
        CK_MECHANISM            mech;


        memset( key256, 0, sizeof(key256) );
        memset( pt, 0, sizeof(pt) );
        memset( ct, 0, sizeof(ct) );
        memset( final_pt, 0, sizeof(final_pt) );
	
	if( (rc = funcs->C_CreateObject(sess, template, 7, &h_key)) != CKR_OK) {
		OC_ERR_MSG("C_CreateObject #1", rc);
		goto done;
	}
	

        mech.mechanism = CKM_AES_ECB;
        mech.ulParameterLen = 0;
        mech.pParameter = NULL;

        for( i=0; i<400; i++) {

                if(i==399)
                        memcpy(final_pt, ct+16, sizeof(final_pt));

                for( j=0; j<10000; j++) {

			memcpy(ct, ct+16, 16);

                        rc = funcs->C_EncryptInit(sess, &mech, h_key);
                        if (rc != CKR_OK) {
                                OC_ERR_MSG("   C_EncryptInit #1", rc);
                                goto done;
                        }

                        rc = funcs->C_Encrypt(sess, pt, pt_len, ct+16, &ct_len);
                        if (rc != CKR_OK) {
                                OC_ERR_MSG("   C_Encrypt #1", rc);
                                goto done;
                        }

                        /* After the final encrypt, we need to keep the
                         * plain text pure */
                        if(i == 399 && j == 9999)
                                goto print_done;
                        else {
                                memcpy(pt, ct+16, sizeof(pt));
			}
                }
                for( k=0; k<sizeof(ct); k++)
                        key256[k] ^= ct[k];

                if( (rc = funcs->C_DestroyObject(sess, h_key)) != CKR_OK) {
                        OC_ERR_MSG("C_DestroyObject", rc);
                        goto done;
                }

                if( (rc = funcs->C_CreateObject(sess, template, 7, &h_key)) != CKR_OK) {
                        OC_ERR_MSG("C_CreateObject #2", rc);
                        goto done;
                }

                /* One status tick */
                if(!(i%5)) {
                        printf(".");
                        fflush(stdout);
                }
        }

print_done:
	printf("\n");

        for( i=0; i<sizeof(key256); i++) {
                if(key256[i] != KAT_256_ECB_KEY[i]) {
                        printf("%s:%d Error: key data does not match known "
                                "key data at byte %d.\n", __FILE__, __LINE__, i);
			rc = -1;
                        goto done;
                }
        }

        for( i=0; i<sizeof(final_pt); i++) {
                if(final_pt[i] != KAT_256_ECB_PT[i]) {
                        printf("%s:%d Error: Plain text does not match known "
                                "plain text at byte %d.\n", __FILE__, __LINE__, i);
			rc = -1;
                        goto done;
                }
        }
        for( i=0; i<AES_BLOCK_SIZE; i++) {
                if(ct[i+16] != KAT_256_ECB_CT[i]) {
                        printf("%s:%d Error: Cipher text does not match known "
                                "cipher text at byte %d.\n", __FILE__, __LINE__, i);
			rc = -1;
                        goto done;
                }
        }
done:
        return rc;

}



int do_AES_KAT_128_CBC(void)
{
        int                     i, j, k;
        CK_RV                   rc;
        CK_BYTE                 pt[AES_BLOCK_SIZE],
                                ct[16],
				old_ct[16],
                                final_pt[AES_BLOCK_SIZE],
                                key[AES_KEY_SIZE_128],
				iv[AES_BLOCK_SIZE],
				cv[AES_BLOCK_SIZE];
        CK_ULONG                pt_len = AES_BLOCK_SIZE;
        CK_ULONG                ct_len = AES_BLOCK_SIZE;
        CK_ULONG                key_size = AES_KEY_SIZE_128;

        CK_OBJECT_CLASS         class = CKO_SECRET_KEY;
        CK_KEY_TYPE             key_type = CKK_AES;
        CK_UTF8CHAR             label[] = "AES secret key object";
        CK_BBOOL                true = TRUE;

        CK_ATTRIBUTE            template[] = {
                {CKA_CLASS,     &class,         sizeof(class)},
                {CKA_KEY_TYPE,  &key_type,      sizeof(key_type)},
                {CKA_TOKEN,     &true,          sizeof(true)},
                {CKA_LABEL,     label,          sizeof(label)-1},
                {CKA_ENCRYPT,   &true,          sizeof(true)},
                {CKA_VALUE,     key,		sizeof(key)},
                {CKA_VALUE_LEN, &key_size,      sizeof(key_size)}
        };

        CK_OBJECT_HANDLE        h_key;
        CK_MECHANISM            mech;


        memset( key, 0, sizeof(key) );
        memset( pt, 0, sizeof(pt) );
        memset( ct, 0, sizeof(ct) );
	memset( old_ct, 0, sizeof(ct) );
        memset( final_pt, 0, sizeof(final_pt) );
	memset( iv, 0, sizeof(iv) );
	memset( cv, 0, sizeof(cv) );

        if( (rc = funcs->C_CreateObject(sess, template, 7, &h_key)) != CKR_OK) {
                OC_ERR_MSG("C_CreateObject #1", rc);
                goto done;
        }


        mech.mechanism = CKM_AES_CBC;
        mech.ulParameterLen = sizeof(iv);
        mech.pParameter = iv;
	
        for( i=0; i<400; i++) {
                if(i==399)
                        memcpy(final_pt, pt, sizeof(final_pt));
		// Record i, key, cv, pt
                for( j=0; j<10000; j++) {
			for(k=0; k<sizeof(cv); k++) 
				pt[k] ^= cv[k];
			
			memcpy(old_ct, ct, sizeof(old_ct));
			
                        rc = funcs->C_EncryptInit(sess, &mech, h_key);
                        if (rc != CKR_OK) {
                                OC_ERR_MSG("   C_EncryptInit #1", rc);
                                goto done;
                        }

                        rc = funcs->C_Encrypt(sess, pt, pt_len, ct, &ct_len);
                        if (rc != CKR_OK) {
                                OC_ERR_MSG("   C_Encrypt #1", rc);
                                goto done;
                        }

			memcpy(pt, old_ct, sizeof(pt));
			memcpy(cv, ct, sizeof(ct));
			
			/* After the final encrypt, we need to keep the
                         * plain text pure */
                        if(i == 399 && j == 9999)
                                goto print_done;
                }
		// Record ct
                for( k=0; k<sizeof(ct); k++)
                        key[k] ^= ct[k];

                if( (rc = funcs->C_DestroyObject(sess, h_key)) != CKR_OK) {
                        OC_ERR_MSG("C_DestroyObject", rc);
                        goto done;
                }

                if( (rc = funcs->C_CreateObject(sess, template, 7, &h_key)) != CKR_OK) {
                        OC_ERR_MSG("C_CreateObject #2", rc);
                        goto done;
                }

                /* One status tick */
                if(!(i%5)) {
                        printf(".");
                        fflush(stdout);
                }
        }
print_done:
        printf("\n");

        for( i=0; i<sizeof(key); i++) {
                if(key[i] != KAT_128_CBC_KEY[i]) {
                        printf("%s:%d Error: key data does not match known "
                                "key data at byte %d.\n", __FILE__, __LINE__, i);
                        rc = -1;
                        goto done;
                }
        }

        for( i=0; i<sizeof(final_pt); i++) {
                if(final_pt[i] != KAT_128_CBC_PT[i]) {
                        printf("%s:%d Error: Plain text does not match known "
                                "plain text at byte %d.\n", __FILE__, __LINE__, i);
                        rc = -1;
                        goto done;
                }
        }
        for( i=0; i<AES_BLOCK_SIZE; i++) {
                if(ct[i] != KAT_128_CBC_CT[i]) {
                        printf("%s:%d Error: Cipher text does not match known "
                                "cipher text at byte %d.\n", __FILE__, __LINE__, i);
                        rc = -1;
                        goto done;
                }
        }
done:
        return rc;

}


int do_AES_KAT_192_CBC(void)
{
        int                     i, j, k;
        CK_RV                   rc;
        CK_BYTE                 pt[AES_BLOCK_SIZE],
				old_ct[AES_BLOCK_SIZE],
                                ct[24], // larger to acct for trailing ciphertext
                                final_pt[AES_BLOCK_SIZE],
				cv[AES_BLOCK_SIZE],
				iv[AES_BLOCK_SIZE];
        CK_BYTE                 key[AES_KEY_SIZE_192];
        CK_ULONG                pt_len = AES_BLOCK_SIZE;
        CK_ULONG                ct_len = AES_BLOCK_SIZE;
        CK_ULONG                key_size = AES_KEY_SIZE_192;

        CK_OBJECT_CLASS         class = CKO_SECRET_KEY;
        CK_KEY_TYPE             key_type = CKK_AES;
        CK_UTF8CHAR             label[] = "AES secret key object";
        CK_BBOOL                true = TRUE;

        CK_ATTRIBUTE            template[] = {
                {CKA_CLASS,     &class,         sizeof(class)},
                {CKA_KEY_TYPE,  &key_type,      sizeof(key_type)},
                {CKA_TOKEN,     &true,          sizeof(true)},
                {CKA_LABEL,     label,          sizeof(label)-1},
                {CKA_ENCRYPT,   &true,          sizeof(true)},
                {CKA_VALUE,     key,            sizeof(key)},
                {CKA_VALUE_LEN, &key_size,      sizeof(key_size)}
        };

        CK_OBJECT_HANDLE        h_key;
        CK_MECHANISM            mech;


        memset( key, 0, sizeof(key) );
        memset( pt, 0, sizeof(pt) );
        memset( ct, 0, sizeof(ct) );
        memset( cv, 0, sizeof(cv) );
        memset( final_pt, 0, sizeof(final_pt) );
	memset( iv, 0, sizeof(iv) );

        if( (rc = funcs->C_CreateObject(sess, template, 7, &h_key)) != CKR_OK) {
                OC_ERR_MSG("C_CreateObject #1", rc);
                goto done;
        }

        mech.mechanism = CKM_AES_CBC;
        mech.ulParameterLen = sizeof(iv);
        mech.pParameter = iv;

        for( i=0; i<400; i++) {
                if(i==399)
                        memcpy(final_pt, pt, sizeof(final_pt));

                for( j=0; j<10000; j++) {
			for( k=0; k<sizeof(pt); k++)
				pt[k] ^= cv[k];
			
                        memcpy(old_ct, ct+8, sizeof(old_ct));

                        rc = funcs->C_EncryptInit(sess, &mech, h_key);
                        if (rc != CKR_OK) {
                                OC_ERR_MSG("   C_EncryptInit #1", rc);
                                goto done;
                        }

                        rc = funcs->C_Encrypt(sess, pt, pt_len, ct+8, &ct_len);
                        if (rc != CKR_OK) {
                                OC_ERR_MSG("   C_Encrypt #1", rc);
                                goto done;
                        }

			memcpy(ct, old_ct+8, 8);
			memcpy(pt, old_ct, sizeof(pt));
			memcpy(cv, ct+8, sizeof(cv));

                        if(i == 399 && j == 9999)
                                goto print_done;
                }
                for( k=0; k<sizeof(ct); k++)
                        key[k] ^= ct[k];

                if( (rc = funcs->C_DestroyObject(sess, h_key)) != CKR_OK) {
                        OC_ERR_MSG("C_DestroyObject", rc);
                        goto done;
                }

                if( (rc = funcs->C_CreateObject(sess, template, 7, &h_key)) != CKR_OK) {
                        OC_ERR_MSG("C_CreateObject #2", rc);
                        goto done;
                }

                /* One status tick */
                if(!(i%5)) {
                        printf(".");
                        fflush(stdout);
                }
        }
print_done:
        printf("\n");

        for( i=0; i<sizeof(key); i++) {
                if(key[i] != KAT_192_CBC_KEY[i]) {
                        printf("%s:%d Error: key data does not match known "
                                "key data at byte %d.\n", __FILE__, __LINE__, i);
                        rc = -1;
                        goto done;
                }
        }

        for( i=0; i<sizeof(final_pt); i++) {
                if(final_pt[i] != KAT_192_CBC_PT[i]) {
                        printf("%s:%d Error: Plain text does not match known "
                                "plain text at byte %d.\n", __FILE__, __LINE__, i);
                        rc = -1;
                        goto done;
                }
        }
        for( i=0; i<AES_BLOCK_SIZE; i++) {
                if(ct[i+8] != KAT_192_CBC_CT[i]) {
                        printf("%s:%d Error: Cipher text does not match known "
                                "cipher text at byte %d.\n", __FILE__, __LINE__, i);
                        rc = -1;
                        goto done;
                }
        }
done: