Uploaded on

 

  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
    Be the first to like this
No Downloads

Views

Total Views
382
On Slideshare
0
From Embeds
0
Number of Embeds
0

Actions

Shares
Downloads
11
Comments
0
Likes
0

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide
  • Block ciphers work a on block / word at a time, which is some number of bits. All of these bits have to be available before the block can be processed. Stream ciphers work on a bit or byte of the message at a time, hence process it as a “stream”.
  • Block ciphers work a on block / word at a time, which is some number of bits. All of these bits have to be available before the block can be processed. Stream ciphers work on a bit or byte of the message at a time, hence process it as a “stream”.
  • Public key schemes are no more or less secure than private key schemes - in both cases the size of the key determines the security. Note also that you can't compare key sizes - a 64-bit private key scheme has very roughly similar security to a 512-bit RSA - both could be broken given sufficient resources. But with public key schemes at least there's usually a firmer theoretical basis for determining the security since its based on well-known and well studied number theory problems.
  • Both the prime generation and the derivation of a suitable pair of inverse exponents may involve trying a number of alternatives, but theory shows the number is not large.
  • RSA is the best known, and by far the most widely used general public key encryption algorithm.
  • These are the specifications for good hash functions. Essentially it must be extremely difficult to find 2 messages with the same hash, and the hash should not be related to the message in any obvious way (ie it should be a complex non-linear function of the message). There are quite a few similarities in the evolution of hash functions & block ciphers, and in the evolution of the design requirements on both.
  • The Birthday Attack exploits the birthday paradox – the chance that in a group of people two will share the same birthday – only 23 people are needed for a Pr>0.5 of this. Can generalize the problem to one wanting a matching pair from any two sets, and show need 2 m / 2 in each to get a matching m-bit hash. Note that creating many message variants is relatively easy, either by rewording or just varying the amount of white-space in the message.
  • MD5 is the current, and very widely used, member of Rivest’s family of hash functions.
  • The padded message is broken into 512-bit blocks, processed along with the buffer value using 4 rounds, and the result added to the input buffer to make the new buffer value. Repeat till run out of message, and use final buffer value as hash. nb. due to padding always have a full final block (with length in it).
  • Stallings Fig 12.1
  • MD4 is the precursor to MD5, and was widely used. It uses 3 instead of 4 rounds, and the round functions are a little simpler. In creating MD5 Rivest aimed to strengthen the algorithms by introducing the extra round, and varying the constants used.
  • Some progress has been made analysing MD5, which along with the hash size of 128-bits means its starting to look too small. Hence interest in hash functions that create larger hashes.
  • SHA is one of the newer generation of hash functions, more resistant to cryptanalysis, and now probably preferred for new applications.
  • Note that the SHA-1 Overview is very similar to that of MD5.
  • Compare using the design goals listed earlier. SHA-1 is probbaly the preferred hash function for new applications. Currently no problems are known with it.
  • See Stallings Tables 12.3 and 12.4 for details.
  • See Stallings Tables 12.3 and 12.4 for details.

