KẾT LUẬN
1. NHỮNG CÔNG VIỆC MÀ LUẬN VĂN ĐÃ ĐẠT ĐƢỢC
Luận văn này với mục tiêu nghiên cứu và ứng dụng lý thuyết cũng nhƣ các chuẩn công nghiệp đƣợc chấp nhận toàn cầu vào lĩnh vực chữ ký số để áp dụng vào thực tiễn trển khai trên các thiết bị cầm tay. Xet về mặt kết quả tổng quan, Luận văn đã đƣa ra đƣợc các:
- Nghiên cứu tổng quan về chữ ký số.
- Nghiên cứu tình hình triển khai chữ ký số tổng quan trong nƣớc và quốc tế. - Nghiên cứu lý thuyết cơ sở về chữ ký số.
- Nghiên cứu các chuẩn công nghiệp về chữ ký số.
- Phát triển các ứng dụng chữ ký số nhằm tƣơng tác với thiết bị cầm tay tƣơng đƣơng với việc ứng dụng chữ ký số đang đƣợc sử dụng trên máy tính thông thƣờng.
Kết quả của Luận văn đã đƣợc vào triển khai thực tiễn và đã đƣợc áp dụng vào các ứng dụng chữ ký số thực tiễn đầu tiên tại Việt Nam trên nền thiết bị di động và đã đƣợc một số doanh nghiệp sử dụng và từng bƣớc mở sang toàn bộ cộng đồng Việt Nam và quốc tế.
2. KHẢ NĂNG PHÁT TRIỂN CỦA LUẬN VĂN
Luận văn này dựa trên nghiên cứu cơ sở lý thuyết, thực tiễn phát triển và ứng dụng chữ ký số, mở sang một nền tảng áp dụng sản phẩm chữ ký số trên thiết bị cầm tay. Trên cơ sở thực tế của Luận văn sẽ có nhiều cơ sở để thúc đẩy thị trƣờng chữ ký số trên thiết bị cầm tay, đảm đảm an ninh thông tin trên thiết bị cầm tay. Và chính trên nền tảng mở ra nền tảng ứng dụng chữ ký số trên thiết bị cầm tay đƣợc áp dụng trong mọi giao dịch điện tử, và đây cũng là hƣớng phát triển tƣơng lai thực sự của Luận văn để mở sang một kỳ vọng cho tƣơng lai là mọi giao dịch thực hiện đƣợc trên nền tảng điện tử hoàn toàn mà vẫn đảm bảo tin cậy, xác thực, bảo mật.
TÀI LIỆU THAM KHẢO
[1.] PGD.TS Trịnh Nhật Tiến,“Giáo trình an toàn thông tin”
[2.] RSA Laboratories,“PKCS #1: RSA Cryptography Standard, Version 2.2”
[3.] RSA Laboratories, “PKCS #11: Cryptographic Token Interface Standard, Version 2.30”
[4.] RSA Laboratories, “PKCS #7: Cryptographic Message Syntax Standard”
[5.] RSA Laboratories, “PKCS #15: Cryptographic Token Information Format Standard”
[6.] Andrew Nash, William Duane, Celia Joseph, Derek Brink “PKI Implementing amd Managing E-Security ”
PHỤ LỤC
CÀI ĐẶT MỘT SỐ CHỨC NĂNG TRÊN MOBILE Phụ lục 1: CÀI ĐẶT CÁC HÀM CƠ SỞ
- Class định nghĩa Bộ sinh số ngẫu nhiên
/**
* This class represents a random number (RNG) generator object. */
class RandomNumberGenerator {
public:
/**
* Create a seeded and active RNG object for general application use */
staticRandomNumberGenerator* make_rng();
/**
* Randomize a byte array.
* @param output the byte array to hold the random output. * @param length the length of the byte array output.
*/
virtualvoid randomize(byte output[], size_t length) = 0;
/**
* Return a random vector
* @param bytes number of bytes in the result * @return randomized vector of length bytes */
SecureVector<byte> random_vec(size_t bytes) {
SecureVector<byte>output(bytes); randomize(&output[0], output.size());
return output; }
/**
* Return a random byte * @return random byte */
byte next_byte();
/**
* Check whether this RNG is seeded.
* @return true if this RNG was already seeded, false otherwise. */
virtualbool is_seeded() const { returntrue; }
/**
* Clear all internally held values of this RNG. */
virtualvoid clear() = 0;
* Return the name of this object */
virtualstd::string name() const = 0;
/**
* Seed this RNG using the entropy sources it contains. * @param bits_to_collect is the number of bits of entropy to attempt to gather from the entropy sources
*/
virtualvoid reseed(size_t bits_to_collect) = 0;
/**
* Add this entropy source to the RNG object
* @param source the entropy source which will be retained and used by RNG */
virtualvoid add_entropy_source(EntropySource* source) = 0;
/**
* Add entropy to this RNG.
* @param in a byte array containg the entropy to be added * @param length the length of the byte array in
*/
virtualvoid add_entropy(constbytein[], size_t length) = 0; RandomNumberGenerator() {}
virtual ~RandomNumberGenerator() {}
private:
RandomNumberGenerator(constRandomNumberGenerator&) {}
RandomNumberGenerator&operator=(constRandomNumberGenerator&) { return (*this); }
};
/**
* Null/stub RNG - fails if you try to use it for anything */
class Null_RNG : publicRandomNumberGenerator
{
public:
void randomize(byte[], size_t) { throwPRNG_Unseeded("Null_RNG"); }
void clear() {}
std::string name() const { return"Null_RNG"; }
void reseed(size_t) {}
bool is_seeded() const { returnfalse; }
void add_entropy(constbyte[], size_t) {}
void add_entropy_source(EntropySource* es) { delete es; } };
- Hàm sinh số ngẫu nhiên lớn
/*
* Randomize this number */
voidBigInt::randomize(RandomNumberGenerator& rng, size_t bitsize)
{ set_sign(Positive); if(bitsize == 0) clear(); else {
SecureVector<byte> array = rng.random_vec((bitsize + 7) / 8);
if(bitsize % 8)
array[0] &= 0xFF>> (8 - (bitsize % 8));
array[0] |= 0x80>> ((bitsize % 8) ? (8 - bitsize % 8) : 0); binary_decode(&array[0], array.size());
} }
- Hàm sinh số nguyên tố lớn
/*
* Generate a random prime */
BigInt random_prime(RandomNumberGenerator& rng, size_t bits, constBigInt& coprime,
size_t equiv, size_t modulo) {
if(bits <= 1)
throwInvalid_Argument("random_prime: Can't make a prime of " + to_string(bits) + " bits"); elseif(bits == 2) return ((rng.next_byte() % 2) ? 2 : 3); elseif(bits == 3) return ((rng.next_byte() % 2) ? 5 : 7); elseif(bits == 4) return ((rng.next_byte() % 2) ? 11 : 13); if(coprime <= 0)
throwInvalid_Argument("random_prime: coprime must be > 0");
if(modulo % 2 == 1 || modulo == 0)
throwInvalid_Argument("random_prime: Invalid modulo value");
if(equiv >= modulo || equiv % 2 == 0)
throwInvalid_Argument("random_prime: equiv must be < modulo, and odd");
while(true) {
BigIntp(rng, bits);
// Force lowest and two top bits on
p.set_bit(bits - 1); p.set_bit(bits - 2); p.set_bit(0);
if(p % modulo != equiv)
p += (modulo - p % modulo) + equiv;
SecureVector<size_t>sieve(sieve_size);
for(size_t j = 0; j != sieve.size(); ++j) sieve[j] = p % PRIMES[j];
size_t counter = 0;
while(true) {
if(counter == 4096 || p.bits() > bits)
break;
bool passes_sieve = true; ++counter;
p += modulo;
if(p.bits() > bits)
break;
for(size_t j = 0; j != sieve.size(); ++j) {
sieve[j] = (sieve[j] + modulo) % PRIMES[j];
if(sieve[j] == 0) passes_sieve = false; } if(!passes_sieve || gcd(p - 1, coprime) != 1) continue; if(check_prime(p, rng)) return p; } } }
- Hàm sinh khoá RSA
/*
* Create a RSA private key */
RSA_PrivateKey::RSA_PrivateKey(RandomNumberGenerator& rng, size_t bits, size_t exp) {
if (bits <512)
throwInvalid_Argument(algo_name() + ": Can't make a key that is only " + to_string(bits) + " bits long");
if (exp <3 || exp % 2 == 0)
throwInvalid_Argument(algo_name() + ": Invalid encryption exponent");
e = exp;
do {
p = random_prime(rng, (bits + 1) / 2, e);
q = random_prime(rng, bits - p.bits(), e);
n = p * q; } while (n.bits() != bits);
d = inverse_mod(e, lcm(p - 1, q - 1)); d1 = d % (p - 1); d2 = d % (q - 1); c = inverse_mod(q, p); gen_check(rng); }
Phụ lục 2: CÀI ĐẶT HÀM MÃ HÓA VÀ GIẢI MÃ
- Hàm mã hoá dữ liệu
/*
* PK_Encryptor_EME Constructor */
PK_Encryptor_EME::PK_Encryptor_EME(constPublic_Key& key,
conststd::string& eme_name) {
Algorithm_Factory::Engine_Iteratori(global_state().algorithm_factory());
while (constEngine* engine = i.next()) {
op = engine->get_encryption_op(key);
if (op)
break; }
if (!op)
throwLookup_Error("PK_Encryptor_EME: No working engine for " + key.algo_name());
eme = (eme_name == "Raw") ? 0 :get_eme(eme_name); }
/*
* Encrypt a message */
SecureVector<byte>PK_Encryptor_EME::enc(constbyte in[], size_t length,
RandomNumberGenerator& rng) const {
if (eme) {
SecureVector<byte> encoded = eme->encode(in, length,
op->max_input_bits(), rng);
if (8 * (encoded.size() - 1) + high_bit(encoded[0]) >op->max_input_bits())
throwInvalid_Argument("PK_Encryptor_EME: Input is too large");
returnop->encrypt(&encoded[0], encoded.size(), rng); } else {
if (8 * (length - 1) + high_bit(in[0]) >op->max_input_bits())
throwInvalid_Argument("PK_Encryptor_EME: Input is too large");
returnop->encrypt(&in[0], length, rng); }
- Hàm giải mã dữ liệu
/*
* PK_Decryptor_EME Constructor */
PK_Decryptor_EME::PK_Decryptor_EME(constPrivate_Key& key,
conststd::string& eme_name) {
Algorithm_Factory::Engine_Iteratori(global_state().algorithm_factory());
while (constEngine* engine = i.next()) {
op = engine->get_decryption_op(key);
if (op)
break; }
if (!op)
throwLookup_Error("PK_Decryptor_EME: No working engine for " + key.algo_name());
eme = (eme_name == "Raw") ? 0 :get_eme(eme_name); }
/*
* Decrypt a message */
SecureVector<byte>PK_Decryptor_EME::dec(constbyte msg[], size_t length) const {
try {
SecureVector<byte> decrypted = op->decrypt(msg, length);
if (eme)
returneme->decode(decrypted, op->max_input_bits());
else
return decrypted; } catch (Invalid_Argument) {
throwDecoding_Error("PK_Decryptor_EME: Input is invalid"); }
}
Phụ lục 3: CÀI ĐẶT HÀM KÝ SỐ VÀ KIỂM TRA CHỮ KÝ SỐ
- Hàm ký dữ liệu
SecureVector<byte>
NR_Signature_Operation::sign(constbyte msg[], size_t msg_len,
RandomNumberGenerator& rng) {
rng.add_entropy(msg, msg_len);
BigIntf(msg, msg_len);
if(f >= q)
throwInvalid_Argument("NR_Signature_Operation: Input is out of range");
BigInt c, d;
while(c == 0) {
do
k.randomize(rng, q.bits());
while(k >= q);
c = mod_q.reduce(powermod_g_p(k) + f); d = mod_q.reduce(k - x * c);
}
SecureVector<byte>output(2*q.bytes());
c.binary_encode(&output[output.size() / 2 - c.bytes()]); d.binary_encode(&output[output.size() - d.bytes()]); return output; } - Hàm xác thực dữ liệu SecureVector<byte>
NR_Verification_Operation::verify_mr(constbyte msg[], size_t msg_len) {
constBigInt& q = mod_q.get_modulus();
if(msg_len != 2*q.bytes())
throwInvalid_Argument("NR verification: Invalid signature");
BigIntc(msg, q.bytes());
BigIntd(msg + q.bytes(), q.bytes());
if(c.is_zero() || c >= q || d >= q)
throwInvalid_Argument("NR verification: Invalid signature");
BigInt i = mod_p.multiply(powermod_g_p(d), powermod_y_p(c));
returnBigInt::encode(mod_q.reduce(c - i)); }