rijndael-test-fst.c

AES最新加密解密算法

	BYTE inBlock[256/8], outBlock[256/8], binKey[256/8], cv[256/8];
	BYTE keyMaterial[320];
	keyInstance keyInst;
	cipherInstance cipherInst;

#ifdef TRACE_KAT_MCT
	int width = 0;
	clock_t elapsed = -clock();
	printf("Executing CBC MCT (%s, key %d): ",
		direction == DIR_ENCRYPT ? "ENCRYPT" : "DECRYPT", keyLength);
	fflush (stdout);
#endif /* ?TRACE_KAT_MCT */
	fprintf (fp,
		"\n"
		"==========\n"
		"\n"
		"KEYSIZE=%d\n", keyLength);
	fflush(fp);
	memset(cv, 0, 16);
	memset(inBlock, 0, 16);
	memset(binKey, 0, keyLength/8);
	for (i = 0; i < 400; i++) {
#ifdef TRACE_KAT_MCT                 
        while (width-- > 0) {
        	putchar('\b');
        }
        width = printf("%d", i);
        fflush(stdout);    
#endif /* ?TRACE_KAT_MCT */
		fprintf (fp, "\nI=%d\n", i);
		/* prepare key: */
		for (j = 0; j < keyLength/8; j++) {
			sprintf (&keyMaterial[2*j], "%02X", binKey[j]);
		}
		keyMaterial[keyLength/4] = 0;
		fprintf(fp, "KEY=%s\n", keyMaterial);
		r = makeKey(&keyInst, direction, keyLength, keyMaterial);
		if (TRUE != r) {
			fprintf(stderr,"makeKey error %d\n",r);
			exit(-1);
		}
		r = cipherInit(&cipherInst, MODE_ECB, NULL);
		if (TRUE != r) {
			fprintf(stderr,"cipherInit error %d\n",r);
			exit(-1);
		}
		/* do encryption/decryption: */
		blockPrint(fp, cv, "IV");
		blockPrint(fp, inBlock, direction == DIR_ENCRYPT ? "PT" : "CT");
		if (direction == DIR_ENCRYPT) {
			for (j = 0; j < 10000; j++) {
				for (t = 0; t < 16; t++) {
					inBlock[t] ^= cv[t];
				}
				r = blockEncrypt(&cipherInst, &keyInst, inBlock, 128, outBlock);
				if (128 != r) {
					fprintf(stderr,"blockEncrypt error %d\n",r);
					exit(-1);
				}
				memcpy(inBlock, cv, 16);
				memcpy(cv, outBlock, 16);
			}
		} else {
			for (j = 0; j < 10000; j++) {
				blockDecrypt(&cipherInst, &keyInst, inBlock, 128, outBlock);
				for (t = 0; t < 16; t++) {
					outBlock[t] ^= cv[t];
				}
				memcpy(cv, inBlock, 16);
				memcpy(inBlock, outBlock, 16);
			}
		}
		blockPrint(fp, outBlock, direction == DIR_ENCRYPT ? "CT" : "PT");
		/* prepare new key: */
		switch (keyLength) {
		case 128:
			for (j = 0; j < 128/8; j++) {
				binKey[j] ^= outBlock[j];
			}
			break;
		case 192:
			for (j = 0; j < 64/8; j++) {
				if (direction == DIR_ENCRYPT) {
					binKey[j] ^= inBlock[j + 64/8];
				} else {
					binKey[j] ^= cv[j + 64/8];
				}
			}
			for (j = 0; j < 128/8; j++) {
				binKey[j + 64/8] ^= outBlock[j];
			}
			break;
		case 256:
			for (j = 0; j < 128/8; j++) {
				if (direction == DIR_ENCRYPT) {
					binKey[j] ^= inBlock[j];
				} else {
					binKey[j] ^= cv[j];
				}
			}
			for (j = 0; j < 128/8; j++) {
				binKey[j + 128/8] ^= outBlock[j];
			}
			break;
		}
	}
#ifdef TRACE_KAT_MCT
	elapsed += clock();
    while (width-- > 0) {
    	putchar('\b');
    }
	printf("%d done (%.1f s).\n", i, (float)elapsed/CLOCKS_PER_SEC);
