Public Key Encryption and Digital Signature - Assignment Example

TASK a) Assuming that you have access to 10,000 up-to PCs and stating any other reasonable assumptions you need to make, calculate how long itwill take, on average, to derive an AES key using a key space search (sometimes referred to as a brute force attack). b) Explain the comparative advantages and disadvantages of public key and private key cryptography. For each cryptography type: name and give outline information for ONE common cipher (excluding AES). Solution 1. Security and Convenience The primary advantage of public-key cryptography is increased security and convenience because private keys are never transmitted or revealed to anyone. By contrast, in a private-key cryptography (also called secret-key cryptography), the private keys are required to be transmitted (either manually or through a communication channel), and there may be a probability that an unauthorized person can access the secret keys during their transmission. (‘Harvard style’, n.d.a) 2. Authentication Secret-key systems require the sharing of some secret or sometimes trust of a third party to support authentication. As a result, a sender can repudiate a previously authenticated message by claiming that the shared secret was somehow compromised by one of the parties sharing the secret. For example, the Kerberos secret-key authentication system keeps copies of the secret keys of all uses in a central database; an attack on the database would allow widespread forgery. On the other hand, since each user has sole responsibility for protecting his or her private key, public-key authentication effectively prevents any sort of repudiation; this property of public-key authentication is often called non-repudiation. (‘Harvard style’, n.d.a) 3. Speed Secret-key encryption methods are significantly faster than any currently available public-key encryption methods. (‘Harvard style’, n.d.a) 4. Vulnerability Unlike secret-key cryptography, public-key cryptography may be vulnerable to impersonation even if user’s private keys are not available. A successful attack on certification authority will allow an adversary to impersonate whomever the adversary chooses by using a public-key certificate from the compromised authority to bind a key of the adversary’s choice to the name of another user. (‘Harvard style’, n.d.a) Public Key Cipher: RSA RSA, which stands for Rivest, Shamir and Adleman, was the first and most widely used public key cryptosystem. Developed in 1977 by three M.I.T. professors, it is based on the mathematical properties of modulo arithmetic. (‘Harvard style’, n.d.c) Modulo arithmetic is much like normal arithmetic, but only uses integers no longer than a limiting number, the modulus (usually written as m). Any result larger than the modulus has the modulus subtracted from it repeatedly until it is less than the modulus. Thus, instead of the numbers forming a line, modulo numbers can be thought of as forming a ring, when the largest number loops back to 0 as shown in figure below. (‘Harvard style’, n.d.c) Figure 1: Modulo numbers (Source: ‘Harvard style’, n.d.) For example, 8 + 8 mod 15 = 1, since 16 is larger than the modulus, 15, therefore, 16 – 15 = 1. Exponentiation is similarly defined; 33 mod 15 = 12 since 33 = 27 and 27 - 15 = 12. (‘Harvard style’, n.d.c) RSA involves two keys; a public key which can be known to everyone and is used for encrypting messages, and a private key which can be used to decrypt those encrypted messages. To generate the keys, RSA picks two distinct prime numbers p and q, multiplies them (p and q) together to form modulus (m), and computes φ(m) = (p - 1)(q - 1). Since xφ(m) mod m = 1, it stands to reason that xφ(m)+1 mod m = x; this special power is capable to produce an identity transformation on any number. Finally, RSA alters this special power into two factors based on fact that since (xy)z = x(yz) for any numbers, raising a number of one of these two factors produces gibberish, and raising the gibberish to the second factor produces the original number (yz = φ(m)+1). The public key consists of the modulus (m) and the public exponent – one of these powers (y); the other power (z) forms the private exponent (private key) and is therefore, kept secret to allow the original number to be recovered. (‘Harvard style’, n.d.c) For example, let 33 (3 * 11) to be modulus, so φ(m) = 2 * 10 = 20, φ(m) + 1 = 21 and x21 mod 33 = x, for any x. Now, factor 21 = 3 * 7; let 3 be our public exponent and 7 as our private exponent. Now, we can encrypt any number between 1 and 32 (one less than the modulus). Lets encrypt 15. Since 153 = 3375 and 33 * 102 = 3366 Thus, 153 mod 33 = 3375 - 3366 = 9 So 15 encrypts as 9. Now lets decrypt it, using the private exponent: Since 97 = 4782969 and 33 * 144938 = 4782954 Thus, 97 mod 33 = 4782969 - 4782954 = 15 (‘Harvard style’, n.d.c) Private Key Cipher: DES Adopted by the U.S. government in July 1977, the Data Encryption Standard (DES) is a “symmetrical” encryption algorithm – same key that is used for encryption is used to decrypt the message – is a block cipher that transforms 64-bits data blocks under a 56-bit secret key, by means of permutation and substitution. (EventID.Net, n.d.c) Figure 2: DES algorithm (Source: EventID.Net, n.d.) To demonstrate how DES algorithm works, assume the following example presented by EventID.Net (n.d.): Step 1: Process the key. Get a 64-bit key from the user which can be either entered directly or the result of hashing something. Every 8th bit (the least significant bit of each byte) is considered a parity bit and therefore, for a key to have correct parity, each byte should contain an odd number of “1” bits. For this example, the 64-bit key is [222 16 156 88 232 164 166 48]. Bits 1 – 8 1 1 0 1 1 1 1 0 Bits 9 – 16 0 0 0 1 0 0 0 0 Bits 17 – 24 1 0 0 1 1 1 0 0 Bits 25 – 32 0 1 0 1 1 0 0 0 Bits 33 – 40 1 1 1 0 1 0 0 0 Bits 41 – 48 1 0 1 0 0 1 0 0 Bits 49 – 56 1 0 1 0 0 1 1 0 Bits 57 – 64 0 0 1 1 0 0 0 0 Table 1: 64-bit key with parity bits (in red) Discard the parity bits and perform the following permutation on the remaining 56 bits of the key. 57 49 41 33 25 17 9 0 1 1 1 0 1 0 1 58 50 42 34 26 18 1 0 0 0 1 1 0 10 2 59 51 43 35 27 0 1 1 0 0 0 1 19 11 3 60 52 44 36 0 0 0 1 0 0 0 3 55 47 39 31 23 15 0 1 0 0 0 0 0 7 62 54 46 38 30 22 1 0 1 1 0 0 1 14 6 61 53 45 37 29 0 1 0 0 0 1 1 21 13 5 28 20 12 4 1 0 1 1 1 1 1 Table 2: Permuted Choice 1 (PC-1) Table 3: Permuted 56-bit key Split the permuted key into two halves; the first 28 bits are called C[0] and the last 28 bits are called D[0]. 0 1 1 1 0 1 0 0 1 0 0 0 0 0 1 0 0 0 1 1 0 1 0 1 1 0 0 1 0 1 1 0 0 0 1 0 1 0 0 0 1 1 0 0 0 1 0 0 0 1 0 1 1 1 1 1 Table 5: C[0] Table 5: D[0] Split the permuted key into two halves; the first 28 bits are called C[0] and the last 28 bits are called D[0]. 0 1 1 1 0 1 0 0 1 0 0 0 0 0 1 0 0 0 1 1 0 1 0 1 1 0 0 1 0 1 1 0 0 0 1 0 1 0 0 0 1 1 0 0 0 1 0 0 0 1 0 1 1 1 1 1 Table 5: C[0] Table 5: D[0] Calculate the 16 sub-keys, starting with i = 1. Perform one or two circular left shifts on both C[i - 1] and D[i - 1] to get C[i] and D[i], respectively. The number of shifts per iteration is given in Table 6 below. Iteration No. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 Left Shifts 1 1 2 2 2 2 2 2 1 2 2 2 2 2 2 1 Table 6: Number of shifts per iteration After 16 iterations, the following sub-keys are generated: Iteration 0 (see Step 4) C[0] 0 1 1 1 0 1 0 1 0 0 0 1 1 0 0 1 1 0 0 0 1 0 0 0 1 0 0 0 D[0] 1 0 0 0 0 0 1 0 1 1 0 0 1 0 1 0 0 0 1 1 1 0 1 1 1 1 1 0 Iteration 1 C[1] 1 1 1 0 1 0 1 0 0 0 1 1 0 0 1 1 0 0 0 1 0 0 0 1 0 0 0 0 D[1] 1 0 0 0 0 0 1 0 1 1 0 0 1 0 1 0 0 0 1 1 1 0 1 1 1 1 1 0 Iteration 2 C[2] 1 1 0 1 0 1 0 0 0 1 1 0 0 1 1 0 0 0 1 0 0 0 1 0 0 0 0 1 D[2] 0 0 0 0 0 1 0 1 1 0 0 1 0 1 0 0 0 1 1 1 0 1 1 1 1 1 0 1 Iteration 3 C[3] 0 1 0 1 0 0 0 1 1 0 0 1 1 0 0 0 1 0 0 0 1 0 0 0 0 1 1 1 D[3] 0 0 0 1 0 1 1 0 0 1 0 1 0 0 0 1 1 1 0 1 1 1 1 1 0 1 0 0 . Iteration 16 C[16] 0 1 1 1 0 1 0 1 0 0 0 1 1 0 0 1 1 0 0 0 1 0 0 0 1 0 0 0 D[16] 0 1 0 0 0 0 0 1 0 1 1 0 0 1 0 1 0 0 0 1 1 1 0 1 1 1 1 1 Table 7: Sub-keys Permute the concatenation C[i]D[i] as indicated below to yield K[i], which is 48-bits long. Bits 1 – 7 0 1 1 1 0 1 0 Bits 8 – 14 1 0 0 0 1 1 0 Bits 15 – 21 0 1 1 0 0 0 1 Bits 22 – 28 0 0 0 1 0 0 0 Bits 29 – 35 0 1 0 0 0 0 0 Bits 36 – 42 1 0 1 1 0 0 1 Bits 43 – 49 0 1 0 0 0 1 1 Bits 50 – 56 1 0 1 1 1 1 1 Table 8: C[i]D[i] 14 17 11 24 1 5 0 1 0 0 0 0 3 28 15 6 21 10 1 0 0 1 1 0 23 19 12 4 26 8 0 0 1 1 0 1 16 7 27 20 13 2 1 0 0 0 1 1 41 52 31 37 47 55 0 1 0 0 0 1 30 40 51 45 33 48 1 0 0 0 0 1 44 49 39 56 34 53 1 1 1 1 0 1 46 42 50 36 29 32 0 1 1 1 0 0 Table 9: Permuted Choice 2 (PC-2) Table 10: K[i] Loop back until K[16] has been calculated. Step 2: Process a 64-bit data block. Get a 64-bit data block. If the block is shorter than 64-bits, it should be padded as appropriate for the application. For this example, the 64-bit data block is [86 233 158 172 222 95 244 177]. Bits 1 – 8 0 1 0 1 0 1 1 0 Bits 9 – 16 1 1 1 0 1 0 0 1 Bits 17 – 24 1 0 0 1 1 1 1 0 Bits 25 – 32 1 0 1 0 1 1 0 0 Bits 33 – 40 1 1 0 1 1 1 1 0 Bits 41 – 48 0 1 0 1 1 1 1 1 Bits 49 – 56 1 1 1 1 0 1 0 0 Bits 57 – 64 1 0 1 1 0 0 0 1 Table 11: 64-bit data block Perform the following permutation on the data block. 58 50 42 34 26 18 10 2 0 1 0 1 0 1 1 0 60 52 44 36 28 20 12 4 1 1 1 0 1 0 0 1 62 54 46 38 30 22 14 6 1 0 0 1 1 1 1 0 64 56 48 40 32 24 16 8 1 0 1 0 1 1 0 0 57 49 41 33 25 17 9 1 1 1 0 1 1 1 1 0 59 51 43 35 27 19 11 3 0 1 0 1 1 1 1 1 61 53 45 37 29 21 13 5 1 1 1 1 0 1 0 0 63 55 47 39 31 23 15 7 1 0 1 1 0 0 0 1 Table 12: Initial Permutation (IP) Table 13: Permuted 64-bit data block Split the block into two halves; the first 32 bits are called L[0] and the last 32 bits are called R[0]. 0 1 1 1 0 0 1 1 1 1 0 1 1 1 1 0 1 1 1 1 0 1 0 1 1 1 0 0 1 0 1 0 0 1 1 1 1 1 0 1 0 0 1 1 1 1 1 0 1 0 1 0 0 0 1 0 0 0 1 1 0 1 0 1 Table 14: L[0] Table 15: R[0] Apply the 16 sub keys to the data block, starting with i = 1. Expand the 32-bit R[i - 1] into 48 bits according to the bit-selection function below. 32 1 2 3 4 5 1 1 0 1 1 1 4 5 6 7 8 9 1 1 1 1 0 1 8 9 10 11 12 13 0 1 1 0 0 1 12 13 14 15 16 17 0 1 0 1 0 0 16 17 18 19 20 21 0 0 0 1 1 1 20 21 22 23 24 25 1 1 1 1 0 0 24 25 26 27 28 29 0 0 0 1 1 0 28 29 30 31 32 1 1 0 1 0 1 1 Table 16: Bit-selection function Table 17: E(R[0]) Perform exclusive-or (XOR) E(R[i - 1]) with K[i]. 1 0 0 1 1 1 0 1 1 0 1 1 0 1 1 1 0 0 1 1 1 0 0 1 0 1 1 1 1 0 0 1 1 1 0 1 1 1 1 0 1 1 1 1 0 1 1 1 Table 18: E(R[i-1]) XOR K[i] Break E(R[i - 1]) XOR K[i] into eight 6-bit blocks. Bits 1-6 are B[1], bits 7-12 are B[2], and so on with bits 43-48 being B[8]. Substitute the values found in the S-boxes for all B[j], starting with j = 1. All values in the S-boxes should be considered 4 bits wide. Take the 1st and 6th bits of B[j] together as 2 bit value (call it m) indicating the row in S[j] to look for substitution. Similarly, take the 2nd through 5th bits of B[j] together as a 4-bit value (call it n) indicating the column in S[j] to find the substitution. Thus, replace B[j] with S[j][m][n]. 14 4 13 1 2 15 11 8 3 10 6 12 5 9 0 7 Since, B[1] = 1 0 0 1 1 1 So, m = 1 1 = 3 and n = 0 0 1 1 = 3 Thus, S[1][3][3] = 2 0 15 7 4 14 2 13 1 10 6 12 11 9 5 3 8 4 1 14 8 13 6 2 11 15 12 9 7 3 10 5 0 15 12 8 2 4 9 1 7 5 11 3 14 10 0 6 13 Table 19: S-Box 1 (S[1]) Calculate S[2] through S[8] by following the same procedure as illustrated above for calculating S[1]. Permute the concatenation of B[1] through B[8] as indicated below: B[1] = S[1][3][3] = 2 = 0 0 1 0 B[2] = S[2][1][13] = 9 = 1 0 0 1 B[3] = S[3][0][14] = 2 = 0 0 1 0 B[4] = S[4][3][12] = 12 = 1 1 0 0 B[5] = S[5][0][15] = 9 = 1 0 0 1 B[6] = S[6][1][14] = 3 = 0 0 1 1 B[7] = S[7][3][13] = 2 = 0 0 1 0 B[8] = S[8][3][11] = 0 = 0 0 0 0 Therefore, B[1-8] = 00101001001011001001001100100000 16 7 20 21 0 0 1 0 29 12 28 17 0 0 0 1 1 15 23 26 0 0 1 0 5 18 31 10 1 0 0 0 2 8 24 14 0 1 1 1 32 27 3 9 0 1 1 0 19 13 30 6 0 1 0 0 22 11 4 25 0 1 0 0 Table 20: Permutation (P) Table 21: P(S[1](B[1])…S[8](B[8])) Exclusive-or (XOR) the resulting value with L[i - 1]. Thus, all together, R[i] = L[i - 1] XOR P(S[1](B[1])…S[8](B[8])), where B[j] is a 6-bit block of E(R[i – 1]) XOR K[i](The function for R[i] is more concisely written as, R[i] = L[I – 1] XOR f(R[I – 1], K[i]).). 0 1 0 1 0 0 1 0 1 1 0 1 1 1 0 1 0 0 0 0 1 0 1 1 1 1 1 0 0 1 0 0 Table 22: R[1] = L[0] XOR P(S[1](B[1])…S[8](B[8])) c) Describe the sequence of operations which must be undertaken to compute and then verify the digital signature of a long message. Solution Digital signature is a mechanism by which a message is authenticated i.e. proving that a message is effectively coming from a given sender, much like a signature on a paper document. Applying digital signatures usually involves two processes; one performed by the signer and the other by the receiver of the digital signature. (CGI Group Inc., 2004) As illustrated by CGI Group Inc. (2004), the following steps are involved in singing and encrypting a message by a sender: 1. Message Signature; includes two steps: Message digest evaluation: The main purpose for evaluating a digest is to ensure that the message is kept unaltered; this is called message integrity. Digest Signature: A signature is in fact an encryption using the issuer’s (say, Alice in this case) private key. Included in the signature is also the hashing algorithm name used by the issuer. The issuer’s public key is also appended to the signature. This allows anyone to decrypt and verify the signature using the issuer’s public key and hashing algorithm. 2. Message Encryption; includes the following three steps: Creation of one time symmetric encryption/decryption key: Unlike algorithms using asymmetric keys, symmetric-key algorithms are very efficient for message and are therefore used for generating encryption and decryption keys. Message encryption: The whole message, including the signature, is encrypted using SymK, the symmetric key evaluated in Figure 3 below. Symmetric-key encryption: SymK is also used by the recipient to decrypt the message, therefore, it must be only available to the recipient (say, Bob in this case). To avoid any unauthorized access, SymK must be encrypted as well using the recipient’s public key. In case if the sender (say, Alice in this case) wants to send the same message to more than one recipient (say, Bob and John), the only addition operation performed is to repeat the step mentioned in above paragraph. Hence, the message that recipients would receive would look like: [Message+[Digest]PrKA+PuKA]SymK+[SymK]PuKB+[SymK]PuK]. Notice that the exact same SymK will be used by recipients (Bob and John) to decrypt the message. Figure 3: Signature and Encryption details with keys (Source: CGI Group Inc., 2004) Similarly, the following steps are involved in decrypting and verifying the signature of a message by a recipient: 1. Message Decryption; includes the following steps: Symmetric-key decryption: The one time symmetric-key has been used to encrypt the message. This key (SymK) has been encrypted using the recipient’s (Bob) public-key, therefore, only the intended recipient (Bob) can decrypt SymK and use it to decrypt the message. Message decryption: The message, including the signature, is decrypted using SymK. 2. Signature Verification; includes the following three steps: Message digest decryption: The digest has been encrypted using the issuer’s (Alice) private-key, therefore, the digest can only be decrypted using the issuer’s public-key included in the message. Digest evaluation: Since hashing is one-way process i.e. the message cannot be derived from the digest itself, the recipient must re-evaluate the digest using the exact same hashing algorithm the issuer used. Digest comparison: The digest decrypted (1st point) and the digest evaluated (2nd point) are compared. If there is a match, the signature has been verified, and the recipient can accept the message as coming unaltered from the issue; otherwise, the message should be rejected. Figure 4: Decryption and verification details with keys (Source: CGI Group Inc., 2004) d) Describe the sequence of operations which must be undertaken to compute and then verify the message authentication code (MAC) of a long message. Solution A message authentication code (MAC) is a short piece of information used to authenticate a message. A MAC algorithm accepts as input a secret key and an arbitrary-length message to be authenticated, and outputs a MAC (sometimes known as tag). The MAC value protects both a message’s integrity as well as its authencity, by allowing verifiers (who also posses the secret key) to detect any changes to the message content. (Wikipedia, 2009) In Figure 5, the sender of a message runs it through a MAC algorithm to produce a MAC data tag. The message and the MAC tag are then sent to the receiver. The receiver in turn runs the message portion of the transmission through the same MAC algorithm using the same key, producing a second MAC data tag. The receiver then compares the first MAC tag received in the transmission to the second generated MAC tag. If they are identical, the receiver can safely assume that the integrity of the message was not compromised, and the message was not altered or tampered with during transmission. (Wikipedia, 2009) Figure 5: Message Authentication Code algorithm (Source: Wikipedia, 2009) e) Compare and contrast digital signatures and MACs. Solution S. No. Digital Signature Message Authentication Code 1. Digital signature uses public key cryptography. (Peltier, n.d.) MAC uses private key cryptography. (Peltier, n.d.) 2. Digital signature is generated using the private key of a key pair which is only accessible to its holder. Therefore, it effectively offers non-repudiation. (Wikipedia, 2009) MAC values are both generated and verified using the same secret key which needs to be shared by the sender with the receiver of the message before initiating communications. Therefore, MAC does not provide the property of non-repudiation. (Wikipedia, 2009) 3. Digital signature can only authenticate an individual. (Peltier, n.d.) MAC authenticates all parties of a conversation. (Peltier, n.d.) TASK-2 a) Explain the operation of the THREE elements which make up the TCP congestion control algorithm. Solution Moving bulk data quickly over high-speed data network is a requirement for many applications. These applications require high-bandwidth links between network nodes. To maintain the stability of Internet all applications should be subjected to congestion control. (Jamal & Sultan, 2008) According to Jamal & Sultan (2008), TCP Reno is the standard TCP congestion control algorithm that implements the TCP’s AIMD (Additive Increase/Multiplicative Decrease) mechanism of increasing the congestion window W by one segment per round-trip time for each received ACK and halving the congestion window for each loss event per round-trip time. TCP Reno controls the congestion window as follows: Increase: (Eq. 1) Decrease: (Eq. 2) They (Jamal & Sultan, 2008) further explained that when the link bandwidth does not change, TCP Reno periodically repeats the window increase and decrease. TCP Reno’s congestion window in terms of packet loss rate (p) is defined as: (Eq. 3) As shown in (Eq. 3), TCP Reno places a serious constraint on the congestion window that can be achieved by TCP in realistic environments. For example, for a TCP Reno connection with 1500-byte packets and 100ms RTT, achieving a steady-state throughout of 1Gbps would require an average congestion window of 8300 segments, and an average packet loss rate of 2 x 10-8. However, this requirement is unrealistic in current networks because the congestion window takes more than 4000 RTT to recover after a loss event which prevents efficient use of the link bandwidth. TCP requires extremely small packet loss rate to sustain a large window which is not possible in real-life networks. (Jamal & Sultan, 2008) b) With the aid of diagrams where appropriate, compare and contrast the Tahoe, Reno and Vegas TCP algorithms. Solution As mentioned in ‘Harvard sytle’ (n.d.b), TCP Vegas algorithm is better than: 1. TCP Tahoe, because it can Detect and retransmit lost packets much faster. Requires fewer re-transmissions since it doesn’t empty the whole pipe whenever it loses packets. Accurately measure the available bandwidth and therefore, uses network resources efficiently avoiding unnecessary network congestions. 2. TCP Reno, because it can Prevent more than half of the coarse-grained timeouts of Reno by detecting and re-transmitting more than one lost packet before occurrence of timeout. Re-transmit faster as it doesn’t have to wait for 3 duplicate packets. Avoid reducing the congestion window too much prematurely. Have same advantages of congestion avoidance and bandwidth utilization like in case of Tahoe. REFERENCES CGI Group Inc. 2004, Public Key Encryption and Digital Signature: How do they work?, viewed 20 August, 2009, http://www.cgi.com/cgi/pdf/cgi_whpr_35_pki_e.pdf EventID.Net n.d., DES Encryption Example, viewed 20 August 2009, http://www.eventid.net/docs/desexample.asp ‘Harvard style’ n.d.a, Advantages and disadvantages of public-key cryptography compared with secret-key cryptography, viewed 20 August 2009, http://www.x5.net/faqs/crypto/q4.html ‘Harvard style’ n.d.b, A comparative analysis of TCP Taheo, Reno, New-Reno, SACK and Vegas, viewed 20 August 2009, http://inst.eecs.berkeley.edu/~ee122/fa05/projects/Project2/SACKRENEVEGAS.pdf ‘Harvard style’ n.d.c, Public key ciphers, viewed 20 August 2009, http://www.lincoln.edu/math/rmyrick/ComputerNetworks/InetReference/144.htm Jamal, H & Sultan, K 2008, ‘Performance analysis of TCP congestion control algorithms’, International Journals of Computers and Communications, vol. 2, no. 1, viewed 20 August 2009, http://www.wseas.us/journals/cc/cc-27.pdf Peltier, J n.d., Complete guide to CISM certification, pp. 248, viewed 20 August 2009, http://books.google.com/books?id=7X7MC8zYs_8C&pg=PA248&lpg=PA248&dq=difference+digital+signature+with+message+authentication+code&source=bl&ots=qd0HtcJg8G&sig=fjEKZBtQXtQ4ybIrMIqrI4Loua0&hl=en&ei=8IaRSs7NBZiWkQWcmc27Cg&sa=X&oi=book_result&ct=result&resnum=4#v=onepage&q=&f=false Wikipedia 2009, Message authentication code, viewed 20 August 2009, http://en.wikipedia.org/wiki/Message_authentication_code Read More