Transcript

  • 1. Lecture 1: Cryptography for Network Security Anish Arora CIS694K Introduction to Network Security
  • 2. Symmetric encryption
  • 3. Symmetric encryption requirements
    • two requirements for secure use of symmetric encryption:
      • a strong encryption algorithm
      • a secret key known only to sender / receiver
        • y= S ‹ x › in notation of book : Y = E K ( X )
        • x= S ‹ y › X = D K ( Y )
    • assume encryption algorithm is known
    • implies a secure channel to distribute key
  • 4. Block versus stream ciphers
    • block ciphers divide messages into blocks, each is then en/decrypted
        • like a substitution on very big characters
        • 64-bits or more
        • would need table of 2 64 entries for a 64-bit block
        • instead create from smaller building blocks
        • using idea of a product cipher
          • substitution (S-box) provides confusion
          • permutation (P-box) provides diffusion
    • stream ciphers process messages a bit or byte at a time
        • typically have a (pseudo) random stream key
  • 5. Block versus stream ciphers … contd
        • key should satisfy
          • statistical uniformity: of distribution of numbers in sequence
          • unpredictability: of successive members of sequence
        • randomness of key destroys statistical properties in message
        • but must not reuse stream key
        • e.g. RC4 used in SSL and WEP
    • many current ciphers are block ciphers
    • many symmetric block ciphers use Feistel Cipher Structure
  • 6. Fesitel schema for symmetric encryption
    • Overall processing at each iteration: use two 32-bit halves L and R
        • Li = Ri-1
        • Ri = Li-1  F(Ri-1, Ki)
  • 7. Data Encryption Standard (DES)
    • A widely used symmetric encryption scheme
    • Algorithm is referred to as Data Encryption Algorithm (DEA)
    • DES is a block cipher
    • Plaintext is processed in 64-bit blocks
    • Key is usually 56-bits in length
    • n rounds, in each
      • every block first undergoes key-based substitution
      • then all blocks are collated and undergo key-based permutation
    • Easy in hardware, slow in software
      • selection of block size, key size, #rounds, round function, subkey generation scheme trades off security vs speed
  • 8. The function F in DES
    • takes 32-bit R half & 48-bit subkey and:
      • expands R to 48-bits using perm E
      • adds to subkey
      • passes through 8 S-boxes to get 32-bit result
      • finally permutes this using 32-bit perm P
  • 9. DEA Decryption runs backward
  • 10. DES History
    • IBM developed Lucifer cipher
      • by team led by Feistel
      • used 64-bit data blocks with 128-bit key
    • Then redeveloped as a commercial cipher with input from NSA & others
    • In 1973, NBS issued request for proposals for a national cipher standard
    • IBM submitted their revised Lucifer which was eventually accepted as the DES
    • DES standard is public
    • But there has been considerable controversy over design
      • in choice of 56-bit key (vs original Lucifer 128-bit)
      • and because design criteria were classified
  • 11. Breaking DES
  • 12. Concerns about DEA
    • Key length of only 56-bits is insufficient
    • Even with larger keys, breaking is feasible if you have
      • known plaintext or have repeated encryptions
        • generally these are statistical attacks
      • access to timing or power consumption information
        • use knowledge of implementation to derive subkey bits
        • exploit fact that calculations take varying times based on input value
        • particularly problematic on smartcards
  • 13. Weaknesses in DES
    • DES has Weak and Semi-Weak Keys: The round key construction is such that
      • Any key comprising All 0s, All 1s, Alternating 0s and 1a, or Alternating 1s and 0s is its own inverse (these are the 4 weak keys)
      • The set of keys composed of two halves each of the above sorts is such that each key has an inverse in this set (these are 12 semi-weak keys)
    • Complement key property means that brute force search for DES is of complexity 2 55 , not 2 56
  • 14. DES Electronic Code Book
    • In encryption via ECB, repeated 64-bit blocks are identically encrypted
    • ECB attackers who know the data structure (e.g. fields such as salary ) can reorder blocks while preserving structure
  • 15. Cipher Block Chaining
    • To overcome ECB weakness, add (i.e. XOR) a random number to each 64-bit block being encrypted, and additionally communicate the random number in the clear
    • This is inefficient
    • Approximation: only communicate the initial random number, and derive the successive random numbers from the previously encrypted message
      • Initial random number is called the initialization vector
      • Default IV s, such as All Zeroes, can be used, but is insecure for repeated transmissions of the same message sequence
  • 16. Cipher Block Chaining
    • Improvement over ECB: XOR a random number to each 64-bit block being encrypted, & communicate the random number in the clear
    • An optimization: communicate only the initial random number, & derive successive numbers from previously encrypted message
      • initial random number is called the initialization vector
      • use default IV s, such as All Zeroes, can be used, but this is insecure for repeated transmissions of the same message sequence
  • 17. A CBC threat
    • If message structure is known, intruder can systematically ensure that a modified message is delivered, by changing the previous ciphertext
        • but then the previous plaintext is deciphered in a way not controlled by intruder
    • An alternative to CBC is the Counter Mode (CTR):
    • precompute encryptions of a counter value and XOR with successive messages (this method enjoys parallelism)
  • 18. Multiple DES, 3DES
    • Two successive encryptions with different keys are better than one 56 bit key
      • E 2 .E 1 to encrypt and D 2 .D 1 to decrypt
      • Combinatorially, two keys yields more permutations than those possible with one key
      • However, meet-in-the-middle cryptanalysis reduces complexity of attack to 2 56 , so net improvement is not large
    • 3DES uses two keys: E 1 .D 2 .E 1 to encrypt and D 1 .E 2 .D 1 to decrypt
      • or three keys: E 3 .D 2 .E 1 to encrypt and D 3 .E 2 .D 1 to decrypt
  • 19. Other symmetric block ciphers
    • Blowfish
      • Easy to implement
      • High execution speed
      • Run in less than 5K of memory
      • Uses a 32 to 448 bit key
    • RC5
      • Suitable for hardware and software
      • Fast, simple, but proprietary
      • Adaptable to processors of different word lengths
      • Variable number of rounds
      • Variable-length key
      • Low memory requirement
      • High security
      • Data-dependent rotations
  • 20. AES
    • AES, Elliptic Curve, IDEA, Public Key cryptography concern numbers & finite fields
    • US NIST issued call for ciphers in 1997
      • 15 candidates accepted in Jun 98
      • 5 were shortlisted in Aug 99
      • Rijndael was selected as the AES in Oct 2000
      • issued as a standard in Nov 2001
    • Symmetric block cipher, 128-bit data, 128/192/256-bit keys
      • provide full specification & design details
      • both C & Java implementations
      • NIST have released all submissions & unclassified analyses
      • iterative (vs feistel) cipher, operates on entire block per round
  • 21. Asymmetric encryption: Public key cryptography
  • 22. Security of public key schemes
    • brute force attacks infeasible since keys used are too large (> 512bits)
    • security relies on a large computation difference in difficulty between easy (en/decrypt) and hard (cryptanalyse) problems
    • the hard problem is generally known, it’s just made too hard to do in practice
    • requires the use of very large numbers
    • hence is slow compared to private key schemes
  • 23. Background
    • Asymmetric cryptography invented by Diffie and Helman ’76
    • 3 categories of uses:
      • encryption/decryption (provide secrecy)
      • digital signatures (provide authentication)
      • key exchange (of session keys)
  • 24. Authentication using public keys
  • 25. RSA
    • To encrypt a message M the sender:
      • obtain public key of recipient KU={e,N}
      • computes: C=M e mod N , where 0 ≤ M < N
    • To decrypt the ciphertext C the receiver:
      • uses its private key KR={d,p,q}
      • computes: M=C d mod N
    • Message M is smaller than modulus N (so block if needed)
  • 26. RSA key generation
    • 1: determine two primes at random - p, q
    • primes p,q must not be easily derived from mod N=p.q
      • means must be sufficiently large
      • typically guess and use probabilistic test
    • 2: select either e or d and compute the other
    • exponents e , d are inverses
  • 27. RSA (contd.)
    • Due to Rivest, Shamir & Adleman of MIT in 1977
    • Best known & widely used public-key scheme
    • Based on exponentiation in a finite (Galois) field over integers modulo a prime
      • exponentiation takes O((log n) 3 ) operations (easy)
    • Uses large integers (e.g. 1024 bits)
    • Security due to cost of factoring large numbers
      • factorization takes O(e log n log log n ) operations (hard)
      • barring dramatic breakthrough 1024+ bit RSA secure
    • Timing attacks possible
      • exploit time taken in exponentiation to infer operands
      • countermeasures
        • use constant exponentiation time, add random delays
  • 28. Hash functions
    • a hash function produces a fingerprint of some file/message/data
      • h = H(M)
      • condenses a variable-length message M
      • to a fixed-sized fingerprint
    • usually assume that the hash function is public, not keyed
      • cf. MAC which is keyed
    • hash used to detect changes to message
    • can use in various ways with message
    • most often to create a digital signature, or fingerprint
  • 29. Requirements for hash functions
    • can be applied to any sized message M
    • produces fixed-length output h
    • is easy to compute h=H(M) for any message M
    • given h is infeasible to find x s.t. H(x)=h
      • one-way property
    • given x is infeasible to find y s.t . H(y)=H(x)
      • weak collision resistance
    • is infeasible to find any x,y s.t . H(y)=H(x)
      • strong collision resistance
  • 30. Simple hash functions
    • there are several proposals for simple functions, based on XOR of message blocks:
      • e.g. longitudinal redundancy check:
        • xor of columns of n-bit block arranged in rows
      • e.g. above+ circular left shift of hash after each row
        • effect of rotated XOR (RXOR) is to randomize the input
    • but these lack weak collision resistance
      • simply “add a block” to obtain desired hash
    • need a stronger cryptographic function
  • 31. Birthday attacks imply need longer hash values
    • You might think a 64-bit hash is secure
    • but by Birthday Paradox is not
    • birthday attack works thus:
      • opponent generates 2 m / 2 variations of a valid message all with essentially the same meaning
      • opponent also generates 2 m / 2 variations of a desired fraudulent message
      • two sets of messages are compared to find pair with same hash (probability > 0.5 by birthday paradox)
      • have user sign the valid message, then substitute the forgery which will have a valid signature
    • conclusion is that need to use longer hash values
    • also, you might wish to change every message you sign !
  • 32. Hash algorithms
    • similarities in evolution of hash functions & block ciphers
      • increasing power of brute-force attacks led to evolution in algorithms
        • from DES to AES in block ciphers
        • from MD4 & MD5 to SHA-1 in hash algorithms
    • likewise tend to use common iterative structure as do block ciphers
      • iteration of collision-resistant round compression function preserves collision resistance
    • good round functions should have an avalanche effect
      • small changes in input should have large changes in output
  • 33. Block ciphers as hash functions
    • can use block ciphers as hash functions
      • using H 0 =0 and zero-pad of final block
      • compute: H i = E M i [H i-1 ]
      • and use final block as the hash value
      • similar to cipher block chaining but without a key
    • but resulting hash should not be too small (64-bit)
    • like block ciphers have brute-force attacks, and a number of analytic attacks on iterated hash functions
  • 34. MD5
    • designed by Ronald Rivest (the R in RSA)
    • latest in a series of MD2, MD4
    • produces a 128-bit hash value
    • until recently was the most widely used hash algorithm
      • in recent times had both brute-force & cryptanalytic concerns
    • specified as Internet standard RFC1321
  • 35. MD5 overview
    • pad message so its length is 448 mod 512
    • append a 64-bit length value to message
    • initialise 4-word (128-bit) MD buffer (A,B,C,D)
    • process message in 16-word (512-bit) blocks:
      • using 4 rounds of 16-bit operations on message block & buffer
      • add output to buffer input to form new buffer value
    • output hash value is the final buffer value
  • 36. MD5 overview
  • 37. MD4
    • precursor to MD5
    • also produces a 128-bit hash of message
    • has 3 rounds of 16 steps vs 4 in MD5
    • design goals:
      • collision resistant (hard to find collisions)
      • direct security (no dependence on &quot;hard&quot; problems)
      • fast, simple, compact
      • favours little-endian systems (e.g., PCs)
  • 38. Strength of MD5
    • MD5 hash is dependent on all message bits
    • Rivest claimed security is as strong as can be with 128 bit code
    • known attacks are:
      • Berson 92 attacked any 1 round using differential cryptanalysis (but can’t extend)
      • Boer & Bosselaers 93 found a pseudo collision (again unable to extend)
      • Dobbertin 96 created collisions on MD compression function (but initial constants prevent exploit)
      • conclusion was that MD5 should be vulnerable soon
    • In 2004, an attack was found
  • 39. Secure Hash Algorithm (SHA-1)
    • SHA was designed by NIST & NSA in 1993, revised 1995 as SHA-1
    • US standard for use with DSA signature scheme
      • standard is FIPS 180-1 1995, also Internet RFC3174
      • nb. the algorithm is SHA, the standard is SHS
    • produces 160-bit hash values
    • now the generally preferred hash algorithm
    • based on design of MD4 with key differences
  • 40. SHA overview
    • pad message so its length is 448 mod 512
    • append a 64-bit length value to message
    • initialise 5-word (160-bit) buffer (A,B,C,D,E) to
      • (67452301,efcdab89,98badcfe,10325476,c3d2e1f0)
    • process message in 16-word (512-bit) chunks:
      • expand 16 words into 80 words by mixing & shifting
      • use 4 rounds of 20 bit operations on message block & buffer
      • add output to input to form new buffer value
    • output hash value is the final buffer value
  • 41. SHA-1 verses MD5
    • brute force attack is harder (160 vs 128 bits for MD5)
    • not vulnerable to any known attacks (compared to MD4/5)
    • a little slower than MD5 (80 vs 64 steps)
    • both designed as simple and compact
    • optimised for big endian CPU's (vs MD5 which is optimised for little endian CPU’s)
  • 42. Revised secure hash standard
    • NIST have issued a revision FIPS 180-2
    • adds 3 additional hash algorithms
    • SHA-256, SHA-384, SHA-512
    • designed for compatibility with increased security provided by the AES cipher
    • structure & detail is similar to SHA-1
    • hence analysis should be similar
  • 43. Reading on Crypto
    • Comparable to the extent covered in class, read
    • Chapter 3: 3.1-3.4, 3.6
    • Chapter 5: 5.1
    • Chapter 6: 6.2-6.5
    • Chapter 7: 7.4
    • Chapter 9: 9.1-9.2
    • Chapter 11: 11.4-11.5
    • Chapter 12: 12.1-12.2