#endif /* ?TRACE_KAT_MCT */
} /* rijndaelCBC_MCT */


static void makeMCTs(const char *ecbEncryptionFile, const char *ecbDecryptionFile,
		const char *cbcEncryptionFile, const char *cbcDecryptionFile) {
	FILE *fp;

	/* prepare ECB Encryption Monte Carlo Tests: */
	fp = fopen(ecbEncryptionFile, "w");
	fprintf(fp,
		"\n"
		"=========================\n"
		"\n"
		"FILENAME:  \"%s\"\n"
		"\n"
		"Electronic Codebook (ECB) Mode - ENCRYPTION\n"
		"Monte Carlo Test\n"
		"\n"
		"Algorithm Name: Rijndael\n"
		"Principal Submitter: %s\n",
		ecbEncryptionFile, SUBMITTER);
	fflush(fp);

	rijndaelECB_MCT(fp, 128, DIR_ENCRYPT);
	rijndaelECB_MCT(fp, 192, DIR_ENCRYPT);
	rijndaelECB_MCT(fp, 256, DIR_ENCRYPT);

	fprintf(fp,
		"\n"
		"===========");
	fclose(fp);

	/* prepare ECB Decryption Monte Carlo Tests: */
	fp = fopen(ecbDecryptionFile, "w");
	fprintf(fp,
		"\n"
		"=========================\n"
		"\n"
		"FILENAME:  \"%s\"\n"
		"\n"
		"Electronic Codebook (ECB) Mode - DECRYPTION\n"
		"Monte Carlo Test\n"
		"\n"
		"Algorithm Name: Rijndael\n"
		"Principal Submitter: %s\n",
		ecbDecryptionFile, SUBMITTER);
	fflush(fp);

	rijndaelECB_MCT(fp, 128, DIR_DECRYPT);
	rijndaelECB_MCT(fp, 192, DIR_DECRYPT);
	rijndaelECB_MCT(fp, 256, DIR_DECRYPT);

	fprintf(fp,
		"\n"
		"===========");
	fclose(fp);

	/* prepare CBC Encryption Monte Carlo Tests: */
	fp = fopen (cbcEncryptionFile, "w");
	fprintf(fp,
		"\n"
		"=========================\n"
		"\n"
		"FILENAME:  \"%s\"\n"
		"\n"
		"Cipher Block Chaining (CBC) Mode - ENCRYPTION\n"
		"Monte Carlo Test\n"
		"\n"
		"Algorithm Name: Rijndael\n"
		"Principal Submitter: %s\n",
		cbcEncryptionFile, SUBMITTER);
	fflush(fp);

	rijndaelCBC_MCT(fp, 128, DIR_ENCRYPT);
	rijndaelCBC_MCT(fp, 192, DIR_ENCRYPT);
	rijndaelCBC_MCT(fp, 256, DIR_ENCRYPT);

	fprintf(fp,
		"\n"
		"===========");
	fclose(fp);

	/* prepare CBC Decryption Monte Carlo Tests: */
	fp = fopen(cbcDecryptionFile, "w");
	fprintf(fp,
		"\n"
		"=========================\n"
		"\n"
		"FILENAME:  \"%s\"\n"
		"\n"
		"Cipher Block Chaining (CBC) Mode - DECRYPTION\n"
		"Monte Carlo Test\n"
		"\n"
		"Algorithm Name: Rijndael\n"
		"Principal Submitter: %s\n",
		cbcDecryptionFile, SUBMITTER);
	fflush(fp);

	rijndaelCBC_MCT(fp, 128, DIR_DECRYPT);
	rijndaelCBC_MCT(fp, 192, DIR_DECRYPT);
	rijndaelCBC_MCT(fp, 256, DIR_DECRYPT);

	fprintf(fp,
		"\n"
		"===========");
	fclose(fp);
} /* makeMCTs */

