book

Implementing SSL/TLS Using Cryptography and PKI

by Joshua Davies

January 2011

Intermediate to advanced

696 pages

16h 56m

English

Wiley

Read now

Unlock full access

Supplemental Web SitesRoadmap and Companion Source CodeOutline of the BookHow to Read This Book
What Are Secure Sockets?Insecure Communications: Understanding the HTTP ProtocolRoadmap for the Rest of This Book
Understanding Block Cipher Cryptography AlgorithmsUnderstanding Stream Cipher Algorithms
Understanding the Theory Behind the RSA AlgorithmPerforming Arbitrary Precision Binary Math to Implement Public-Key CryptographyEncryption and Decryption with RSAAchieving Perfect Forward Secrecy with Diffie-Hellman Key ExchangeGetting More Security per Key Bit: Elliptic Curve CryptographyMaking ECC Work with Whole Integers: Elliptic-Curve Cryptography over Fp
Using Message Digests to Create Secure Document Surrogates
Putting It Together: The Secure Channel ProtocolEncoding with ASN.1Developing an ASN.1 ParserManaging CertificatesOther Problems with Certificates
Implementing the TLS 1.0 Handshake (Client Perspective)Secure Data Transfer with TLSImplementing TLS ShutdownExamining HTTPS End-to-End Examples (TLS 1.0)Differences Between SSL 3.0 and TLS 1.0Differences Between TLS 1.0 and TLS 1.1
Implementing the TLS 1.0 Handshake from the Server's PerspectiveAvoiding Common Pitfalls When Adding HTTPS Support to a ServerWhen a Browser Displays Errors: Browser Trust Issues
Passing Additional Information with Client Hello ExtensionsSafely Reusing Key Material with Session ResumptionAvoiding Fixed Parameters with Ephemeral Key ExchangeVerifying Identity with Client AuthenticationDealing with Legacy Implementations: Exportable CiphersDiscarding Key Material Through Session Renegotiation
Supporting TLS 1.2 When You Use RSA for the Key ExchangeImpact to Diffie-Hellman Key ExchangeAdding Support for AEAD Mode CiphersWorking ECC Extensions into the TLS LibraryThe Current State of TLS 1.2
Adding the NTTPS Extension to the NTTP AlgorithmImplementing "Multi-hop" SMTP over TLS and Protecting Email Content with S/MIMESecuring Datagram TrafficSupporting SSL When Proxies Are InvolvedSSL with OpenSSL
The Decimal and Binary Numbering SystemsUnderstanding Binary Logical OperationsTwo's-Complement Representation of Negative NumbersBig-Endian versus Little-Endian Number Formats
Installing TCPDumpInstalling OpenSSL
Implementing the SSL Handshake

Content preview from Implementing SSL/TLS Using Cryptography and PKI

CHAPTER 4 Authenticating Communications Using Digital Signatures

In Chapter 3, you examined public key cryptography in detail. Public key cryptography involves generating two mathematically related keys, one of which can be used to encrypt a value and the other of which can be used to decrypt a value previously encrypted with the other. One important point to note is that it technically doesn't matter which key you use to perform the encryption, as long as the other one is available to perform the decryption. The RSA algorithm defines a public key that is used to encrypt, and a private key that is used to decrypt. However, the algorithm works if you reverse the keys — if you encrypt something with the private key, it can be decrypted with — and only with — the public key.

At first glance, this doesn't sound very useful. The public key, after all, is public. It's freely shared with anybody and everybody. Therefore, if a value is encrypted with the private key, it can be decrypted by anybody and everybody as well. However, the nature of public/private keypairs is such that it's also impossible — or, to be technically precise, mathematically infeasible — for anybody except the holder of the private key to generate something that can be decrypted using the public key. After all, the encryptor must find a number c such that c^e%n = m for some arbitrary m. By definition, c = m^d satisfies this condition and it is believed to be computationally infeasible to find another such number c