MỤC LỤC MỤC LỤC .i DANH MỤC HÌNH VẼ .xi MỞ ĐẦU Chương CÁC ỨNG DỤNG CỦA MẬT MÃ TRONG AN TỒN THƠNG TIN VÀ VAI TRỊ CỦA CÁC NGƠN NGỮ LẬP TRÌNH .2 1.1 SƠ LƯỢC VỀ MẬT MÃ HỌC .2 1.1.1 Lịch sử mật mã 1.1.2 Các mục tiêu mật mã 1.1.3 Phân loại loại mật mã 1.2 CÁC ỨNG DỤNG CỦA MẬT MÃ 1.2.1 Các ứng dụng thực tiễn 1.2.1.1 Ứng dụng đời sống thông tin, kinh tế, xã hội 1.2.1.2 Ứng dụng an ninh, quốc phòng 1.2.2 Ứng dụng số thành phần mật mã 1.2.2.1 Dãy ngẫu nhiên, dãy giả ngẫu nhiên 1.2.2.2 Hàm băm 11 1.2.2.3 Mã dòng 13 1.2.2.4 Mã khối .15 1.2.2.5 Hệ mật khóa công khai 17 1.2.2.6 Chữ ký số 18 1.2.3 Ứng dụng giao thức bảo mật 1.2.3.1 Xác thực đăng nhập Linux 19 1.2.3.2 Secure Shell (SSH) 20 1.2.3.3 SSL/TLS 23 1.2.3.4 Giao thức SET (Secure Electronic Transaction) .27 1.2.3.5 S/MIME (Secure/Multipurpose Internet Mail Extensions) 31 1.2.3.6 PGP, OpenPGP, GnuPG 32 i 1.3 MỘT SỐ FRAMEWORK HỖ TRỢ LẬP TRÌNH ỨNG DỤNG MẬT MÃ 36 1.3.1Thư viện lập trình số lớn GMP 1.3.2Crypto++ 1.3.3Microsoft CryptoAPI 1.3.4JCA, JCE 1.4 MỘT SỐ PHẦN MỀM HỖ TRỢ NGHIÊN CỨU MẬT MÃ .42 1.4.1 Maple 1.4.2 Mathematica 1.5 CÂU HỎI ÔN TẬP .46 Chương MẬT MÃ DÒNG 48 2.1 KHÁI NIỆM MÃ DÒNG .48 2.2 CÁC ĐẶC TRƯNG .50 2.2.1 Độ phức tạp tuyến tính 2.2.1.1 Thanh ghi dịch phản hồi 50 2.2.1.2 Dãy ghi dịch .51 2.2.1.3 Định nghĩa độ phức tạp tuyến tính: 52 2.2.1.4 Thuật tốn Berlekamp-Massey 54 2.2.1.5 Phân bố độ phức tạp tuyến tính dãy ngẫu nhiên 58 2.2.2 Chu kỳ 2.2.3 Tự tương quan 2.2.4 Lực lượng loại dãy 2.2.5 Các tính chất thống kê 2.2.5.1 Kiểm tra tần số đơn (kiểm tra bit đơn) .62 2.2.5.2 Kiểm tra seri (kiểm tra phân bố cặp bit) 63 2.2.5.3 Kiểm tra Poker (kiểm tra phân bố đoạn bít) .63 2.2.5.4 Kiểm tra loạt .64 2.2.5.4 Kiểm tra tự tương quan 64 2.3 CÁC NGUYÊN LÝ THIẾT KẾ MẬT MÃ DÒNG .66 2.3.1 Thiết kế mật mã dòng dựa LFSR 2.3.1.1 Các sinh tổ hợp phi tuyến 67 ii 2.3.1.2 Các lọc phi tuyến 68 2.3.1.3 Các sinh điều khiển đồng hồ .69 2.3 Thiết kế mật mã dòng dựa mật mã khối 2.3.2.1 Kiểu phản hồi mật mã 69 2.3.2.2 Kiểu phản hồi đầu 70 2.3.2.3 Kiểu đếm 70 2.3.3 Các mật mã dòng dựa mật mã khóa cơng khai 2.3.4 Các kiểu thiết kế khác 2.4 MỘT SỐ MẬT MÃ DÒNG: ỨNG VỚI DỊNG KHĨA LÀ DÃY BÍT, DỊNG KHĨA LÀ DÃY BYTE 71 2.4.1 Dịng khóa dãy bít 2.4.1.1 Dãy sinh khóa Geffe P.R 71 2.4.1.2 DÃY D'BRUIJN (dãy phi tuyến chu kỳ cực đại) .72 2.4.1.3 Dãy điều khiển đồng hồ 74 2.4.1.4 Mã dịng dựa mật mã khóa cơng khai 76 2.4.1.4 Mã dòng Seal .78 2.4.1 Dịng khóa sinh từ dãy byte 2.5 CHƯƠNG TRÌNH MAPLE THỰC HIỆN MỘT SỐ MẬT MÃ DỊNG: THUẬT TỐN VÀ ĐỘ AN TỒN 87 2.5.1 Dãy sinh khóa Geffe P.R 2.5.2 DÃY D'BRUIJN (dãy phi tuyến chu kỳ cực đại) 2.5.3 Dãy Shrinking 2.6 CÂU HỎI ÔN TẬP VÀ BÀI TẬP 92 Chương MẬT MÃ KHỐI .94 3.1 ĐỊNH NGHĨA MÃ KHỐI .94 3.2 CÁC LOẠI CẤU TRÚC PHỔ BIẾN CỦA MÃ KHỐI 95 3.2.1 Các thuật tốn lược đồ khóa 3.2.2 Các mạng thay thế- hoán vị (SPN) 3.2.3 Mạng Feistel 3.2.4 Các cấu trúc mã khối khác iii 3.3 XÁC SUẤT TUYẾN TÍNH VÀ SƠ LƯỢC VỀ TẤN CƠNG TUYẾN TÍNH LÊN MÃ KHỐI 101 3.3.1 Xác suất tuyến tính 3.3.2 Sơ lược cơng tuyến tính lên mã khối 3.4 XÁC SUẤT LƯỢNG SAI VÀ SƠ LƯỢC VỀ TẤN CÔNG LƯỢNG SAI LÊN MÃ KHỐI 106 3.4.1 Xác suất lượng sai 3.4.2 Sơ lược công lượng sai lên mã khối 3.5 NGUYÊN LÝ THIẾT KẾ MÃ KHỐI 111 3.6 GIỚI THIỆU MỘT SỐ MÃ KHỐI: CẤU TRÚC, THUẬT TỐN VÀ ĐỘ AN TỒN 112 3.6.1 Chuẩn mã hóa liệu DES 3.6.1.1 Thuật toán mã hoá 113 3.6.1.2 Lược đồ tạo hệ thống khoá : 117 3.6.1.3 Giải mã DES 118 3.6.1.4 Độ an toàn DES 119 3.6.2 Mã khối Camellia 3.6.2.1 Cấu trúc Camellia .123 3.6.2.2 Các thành phần Camellia 137 3.6.2.3 Độ an toàn Camellia 145 3.6.2.4 Dữ liệu thử nghiệm Camellia 146 3.7 THUẬT TỐN VÀ CHƯƠNG TRÌNH TÍNH XÁC SUẤT LƯỢNG SAI VÀ TUYẾN TÍNH CỰC ĐẠI 147 3.7.1 Thuật tốn tính xác suất lượng sai tuyến tính cực đại 3.7.2 Chương trình tính xác suất lượng sai tuyến tính cực đại Maple 3.7.2.1 Chương trình tìm xác xuất lượng sai, tuyến tính cực đại với hộp Sbox AES 149 3.7.2.2 Chương trình tìm xác xuất lượng sai, tuyến tính cực đại với hộp Sbox1 Camelia 151 iv 3.8 CÂU HỎI ÔN TẬP .154 Chương MẬT MÃ TRÊN ĐƯỜNG CONG ELLIPTIC 155 4.1 ĐỊNH NGHĨA 155 4.1.1 Định nghĩa đường cong elliptic 4.1.2 Luật nhóm 4.1.3 Tính kP 4.1.4 Dạng không kỳ dị 4.1.6 Đường cong elliptic trường có đăc số 4.2 NHÚNG MỘT SỐ VÀO ĐƯỜNG CONG ELLIPTIC 165 4.2.1 Chuyển thông báo thành số nguyên thuộc Fp 4.2.2 Nhúng rõ 4.3 ĐẾM ĐƠN GIẢN SỐ ĐIỂM TRÊN ĐƯỜNG CONG ELLIPTIC 168 4.4 TÍNH BẬC CỦA MỘT ĐIỂM 168 4.5 MỘT SỐ HỆ MẬT, HỆ CHỮ KÝ SỐ TRÊN ĐƯỜNG CONG ELLIPTIC 171 4.5.1 Bài tốn lơ ga rít rời rạc (DLP) đường cong elliptic 4.5.2 Các hệ mật đường cong Elliptic: 4.5.2.1 Hệ mật Elgamal Elliptic: 172 4.5.2.2 Lập mã Massey-Omura: 173 4.5.2.3 Hệ mật đường cong elliptic Menezes- Vanstone : 173 4.5.3 Các hệ chữ ký đường cong Elliptic: 4.5.3.1 Sơ đồ chữ ký số Elgamal Elliptic: 174 4.5.3.2 Chuẩn chữ ký số Elliptic (ECDSA): 175 4.5.4 Giao thức trao đổi khóa 4.6 CHỌN ĐƯỜNG CONG TỐT 177 4.6.1 Những yêu cầu kỹ thuật 4.6.2 Những yêu cầu an toàn 4.7 MỘT SỐ CHƯƠNG TRÌNH MAPLE VỀ ĐƯỜNG CONG ELLIPTIC .179 v 4.7.1 Chương trình tính kP 4.7.2 Liệt kê điểm đường cong 4.7.3 Hệ mật đường cong elliptic 4.7.4 Hệ chữ ký đường cong elliptic 4.7.4.1 Sơ đồ chữ ký số Elgamal Elliptic: 183 4.7.4.2 Sơ đồ chữ ký số ECDSA: .184 4.8 CÂU HỎI ÔN TẬP 186 Chương GIAO THỨC MẬT MÃ .187 5.1 ĐỊNH NGHĨA 187 5.2 CÁC YÊU CẦU TRONG GIAO THỨC XÁC THỰC 189 5.2.1 Tính tươi thơng báo tính sống thực thể : 5.2.1.1 Tính tươi thơng báo 189 5.2.1.2 Tính sống thực thể 190 5.2.2 Xác thực nguồn gốc liệu 5.2.3 Xác thực thực thể 5.2.4 Thiết lập khố có xác thực 5.3 MỘT SỐ GIAO THỨC: THUẬT TOÁN VÀ ĐỘ AN TOÀN 193 5.3.1 Quy ước chung 5.3.2 Những kỹ thuật xác thực 5.3.2.1 Những chế thách đố-giải đố .195 5.3.2.2 Các chế tem thời gian 196 5.3.2.3 Những chế phi chuẩn 198 5.3.2.4 Xác thực lẫn 199 5.3.2.5 Xác thực liên quan đến bên thứ ba tin cậy .200 5.3.2.6 Xác thực dựa mật 201 5.3.2.7 Thêm thành phần phụ gia vào giao thức 204 5.3.2.8 Trao đổi khố có xác thực dựa mật mã phi đối xứng .206 5.3.3 Độ an toàn 5.3.3.1 Tấn công diễn lại thông báo 209 5.3.3.2 Tấn công kẻ đứng 211 vi 5.3.3.3 Tấn công phiên song song .212 5.3.3.4 Tấn công phản xạ 213 5.3.3.5 Tấn công xen kẽ 214 5.3.3.6 Tấn công khiếm khuyết kiểu 215 5.3.3.7 Tấn cơng bỏ sót tên 215 5.3.3.8Tấn công dùng sai dịch vụ mật mã .216 5.3.3.9 Tóm tắt thực hành 219 5.3 MỘT SỐ CHƯƠNG TRÌNH MAPLE 219 5.4.1 Cơ chế thách đố-giải đố chuẩn hóa 5.4.2 Cơ chế tem thời gian chuẩn hóa 5.5 CÂU HỎI ƠN TẬP 223 Chương MỘT SỐ CHUẨN MẬT MÃ .226 6.1 CHUẨN MÃ DÒNG 226 6.1.1.Tóm tắt thuật toán gốc SNOW 1.0 6.1.2 Những điểm yếu SNOW 1.0 6.1.3 Thuật toán SNOW 2.0 6.1.4 Việc thực SNOW 2.0 6.2 CHUẨN MÃ KHỐI: AES 236 6.2.1 Các byte đa thức 6.2.1.1 Các biểu diễn byte 238 6.2.1.2 Phép cộng byte 238 6.2.1.3 Phép nhân byte 238 6.2.1.4 Phép dịch chuyển vòng từ vào 239 6.2.2 Mã hoá Rijndael 6.2.2.1 Lời gọi ByteSub(state) 243 6.2.2.2 Lời gọi ShiftRow(state) 244 6.2.2.3 Lời gọi MixColumn(state) .244 6.2.2.4 Lời gọi AddRoundKey(state, RoundKey) 245 6.2.2.5 Lời gọi KeyExpansion(CipherKey,ExpandedKey) 246 6.2.2.6 Lời gọi Rcon[i] (Round keys and constants) 247 6.2.3 Mode giải mã Rijndael vii 6.3 CHUẨN MẬT MÃ KHĨA CƠNG KHAI VÀ CHỮ KÝ SỐ 249 6.3.1 Chuẩn mật mã khóa công khai: RSA-OAEP 6.3.1.1 Mô tả 249 6.3.2 Chuẩn chữ ký số: RSA-PSS 6.3.2.1 Mô tả 251 6.3.2.2 Lược đồ ký RSA-PSS (A ký thông báo cho B.) 252 6.3.2.3 Độ dài muối (salt) 253 6.4 CHUẨN GIAO THỨC MẬT MÃ .254 6.4.1 Các vấn đề chung 6.4.2 Lược đồ thỏa thuận khóa số 6.4.3 Lược đồ thỏa thuận khóa số 6.4.4 Lược đồ thỏa thuận khóa số 6.4.5 Lược đồ thỏa thuận khóa số 6.4.6 Lược đồ thỏa thuận khóa số 6.4.7 Lược đồ thỏa thuận khóa số 6.4.8 Lược đồ thỏa thuận khóa số 6.4.9 So sánh tính chất lược đồ thỏa thuận khóa 6.5 CÂU HỎI ÔN TẬP .280 TÀI LIỆU THAM KHẢO 281 PHỤ LỤC 285 Phụ lục Chương trình mã hóa/giải mã mã khối AES ngôn ngữ C .285 Phụ lục Chương trình mã hóa/giải mã mã khối Camellia ngơn ngữ C 313 viii ix DANH MỤC BẢNG Bảng 3.1 Tính xác suất tuyến tính 102 Bảng 3.2 Tỷ lệ thành công thám tuyến tính hàm c 105 Bảng 3.3 Tính xác suất lượng sai 107 Bảng 3.4 Hoán vị đầu 113 Bảng 3.5 Hoán vị IP-1 114 Bảng 3.6 Mở rộng E 115 Bảng 3.10 Các số lược đồ khóa 135 Bảng 3.11 Các khóa khóa bí mật 128 bit 136 Bảng 3.12 Các khóa khóa bí mật 192/256 bit 137 Bảng 3.13 Hộp s1 143 Bảng 3.14 Hộp s2 143 Bảng 3.15 Hộp s3 144 Bảng 3.16 Hộp s4 144 x * Order: KL, KR, KA, KB */ memset(KC, 0, sizeof(KC)); /* Store KL, KR */ for (i = 0; i < 8; i++) GET_UINT32_BE(KC[i], t, i * 4); /* Generate KA */ for( i = 0; i < 4; ++i) KC[8 + i] = KC[i] ^ KC[4 + i]; camellia_feistel(KC + 8, SIGMA[0], KC + 10); camellia_feistel(KC + 10, SIGMA[1], KC + 8); for( i = 0; i < 4; ++i) KC[8 + i] ^= KC[i]; camellia_feistel(KC + 8, SIGMA[2], KC + 10); camellia_feistel(KC + 10, SIGMA[3], KC + 8); if (keysize > 128) { /* Generate KB */ for( i = 0; i < 4; ++i) KC[12 + i] = KC[4 + i] ^ KC[8 + i]; camellia_feistel(KC + 12, SIGMA[4], KC + 14); camellia_feistel(KC + 14, SIGMA[5], KC + 12); } /* * Generating subkeys */ /* Manipulating KL */ SHIFT_AND_PLACE(idx, 0); /* Manipulating KR */ if (keysize > 128) { SHIFT_AND_PLACE(idx, 1); } /* Manipulating KA */ SHIFT_AND_PLACE(idx, 2); /* Manipulating KB */ 321 if (keysize > 128) { SHIFT_AND_PLACE(idx, 3); } /* Do transpositions */ for ( i = 0; i < 20; i++ ) { if (transposes[idx][i] != -1) { RK[32 + 12 * idx + i] = RK[transposes[idx][i]]; } } return( ); } /* * Camellia key schedule (decryption) */ int camellia_setkey_dec( camellia_context *ctx, const unsigned char *key, unsigned int keysize ) { int idx; size_t i; camellia_context cty; uint32_t *RK; uint32_t *SK; int ret; switch( keysize ) { case 128: ctx->nr = 3; idx = 0; break; case 192: case 256: ctx->nr = 4; idx = 1; break; default : return( POLARSSL_ERR_CAMELLIA_INVALID_KEY_LENGTH ); } RK = ctx->rk; ret = camellia_setkey_enc(&cty, key, keysize); if( ret != ) return( ret ); SK = cty.rk + 24 * + * idx * 2; *RK++ = *SK++; *RK++ = *SK++; *RK++ = *SK++; 322 *RK++ = *SK++; for (i = 22 + * idx, SK -= 6; i > 0; i , SK -= 4) { *RK++ = *SK++; *RK++ = *SK++; } SK -= 2; *RK++ = *SK++; *RK++ = *SK++; *RK++ = *SK++; *RK++ = *SK++; memset( &cty, 0, sizeof( camellia_context ) ); return( ); } /* * Camellia-ECB block encryption/decryption */ int camellia_crypt_ecb( camellia_context *ctx, int mode, const unsigned char input[16], unsigned char output[16] ) { int NR; uint32_t *RK, X[4]; ( (void) mode ); NR = ctx->nr; RK = ctx->rk; GET_UINT32_BE( X[0], input, ); GET_UINT32_BE( X[1], input, ); GET_UINT32_BE( X[2], input, ); GET_UINT32_BE( X[3], input, 12 ); X[0] ^= *RK++; X[1] ^= *RK++; X[2] ^= *RK++; X[3] ^= *RK++; 323 while (NR) { NR; camellia_feistel(X, RK, X + 2); RK += 2; camellia_feistel(X + 2, RK, X); RK += 2; camellia_feistel(X, RK, X + 2); RK += 2; camellia_feistel(X + 2, RK, X); RK += 2; camellia_feistel(X, RK, X + 2); RK += 2; camellia_feistel(X + 2, RK, X); RK += 2; if (NR) { FL(X[0], X[1], RK[0], RK[1]); RK += 2; FLInv(X[2], X[3], RK[0], RK[1]); RK += 2; } } X[2] ^= *RK++; X[3] ^= *RK++; X[0] ^= *RK++; X[1] ^= *RK++; PUT_UINT32_BE( X[2], output, ); PUT_UINT32_BE( X[3], output, ); PUT_UINT32_BE( X[0], output, ); PUT_UINT32_BE( X[1], output, 12 ); return( ); } /* * Camellia-CBC buffer encryption/decryption */ int camellia_crypt_cbc( camellia_context *ctx, int mode, size_t length, unsigned char iv[16], const unsigned char *input, unsigned char *output ) { 324 int i; unsigned char temp[16]; if( length % 16 ) return( POLARSSL_ERR_CAMELLIA_INVALID_INPUT_LENGTH ); if( mode == CAMELLIA_DECRYPT ) { while( length > ) { memcpy( temp, input, 16 ); camellia_crypt_ecb( ctx, mode, input, output ); for( i = 0; i < 16; i++ ) output[i] = (unsigned char)( output[i] ^ iv[i] ); memcpy( iv, temp, 16 ); input += 16; output += 16; length -= 16; } } else { while( length > ) { for( i = 0; i < 16; i++ ) output[i] = (unsigned char)( input[i] ^ iv[i] ); camellia_crypt_ecb( ctx, mode, output, output ); memcpy( iv, output, 16 ); input += 16; output += 16; length -= 16; } } return( ); } #if defined(POLARSSL_CIPHER_MODE_CFB) /* * Camellia-CFB128 buffer encryption/decryption */ 325 int camellia_crypt_cfb128( camellia_context *ctx, int mode, size_t length, size_t *iv_off, unsigned char iv[16], const unsigned char *input, unsigned char *output ) { int c; size_t n = *iv_off; if( mode == CAMELLIA_DECRYPT ) { while( length ) { if( n == ) camellia_crypt_ecb( ctx, CAMELLIA_ENCRYPT, iv, iv ); c = *input++; *output++ = (unsigned char)( c ^ iv[n] ); iv[n] = (unsigned char) c; n = (n + 1) & 0x0F; } } else { while( length ) { if( n == ) camellia_crypt_ecb( ctx, CAMELLIA_ENCRYPT, iv, iv ); iv[n] = *output++ = (unsigned char)( iv[n] ^ *input++ ); n = (n + 1) & 0x0F; } } *iv_off = n; return( ); } #endif /* POLARSSL_CIPHER_MODE_CFB */ #if defined(POLARSSL_CIPHER_MODE_CTR) /* 326 * Camellia-CTR buffer encryption/decryption */ int camellia_crypt_ctr( camellia_context *ctx, size_t length, size_t *nc_off, unsigned char nonce_counter[16], unsigned char stream_block[16], const unsigned char *input, unsigned char *output ) { int c, i; size_t n = *nc_off; while( length ) { if( n == ) { camellia_crypt_ecb( ctx, CAMELLIA_ENCRYPT, nonce_counter, stream_block ); for( i = 16; i > 0; i ) if( ++nonce_counter[i - 1] != ) break; } c = *input++; *output++ = (unsigned char)( c ^ stream_block[n] ); n = (n + 1) & 0x0F; } *nc_off = n; return( ); } #endif /* POLARSSL_CIPHER_MODE_CTR */ #endif /* !POLARSSL_CAMELLIA_ALT */ #if defined(POLARSSL_SELF_TEST) #include /* * Camellia test vectors from: * * http://info.isl.ntt.co.jp/crypt/eng/camellia/technology.html: * http://info.isl.ntt.co.jp/crypt/eng/camellia/dl/cryptrec/intermediate.txt * http://info.isl.ntt.co.jp/crypt/eng/camellia/dl/cryptrec/t_camellia.txt * (For each bitlength: Key 0, Nr 39) 327 */ #define CAMELLIA_TESTS_ECB static const unsigned char camellia_test_ecb_key[3][CAMELLIA_TESTS_ECB][32] = { { { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 }, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } }, { { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 }, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } }, { { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff }, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } }, }; static const unsigned char camellia_test_ecb_plain[CAMELLIA_TESTS_ECB][16] = { { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 }, { 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } }; static const unsigned char camellia_test_ecb_cipher[3][CAMELLIA_TESTS_ECB][16] = { { { 0x67, 0x67, 0x31, 0x38, 0x54, 0x96, 0x69, 0x73, 0x08, 0x57, 0x06, 0x56, 0x48, 0xea, 0xbe, 0x43 }, { 0x38, 0x3C, 0x6C, 0x2A, 0xAB, 0xEF, 0x7F, 0xDE, 0x25, 0xCD, 0x47, 0x0B, 0xF7, 0x74, 0xA3, 0x31 } 328 }, { { 0xb4, 0x99, 0x34, 0x01, 0xb3, 0xe9, 0x96, 0xf8, 0x4e, 0xe5, 0xce, 0xe7, 0xd7, 0x9b, 0x09, 0xb9 }, { 0xD1, 0x76, 0x3F, 0xC0, 0x19, 0xD7, 0x7C, 0xC9, 0x30, 0xBF, 0xF2, 0xA5, 0x6F, 0x7C, 0x93, 0x64 } }, { { 0x9a, 0xcc, 0x23, 0x7d, 0xff, 0x16, 0xd7, 0x6c, 0x20, 0xef, 0x7c, 0x91, 0x9e, 0x3a, 0x75, 0x09 }, { 0x05, 0x03, 0xFB, 0x10, 0xAB, 0x24, 0x1E, 0x7C, 0xF4, 0x5D, 0x8C, 0xDE, 0xEE, 0x47, 0x43, 0x35 } } }; #define CAMELLIA_TESTS_CBC static const unsigned char camellia_test_cbc_key[3][32] = { { 0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C } , { 0x8E, 0x73, 0xB0, 0xF7, 0xDA, 0x0E, 0x64, 0x52, 0xC8, 0x10, 0xF3, 0x2B, 0x80, 0x90, 0x79, 0xE5, 0x62, 0xF8, 0xEA, 0xD2, 0x52, 0x2C, 0x6B, 0x7B } , { 0x60, 0x3D, 0xEB, 0x10, 0x15, 0xCA, 0x71, 0xBE, 0x2B, 0x73, 0xAE, 0xF0, 0x85, 0x7D, 0x77, 0x81, 0x1F, 0x35, 0x2C, 0x07, 0x3B, 0x61, 0x08, 0xD7, 0x2D, 0x98, 0x10, 0xA3, 0x09, 0x14, 0xDF, 0xF4 } }; static const unsigned char camellia_test_cbc_iv[16] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F } ; static const unsigned char camellia_test_cbc_plain[CAMELLIA_TESTS_CBC][16] = { { 0x6B, 0xC1, 0xBE, 0xE2, 0x2E, 0x40, 0x9F, 0x96, 0xE9, 0x3D, 0x7E, 0x11, 0x73, 0x93, 0x17, 0x2A }, { 0xAE, 0x2D, 0x8A, 0x57, 0x1E, 0x03, 0xAC, 0x9C, 0x9E, 0xB7, 0x6F, 0xAC, 0x45, 0xAF, 0x8E, 0x51 }, { 0x30, 0xC8, 0x1C, 0x46, 0xA3, 0x5C, 0xE4, 0x11, 0xE5, 0xFB, 0xC1, 0x19, 0x1A, 0x0A, 0x52, 0xEF } 329 }; static const unsigned char camellia_test_cbc_cipher[3][CAMELLIA_TESTS_CBC][16] = { { { 0x16, 0x07, 0xCF, 0x49, 0x4B, 0x36, 0xBB, 0xF0, 0x0D, 0xAE, 0xB0, 0xB5, 0x03, 0xC8, 0x31, 0xAB }, { 0xA2, 0xF2, 0xCF, 0x67, 0x16, 0x29, 0xEF, 0x78, 0x40, 0xC5, 0xA5, 0xDF, 0xB5, 0x07, 0x48, 0x87 }, { 0x0F, 0x06, 0x16, 0x50, 0x08, 0xCF, 0x8B, 0x8B, 0x5A, 0x63, 0x58, 0x63, 0x62, 0x54, 0x3E, 0x54 } }, { { 0x2A, 0x48, 0x30, 0xAB, 0x5A, 0xC4, 0xA1, 0xA2, 0x40, 0x59, 0x55, 0xFD, 0x21, 0x95, 0xCF, 0x93 }, { 0x5D, 0x5A, 0x86, 0x9B, 0xD1, 0x4C, 0xE5, 0x42, 0x64, 0xF8, 0x92, 0xA6, 0xDD, 0x2E, 0xC3, 0xD5 }, { 0x37, 0xD3, 0x59, 0xC3, 0x34, 0x98, 0x36, 0xD8, 0x84, 0xE3, 0x10, 0xAD, 0xDF, 0x68, 0xC4, 0x49 } }, { { 0xE6, 0xCF, 0xA3, 0x5F, 0xC0, 0x2B, 0x13, 0x4A, 0x4D, 0x2C, 0x0B, 0x67, 0x37, 0xAC, 0x3E, 0xDA }, { 0x36, 0xCB, 0xEB, 0x73, 0xBD, 0x50, 0x4B, 0x40, 0x70, 0xB1, 0xB7, 0xDE, 0x2B, 0x21, 0xEB, 0x50 }, { 0xE3, 0x1A, 0x60, 0x55, 0x29, 0x7D, 0x96, 0xCA, 0x33, 0x30, 0xCD, 0xF1, 0xB1, 0x86, 0x0A, 0x83 } } }; #if defined(POLARSSL_CIPHER_MODE_CTR) /* * Camellia-CTR test vectors from: * * http://www.faqs.org/rfcs/rfc5528.html */ static const unsigned char camellia_test_ctr_key[3][16] = { { 0xAE, 0x68, 0x52, 0xF8, 0x12, 0x10, 0x67, 0xCC, 0x4B, 0xF7, 0xA5, 0x76, 0x55, 0x77, 0xF3, 0x9E }, { 0x7E, 0x24, 0x06, 0x78, 0x17, 0xFA, 0xE0, 0xD7, 0x43, 0xD6, 0xCE, 0x1F, 0x32, 0x53, 0x91, 0x63 }, { 0x76, 0x91, 0xBE, 0x03, 0x5E, 0x50, 0x20, 0xA8, 0xAC, 0x6E, 0x61, 0x85, 0x29, 0xF9, 0xA0, 0xDC } 330 }; static const unsigned char camellia_test_ctr_nonce_counter[3][16] = { { 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }, { 0x00, 0x6C, 0xB6, 0xDB, 0xC0, 0x54, 0x3B, 0x59, 0xDA, 0x48, 0xD9, 0x0B, 0x00, 0x00, 0x00, 0x01 }, { 0x00, 0xE0, 0x01, 0x7B, 0x27, 0x77, 0x7F, 0x3F, 0x4A, 0x17, 0x86, 0xF0, 0x00, 0x00, 0x00, 0x01 } }; static const unsigned char camellia_test_ctr_pt[3][48] = { { 0x53, 0x69, 0x6E, 0x67, 0x6C, 0x65, 0x20, 0x62, 0x6C, 0x6F, 0x63, 0x6B, 0x20, 0x6D, 0x73, 0x67 }, { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F }, { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23 } }; static const unsigned char camellia_test_ctr_ct[3][48] = { { 0xD0, 0x9D, 0xC2, 0x9A, 0x82, 0x14, 0x61, 0x9A, 0x20, 0x87, 0x7C, 0x76, 0xDB, 0x1F, 0x0B, 0x3F }, { 0xDB, 0xF3, 0xC7, 0x8D, 0xC0, 0x83, 0x96, 0xD4, 0xDA, 0x7C, 0x90, 0x77, 0x65, 0xBB, 0xCB, 0x44, 0x2B, 0x8E, 0x8E, 0x0F, 0x31, 0xF0, 0xDC, 0xA7, 0x2C, 0x74, 0x17, 0xE3, 0x53, 0x60, 0xE0, 0x48 }, { 0xB1, 0x9D, 0x1F, 0xCD, 0xCB, 0x75, 0xEB, 0x88, 0x2F, 0x84, 0x9C, 0xE2, 0x4D, 0x85, 0xCF, 0x73, 0x9C, 0xE6, 0x4B, 0x2B, 0x5C, 0x9D, 0x73, 0xF1, 0x4F, 0x2D, 0x5D, 0x9D, 0xCE, 0x98, 0x89, 0xCD, 0xDF, 0x50, 0x86, 0x96 } }; static const int camellia_test_ctr_len[3] = { 16, 32, 36 }; 331 #endif /* POLARSSL_CIPHER_MODE_CTR */ /* * Checkup routine */ int camellia_self_test( int verbose ) { int i, j, u, v; unsigned char key[32]; unsigned char buf[64]; unsigned char src[16]; unsigned char dst[16]; unsigned char iv[16]; #if defined(POLARSSL_CIPHER_MODE_CTR) size_t offset, len; unsigned char nonce_counter[16]; unsigned char stream_block[16]; #endif camellia_context ctx; memset( key, 0, 32 ); for (j = 0; j < 6; j++) { u = j >> 1; v = j & 1; if( verbose != ) printf( " CAMELLIA-ECB-%3d (%s): ", 128 + u * 64, (v == CAMELLIA_DECRYPT) ? "dec" : "enc"); for (i = 0; i < CAMELLIA_TESTS_ECB; i++ ) { memcpy( key, camellia_test_ecb_key[u][i], 16 + * u); if (v == CAMELLIA_DECRYPT) { camellia_setkey_dec(&ctx, key, 128 + u * 64); memcpy(src, camellia_test_ecb_cipher[u][i], 16); memcpy(dst, camellia_test_ecb_plain[i], 16); } else { /* CAMELLIA_ENCRYPT */ camellia_setkey_enc(&ctx, key, 128 + u * 64); memcpy(src, camellia_test_ecb_plain[i], 16); memcpy(dst, camellia_test_ecb_cipher[u][i], 16); } camellia_crypt_ecb(&ctx, v, src, buf); 332 if( memcmp( buf, dst, 16 ) != ) { if( verbose != ) printf( "failed\n" ); return( ); } } if( verbose != ) printf( "passed\n" ); } if( verbose != ) printf( "\n" ); /* * CBC mode */ for( j = 0; j < 6; j++ ) { u = j >> 1; v = j & 1; if( verbose != ) printf( " CAMELLIA-CBC-%3d (%s): ", 128 + u * 64, ( v == CAMELLIA_DECRYPT ) ? "dec" : "enc" ); memcpy( src, camellia_test_cbc_iv, 16); memcpy( dst, camellia_test_cbc_iv, 16); memcpy( key, camellia_test_cbc_key[u], 16 + * u); if (v == CAMELLIA_DECRYPT) { camellia_setkey_dec(&ctx, key, 128 + u * 64); } else { camellia_setkey_enc(&ctx, key, 128 + u * 64); } for (i = 0; i < CAMELLIA_TESTS_CBC; i++ ) { if (v == CAMELLIA_DECRYPT) { memcpy( iv , src, 16 ); memcpy(src, camellia_test_cbc_cipher[u][i], 16); memcpy(dst, camellia_test_cbc_plain[i], 16); } else { /* CAMELLIA_ENCRYPT */ memcpy( iv , dst, 16 ); 333 memcpy(src, camellia_test_cbc_plain[i], 16); memcpy(dst, camellia_test_cbc_cipher[u][i], 16); } camellia_crypt_cbc(&ctx, v, 16, iv, src, buf); if( memcmp( buf, dst, 16 ) != ) { if( verbose != ) printf( "failed\n" ); return( ); } } if( verbose != ) printf( "passed\n" ); } if( verbose != ) printf( "\n" ); #if defined(POLARSSL_CIPHER_MODE_CTR) /* * CTR mode */ for( i = 0; i < 6; i++ ) { u = i >> 1; v = i & 1; if( verbose != ) printf( " CAMELLIA-CTR-128 (%s): ", ( v == CAMELLIA_DECRYPT ) ? "dec" : "enc" ); memcpy( nonce_counter, camellia_test_ctr_nonce_counter[u], 16 ); memcpy( key, camellia_test_ctr_key[u], 16 ); offset = 0; camellia_setkey_enc( &ctx, key, 128 ); if( v == CAMELLIA_DECRYPT ) { len = camellia_test_ctr_len[u]; memcpy( buf, camellia_test_ctr_ct[u], len ); 334 camellia_crypt_ctr( &ctx, len, &offset, nonce_counter, stream_block, buf, buf ); if( memcmp( buf, camellia_test_ctr_pt[u], len ) != ) { if( verbose != ) printf( "failed\n" ); return( ); } } else { len = camellia_test_ctr_len[u]; memcpy( buf, camellia_test_ctr_pt[u], len ); camellia_crypt_ctr( &ctx, len, &offset, nonce_counter, stream_block, buf, buf ); if( memcmp( buf, camellia_test_ctr_ct[u], len ) != ) { if( verbose != ) printf( "failed\n" ); return( ); } } if( verbose != ) printf( "passed\n" ); } if( verbose != ) printf( "\n" ); #endif /* POLARSSL_CIPHER_MODE_CTR */ return ( ); } #endif #endif 335 ... DIFFIE-HELLMAN-GROUP-EXCHANGESHA256, DIFFIE-HELLMAN-GROUP-EXCHANGE-SHA1, DIFFIE-HELLMAN-GROUP14-SHA1, DIFFIE-HELLMANGROUP1-SHA1 Mã xác thực HMAC-MD5, HMAC-SHA1, UMAC-64@OPENSSH.COM, thông báo HMAC-SHA2-256,... ECB, CBC, CBC ciphertext stealing (CTS), CFB, OFB, counter mode (CTR) VMAC, HMAC, GMAC (GCM), CMAC, CBC-MAC, DMAC, Two-Track-MAC SHA-1, SHA-2 (SHA-224, SHA-256, SHA384, SHA-512), SHA-3, Tiger, WHIRLPOOL,... .42 1.4.1 Maple 1.4.2 Mathematica 1.5 CÂU HỎI ÔN TẬP .46 Chương MẬT MÃ DÒNG 48 2.1 KHÁI NIỆM MÃ DÒNG .48 2.2 CÁC ĐẶC TRƯNG .50 2.2.1 Độ