static void makeFIPSTestVectors(const char *fipsFile) {
	int i, keyLength, r;
	keyInstance keyInst;
	cipherInstance cipherInst;
	BYTE keyMaterial[320];
	u8 pt[16], ct[16];
	char format[64];
	FILE *fp;

#ifdef TRACE_KAT_MCT
	printf("Generating FIPS test vectors...");
#endif /* ?TRACE_KAT_MCT */
	
	fp = fopen(fipsFile, "w");
	fprintf(fp,
		"\n"
		"================================\n\n"
		"FILENAME:  \"%s\"\n\n"
		"FIPS Test Vectors\n",
		fipsFile);

	/* 128-bit key: 00010103...0e0f: */
	keyLength = 128;
	memset(keyMaterial, 0, sizeof (keyMaterial));
	for (i = 0; i < keyLength/8; i++) {
		sprintf(&keyMaterial[2*i], "%02X", i);
	}
	
	fprintf(fp, "\n================================\n\n");
	fprintf(fp, "KEYSIZE=128\n\n");
    fprintf(fp, "KEY=%s\n\n", keyMaterial);

	/* plaintext is always 00112233...eeff: */
	for (i = 0; i < 16; i++) {
		pt[i] = (i << 4) | i;
	}

    /* encryption: */	
	makeKey(&keyInst, DIR_ENCRYPT, keyLength, keyMaterial);
	cipherInit(&cipherInst, MODE_ECB, NULL);
	fprintf(fp, "Round Subkey Values (Encryption)\n\n");
    for (r = 0; r <= keyInst.Nr; r++) {
        fprintf(fp, "RK%d=", r);
        for (i = 0; i < 4; i++) {
            u32 w = keyInst.rk[4*r + i];
            fprintf(fp, "%02X%02X%02X%02X", w >> 24, (w >> 16) & 0xff, (w >> 8) & 0xff, w & 0xff);
        }
        fprintf(fp, "\n");
    }
	fprintf(fp, "\nIntermediate Ciphertext Values (Encryption)\n\n");
	blockPrint(fp, pt, "PT");
	for (i = 1; i < keyInst.Nr; i++) {
		cipherUpdateRounds(&cipherInst, &keyInst, pt, 16, ct, i);
		sprintf(format, "CT%d", i);
		blockPrint(fp, ct, format);
	}
	cipherUpdateRounds(&cipherInst, &keyInst, pt, 16, ct, keyInst.Nr);
	blockPrint(fp, ct, "CT");
	
    /* decryption: */	
	makeKey(&keyInst, DIR_DECRYPT, keyLength, keyMaterial);
	cipherInit(&cipherInst, MODE_ECB, NULL);
	fprintf(fp, "\nRound Subkey Values (Decryption)\n\n");
    for (r = 0; r <= keyInst.Nr; r++) {
        fprintf(fp, "RK%d=", r);
        for (i = 0; i < 4; i++) {
            u32 w = keyInst.rk[4*r + i];
            fprintf(fp, "%02X%02X%02X%02X", w >> 24, (w >> 16) & 0xff, (w >> 8) & 0xff, w & 0xff);
        }
        fprintf(fp, "\n");
    }
	fprintf(fp, "\nIntermediate Ciphertext Values (Decryption)\n\n");
	blockPrint(fp, ct, "CT");
	for (i = 1; i < keyInst.Nr; i++) {
		cipherUpdateRounds(&cipherInst, &keyInst, ct, 16, pt, i);
		sprintf(format, "PT%d", i);
		blockPrint(fp, pt, format);
	}
	cipherUpdateRounds(&cipherInst, &keyInst, ct, 16, pt, keyInst.Nr);
	blockPrint(fp, pt, "PT");

	/* 192-bit key: 00010103...1617: */
	keyLength = 192;
	memset(keyMaterial, 0, sizeof (keyMaterial));
	for (i = 0; i < keyLength/8; i++) {
		sprintf(&keyMaterial[2*i], "%02X", i);
	}
	
	fprintf(fp, "\n================================\n\n");
	fprintf(fp, "KEYSIZE=192\n\n");
    fprintf(fp, "KEY=%s\n\n", keyMaterial);

	/* plaintext is always 00112233...eeff: */
	for (i = 0; i < 16; i++) {
		pt[i] = (i << 4) | i;
	}

    /* encryption: */	
	makeKey(&keyInst, DIR_ENCRYPT, keyLength, keyMaterial);
	cipherInit(&cipherInst, MODE_ECB, NULL);
	fprintf(fp, "\nRound Subkey Values (Encryption)\n\n");
    for (r = 0; r <= keyInst.Nr; r++) {
        fprintf(fp, "RK%d=", r);
        for (i = 0; i < 4; i++) {
            u32 w = keyInst.rk[4*r + i];
            fprintf(fp, "%02X%02X%02X%02X", w >> 24, (w >> 16) & 0xff, (w >> 8) & 0xff, w & 0xff);
        }
        fprintf(fp, "\n");
    }
	fprintf(fp, "\nIntermediate Ciphertext Values (Encryption)\n\n");
	blockPrint(fp, pt, "PT");
	for (i = 1; i < keyInst.Nr; i++) {
		cipherUpdateRounds(&cipherInst, &keyInst, pt, 16, ct, i);
		sprintf(format, "CT%d", i);
		blockPrint(fp, ct, format);
	}
	cipherUpdateRounds(&cipherInst, &keyInst, pt, 16, ct, keyInst.Nr);
	blockPrint(fp, ct, "CT");
	
    /* decryption: */	
	makeKey(&keyInst, DIR_DECRYPT, keyLength, keyMaterial);
	cipherInit(&cipherInst, MODE_ECB, NULL);
	fprintf(fp, "\nRound Subkey Values (Decryption)\n\n");
    for (r = 0; r <= keyInst.Nr; r++) {
        fprintf(fp, "RK%d=", r);
        for (i = 0; i < 4; i++) {
            u32 w = keyInst.rk[4*r + i];
            fprintf(fp, "%02X%02X%02X%02X", w >> 24, (w >> 16) & 0xff, (w >> 8) & 0xff, w & 0xff);
        }
        fprintf(fp, "\n");
    }
	fprintf(fp, "\nIntermediate Ciphertext Values (Decryption)\n\n");
	blockPrint(fp, ct, "CT");
	for(i = 1; i < keyInst.Nr; i++) {
		cipherUpdateRounds(&cipherInst, &keyInst, ct, 16, pt, i);
		sprintf(format, "PT%d", i);
		blockPrint(fp, pt, format);
	}
	cipherUpdateRounds(&cipherInst, &keyInst, ct, 16, pt, keyInst.Nr);
	blockPrint(fp, pt, "PT");

	/* 256-bit key: 00010103...1e1f: */
	keyLength = 256;
	memset(keyMaterial, 0, sizeof (keyMaterial));
	for (i = 0; i < keyLength/8; i++) {
		sprintf(&keyMaterial[2*i], "%02X", i);
	}
	
	fprintf(fp, "\n================================\n\n");
	fprintf(fp, "KEYSIZE=256\n\n");
    fprintf(fp, "KEY=%s\n\n", keyMaterial);

	/* plaintext is always 00112233...eeff: */
	for (i = 0; i < 16; i++) {
		pt[i] = (i << 4) | i;
	}

    /* encryption: */	
	makeKey(&keyInst, DIR_ENCRYPT, keyLength, keyMaterial);
	cipherInit(&cipherInst, MODE_ECB, NULL);
	fprintf(fp, "\nRound Subkey Values (Encryption)\n\n");
    for (r = 0; r <= keyInst.Nr; r++) {
        fprintf(fp, "RK%d=", r);
        for (i = 0; i < 4; i++) {
            u32 w = keyInst.rk[4*r + i];
            fprintf(fp, "%02X%02X%02X%02X", w >> 24, (w >> 16) & 0xff, (w >> 8) & 0xff, w & 0xff);
        }
        fprintf(fp, "\n");
    }
	fprintf(fp, "\nIntermediate Ciphertext Values (Encryption)\n\n");
	blockPrint(fp, pt, "PT");
	for(i = 1; i < keyInst.Nr; i++) {
		cipherUpdateRounds(&cipherInst, &keyInst, pt, 16, ct, i);
		sprintf(format, "CT%d", i);
		blockPrint(fp, ct, format);
	}
	cipherUpdateRounds(&cipherInst, &keyInst, pt, 16, ct, keyInst.Nr);
	blockPrint(fp, ct, "CT");
	
    /* decryption: */	
	makeKey(&keyInst, DIR_DECRYPT, keyLength, keyMaterial);
	cipherInit(&cipherInst, MODE_ECB, NULL);
	fprintf(fp, "\nRound Subkey Values (Decryption)\n\n");
    for (r = 0; r <= keyInst.Nr; r++) {
        fprintf(fp, "RK%d=", r);
        for (i = 0; i < 4; i++) {
            u32 w = keyInst.rk[4*r + i];
            fprintf(fp, "%02X%02X%02X%02X", w >> 24, (w >> 16) & 0xff, (w >> 8) & 0xff, w & 0xff);
        }
        fprintf(fp, "\n");
    }
	fprintf(fp, "\nIntermediate Ciphertext Values (Decryption)\n\n");
	blockPrint(fp, ct, "CT");
	for(i = 1; i < keyInst.Nr; i++) {
		cipherUpdateRounds(&cipherInst, &keyInst, ct, 16, pt, i);
		sprintf(format, "PT%d", i);
		blockPrint(fp, pt, format);
	}
	cipherUpdateRounds(&cipherInst, &keyInst, ct, 16, pt, keyInst.Nr);
	blockPrint(fp, pt, "PT");

    fprintf(fp, "\n");
	fclose(fp);
#ifdef TRACE_KAT_MCT
	printf(" done.\n");
#endif /* ?TRACE_KAT_MCT */
}

#define ITERATIONS 10000000

void rijndaelSpeed(int keyBits) {
	int Nr, i;
	u32 rk[4*(MAXNR + 1)];
	u8 cipherKey[256/8], pt[16], ct[16];
	clock_t elapsed;
	float sec;

	memset(cipherKey, 0, sizeof(cipherKey));
	printf("================================\n");
	printf("Speed measurement for %d-bit keys:\n", keyBits);

	/*
	 * Encryption key setup timing:
	 */
	elapsed = -clock();
	for (i = 0; i < ITERATIONS; i++) {
		Nr = rijndaelKeySetupEnc(rk, cipherKey, keyBits);
	}
	elapsed += clock();
	sec = (float)elapsed/CLOCKS_PER_SEC;
	printf("Encryption key schedule: %.1f s, %.0f Mbit/s\n",
		sec, (float)ITERATIONS*128/sec/1000000);

	/*
	 * Encryption timing:
	 */
	elapsed = -clock();
	for (i = 0; i < ITERATIONS; i++) {
		rijndaelEncrypt(rk, Nr, pt, ct);
	}
	elapsed += clock();
	sec = (float)elapsed/CLOCKS_PER_SEC;
	printf("Encryption: %.1f s, %.0f Mbit/s\n",
		sec, (float)ITERATIONS*128/sec/1000000);

	/*
	 * Decryption key setup timing:
	 */
	elapsed = -clock();
	for (i = 0; i < ITERATIONS; i++) {
		Nr = rijndaelKeySetupDec(rk, cipherKey, keyBits);
	}
	elapsed += clock();
	sec = (float)elapsed/CLOCKS_PER_SEC;
	printf("Decryption key schedule: %.1f s, %.0f Mbit/s\n",
		sec, (float)ITERATIONS*128/sec/1000000);

	/*
	 * Decryption timing:
	 */
	elapsed = -clock();
	for (i = 0; i < ITERATIONS; i++) {
		rijndaelDecrypt(rk, Nr, pt, ct);
	}
	elapsed += clock();
	sec = (float)elapsed/CLOCKS_PER_SEC;
	printf("Decryption: %.1f s, %.0f Mbit/s\n",
		sec, (float)ITERATIONS*128/sec/1000000);

}

int main(void) {
	makeFIPSTestVectors("fips-test-vectors.txt");
	makeKATs("ecb_vk.txt", "ecb_vt.txt", "ecb_tbl.txt", "ecb_iv.txt");
	makeMCTs("ecb_e_m.txt", "ecb_d_m.txt", "cbc_e_m.txt", "cbc_d_m.txt");
	/*
	rijndaelSpeed(128);
	rijndaelSpeed(192);
	rijndaelSpeed(256);
	*/
	return 0;
}