tech-invite   World Map     

IETF     RFCs     Groups     SIP     ABNFs    |    3GPP     Specs     Gloss.     Arch.     IMS     UICC    |    Misc.    |    search     info

RFC 6101

Historic
Pages: 67
Top     in Index     Prev     Next
in Group Index     Prev in Group     Next in Group     Group: ~sec-tls

The Secure Sockets Layer (SSL) Protocol Version 3.0

Part 1 of 3, p. 1 to 12
None       Next RFC Part

 


Top       ToC       Page 1 
Internet Engineering Task Force (IETF)                         A. Freier
Request for Comments: 6101                                    P. Karlton
Category: Historic                               Netscape Communications
ISSN: 2070-1721                                                P. Kocher
                                                  Independent Consultant
                                                             August 2011


          The Secure Sockets Layer (SSL) Protocol Version 3.0

Abstract

   This document is published as a historical record of the SSL 3.0
   protocol.  The original Abstract follows.

   This document specifies version 3.0 of the Secure Sockets Layer (SSL
   3.0) protocol, a security protocol that provides communications
   privacy over the Internet.  The protocol allows client/server
   applications to communicate in a way that is designed to prevent
   eavesdropping, tampering, or message forgery.

Foreword

   Although the SSL 3.0 protocol is a widely implemented protocol, a
   pioneer in secure communications protocols, and the basis for
   Transport Layer Security (TLS), it was never formally published by
   the IETF, except in several expired Internet-Drafts.  This allowed no
   easy referencing to the protocol.  We believe a stable reference to
   the original document should exist and for that reason, this document
   describes what is known as the last published version of the SSL 3.0
   protocol, that is, the November 18, 1996, version of the protocol.

   There were no changes to the original document other than trivial
   editorial changes and the addition of a "Security Considerations"
   section.  However, portions of the original document that no longer
   apply were not included.  Such as the "Patent Statement" section, the
   "Reserved Ports Assignment" section, and the cipher-suite registrator
   note in the "The CipherSuite" section.  The "US export rules"
   discussed in the document do not apply today but are kept intact to
   provide context for decisions taken in protocol design.  The "Goals
   of This Document" section indicates the goals for adopters of SSL
   3.0, not goals of the IETF.

   The authors and editors were retained as in the original document.
   The editor of this document is Nikos Mavrogiannopoulos
   (nikos.mavrogiannopoulos@esat.kuleuven.be).  The editor would like to
   thank Dan Harkins, Linda Dunbar, Sean Turner, and Geoffrey Keating
   for reviewing this document and providing helpful comments.

Page 2 
Status of This Memo

   This document is not an Internet Standards Track specification; it is
   published for the historical record.

   This document defines a Historic Document for the Internet community.
   This document is a product of the Internet Engineering Task Force
   (IETF).  It represents the consensus of the IETF community.  It has
   received public review and has been approved for publication by the
   Internet Engineering Steering Group (IESG).  Not all documents
   approved by the IESG are a candidate for any level of Internet
   Standard; see Section 2 of RFC 5741.

   Information about the current status of this document, any errata,
   and how to provide feedback on it may be obtained at
   http://www.rfc-editor.org/info/rfc6101.

Copyright Notice

   Copyright (c) 2011 IETF Trust and the persons identified as the
   document authors.  All rights reserved.

   This document is subject to BCP 78 and the IETF Trust's Legal
   Provisions Relating to IETF Documents
   (http://trustee.ietf.org/license-info) in effect on the date of
   publication of this document.  Please review these documents
   carefully, as they describe your rights and restrictions with respect
   to this document.  Code Components extracted from this document must
   include Simplified BSD License text as described in Section 4.e of
   the Trust Legal Provisions and are provided without warranty as
   described in the Simplified BSD License.

   This document may contain material from IETF Documents or IETF
   Contributions published or made publicly available before November
   10, 2008.  The person(s) controlling the copyright in some of this
   material may not have granted the IETF Trust the right to allow
   modifications of such material outside the IETF Standards Process.
   Without obtaining an adequate license from the person(s) controlling
   the copyright in such materials, this document may not be modified
   outside the IETF Standards Process, and derivative works of it may
   not be created outside the IETF Standards Process, except to format
   it for publication as an RFC or to translate it into languages other
   than English.

Top       Page 3 
Table of Contents

   1. Introduction ....................................................5
   2. Goals ...........................................................5
   3. Goals of This Document ..........................................6
   4. Presentation Language ...........................................6
      4.1. Basic Block Size ...........................................7
      4.2. Miscellaneous ..............................................7
      4.3. Vectors ....................................................7
      4.4. Numbers ....................................................8
      4.5. Enumerateds ................................................8
      4.6. Constructed Types ..........................................9
           4.6.1. Variants ...........................................10
      4.7. Cryptographic Attributes ..................................11
      4.8. Constants .................................................12
   5. SSL Protocol ...................................................12
      5.1. Session and Connection States .............................12
      5.2. Record Layer ..............................................14
           5.2.1. Fragmentation ......................................14
           5.2.2. Record Compression and Decompression ...............15
           5.2.3. Record Payload Protection and the CipherSpec .......16
      5.3. Change Cipher Spec Protocol ...............................18
      5.4. Alert Protocol ............................................18
           5.4.1. Closure Alerts .....................................19
           5.4.2. Error Alerts .......................................20
      5.5. Handshake Protocol Overview ...............................21
      5.6. Handshake Protocol ........................................23
           5.6.1. Hello messages .....................................24
           5.6.2. Server Certificate .................................28
           5.6.3. Server Key Exchange Message ........................28
           5.6.4. Certificate Request ................................30
           5.6.5. Server Hello Done ..................................31
           5.6.6. Client Certificate .................................31
           5.6.7. Client Key Exchange Message ........................31
           5.6.8. Certificate Verify .................................34
           5.6.9. Finished ...........................................35
      5.7. Application Data Protocol .................................36
   6. Cryptographic Computations .....................................36
      6.1. Asymmetric Cryptographic Computations .....................36
           6.1.1. RSA ................................................36
           6.1.2. Diffie-Hellman .....................................37
           6.1.3. FORTEZZA ...........................................37
      6.2. Symmetric Cryptographic Calculations and the CipherSpec ...37
           6.2.1. The Master Secret ..................................37
           6.2.2. Converting the Master Secret into Keys and
                  MAC Secrets ........................................37
   7. Security Considerations ........................................39
   8. Informative References .........................................40

Top      ToC       Page 4 
   Appendix A. Protocol Constant Values ..............................42
     A.1. Record Layer ...............................................42
     A.2. Change Cipher Specs Message ................................43
     A.3. Alert Messages .............................................43
     A.4. Handshake Protocol .........................................44
       A.4.1. Hello Messages .........................................44
       A.4.2. Server Authentication and Key Exchange Messages ........45
     A.5. Client Authentication and Key Exchange Messages ............46
       A.5.1. Handshake Finalization Message .........................47
     A.6. The CipherSuite ............................................47
     A.7. The CipherSpec .............................................49
   Appendix B. Glossary ..............................................50
   Appendix C. CipherSuite Definitions ...............................53
   Appendix D. Implementation Notes ..................................56
     D.1. Temporary RSA Keys .........................................56
     D.2. Random Number Generation and Seeding .......................56
     D.3. Certificates and Authentication ............................57
     D.4. CipherSuites ...............................................57
     D.5. FORTEZZA ...................................................57
       D.5.1. Notes on Use of FORTEZZA Hardware ......................57
       D.5.2. FORTEZZA Cipher Suites .................................58
       D.5.3. FORTEZZA Session Resumption ............................58
   Appendix E. Version 2.0 Backward Compatibility ....................59
     E.1. Version 2 Client Hello .....................................59
     E.2. Avoiding Man-in-the-Middle Version Rollback ................61
   Appendix F. Security Analysis .....................................61
     F.1. Handshake Protocol .........................................61
       F.1.1. Authentication and Key Exchange ........................61
       F.1.2. Version Rollback Attacks ...............................64
       F.1.3. Detecting Attacks against the Handshake Protocol .......64
       F.1.4. Resuming Sessions ......................................65
       F.1.5. MD5 and SHA ............................................65
     F.2. Protecting Application Data ................................65
     F.3. Final Notes ................................................66
   Appendix G. Acknowledgements ......................................66
     G.1. Other Contributors .........................................66
     G.2. Early Reviewers ............................................67

Top      ToC       Page 5 
1.  Introduction

   The primary goal of the SSL protocol is to provide privacy and
   reliability between two communicating applications.  The protocol is
   composed of two layers.  At the lowest level, layered on top of some
   reliable transport protocol (e.g., TCP [RFC0793]), is the SSL record
   protocol.  The SSL record protocol is used for encapsulation of
   various higher level protocols.  One such encapsulated protocol, the
   SSL handshake protocol, allows the server and client to authenticate
   each other and to negotiate an encryption algorithm and cryptographic
   keys before the application protocol transmits or receives its first
   byte of data.  One advantage of SSL is that it is application
   protocol independent.  A higher level protocol can layer on top of
   the SSL protocol transparently.  The SSL protocol provides connection
   security that has three basic properties:

   o  The connection is private.  Encryption is used after an initial
      handshake to define a secret key.  Symmetric cryptography is used
      for data encryption (e.g., DES [DES], 3DES [3DES], RC4 [SCH]).

   o  The peer's identity can be authenticated using asymmetric, or
      public key, cryptography (e.g., RSA [RSA], DSS [DSS]).

   o  The connection is reliable.  Message transport includes a message
      integrity check using a keyed Message Authentication Code (MAC)
      [RFC2104].  Secure hash functions (e.g., SHA, MD5) are used for
      MAC computations.

2.  Goals

   The goals of SSL protocol version 3.0, in order of their priority,
   are:

   1.  Cryptographic security

          SSL should be used to establish a secure connection between
          two parties.

   2.  Interoperability

          Independent programmers should be able to develop applications
          utilizing SSL 3.0 that will then be able to successfully
          exchange cryptographic parameters without knowledge of one
          another's code.

Top      ToC       Page 6 
          Note: It is not the case that all instances of SSL (even in
          the same application domain) will be able to successfully
          connect.  For instance, if the server supports a particular
          hardware token, and the client does not have access to such a
          token, then the connection will not succeed.

   3.  Extensibility

          SSL seeks to provide a framework into which new public key and
          bulk encryption methods can be incorporated as necessary.
          This will also accomplish two sub-goals: to prevent the need
          to create a new protocol (and risking the introduction of
          possible new weaknesses) and to avoid the need to implement an
          entire new security library.

   4.  Relative efficiency

          Cryptographic operations tend to be highly CPU intensive,
          particularly public key operations.  For this reason, the SSL
          protocol has incorporated an optional session caching scheme
          to reduce the number of connections that need to be
          established from scratch.  Additionally, care has been taken
          to reduce network activity.

3.  Goals of This Document

   The SSL protocol version 3.0 specification is intended primarily for
   readers who will be implementing the protocol and those doing
   cryptographic analysis of it.  The spec has been written with this in
   mind, and it is intended to reflect the needs of those two groups.
   For that reason, many of the algorithm-dependent data structures and
   rules are included in the body of the text (as opposed to in an
   appendix), providing easier access to them.

   This document is not intended to supply any details of service
   definition or interface definition, although it does cover select
   areas of policy as they are required for the maintenance of solid
   security.

4.  Presentation Language

   This document deals with the formatting of data in an external
   representation.  The following very basic and somewhat casually
   defined presentation syntax will be used.  The syntax draws from
   several sources in its structure.  Although it resembles the
   programming language "C" in its syntax and External Data
   Representation (XDR) [RFC1832] in both its syntax and intent, it

Top      ToC       Page 7 
   would be risky to draw too many parallels.  The purpose of this
   presentation language is to document SSL only, not to have general
   application beyond that particular goal.

4.1.  Basic Block Size

   The representation of all data items is explicitly specified.  The
   basic data block size is one byte (i.e., 8 bits).  Multiple byte data
   items are concatenations of bytes, from left to right, from top to
   bottom.  From the byte stream, a multi-byte item (a numeric in the
   example) is formed (using C notation) by:

        value = (byte[0] << 8*(n-1)) | (byte[1] << 8*(n-2)) | ...
        | byte[n-1];

   This byte ordering for multi-byte values is the commonplace network
   byte order or big-endian format.

4.2.  Miscellaneous

   Comments begin with "/*" and end with "*/".  Optional components are
   denoted by enclosing them in "[[ ]]" double brackets.  Single-byte
   entities containing uninterpreted data are of type opaque.

4.3.  Vectors

   A vector (single dimensioned array) is a stream of homogeneous data
   elements.  The size of the vector may be specified at documentation
   time or left unspecified until runtime.  In either case, the length
   declares the number of bytes, not the number of elements, in the
   vector.  The syntax for specifying a new type T' that is a fixed-
   length vector of type T is

        T T'[n];

   Here, T' occupies n bytes in the data stream, where n is a multiple
   of the size of T.  The length of the vector is not included in the
   encoded stream.

   In the following example, Datum is defined to be three consecutive
   bytes that the protocol does not interpret, while Data is three
   consecutive Datum, consuming a total of nine bytes.

        opaque Datum[3];      /* three uninterpreted bytes */
        Datum Data[9];        /* 3 consecutive 3 byte vectors */

Top      ToC       Page 8 
   Variable-length vectors are defined by specifying a subrange of legal
   lengths, inclusively, using the notation <floor..ceiling>.  When
   encoded, the actual length precedes the vector's contents in the byte
   stream.  The length will be in the form of a number consuming as many
   bytes as required to hold the vector's specified maximum (ceiling)
   length.  A variable-length vector with an actual length field of zero
   is referred to as an empty vector.

        T T'<floor..ceiling>;

   In the following example, mandatory is a vector that must contain
   between 300 and 400 bytes of type opaque.  It can never be empty.
   The actual length field consumes two bytes, a uint16, sufficient to
   represent the value 400 (see Section 4.4).  On the other hand, longer
   can represent up to 800 bytes of data, or 400 uint16 elements, and it
   may be empty.  Its encoding will include a two-byte actual length
   field prepended to the vector.

        opaque mandatory<300..400>;
              /* length field is 2 bytes, cannot be empty */
        uint16 longer<0..800>;
              /* zero to 400 16-bit unsigned integers */

4.4.  Numbers

   The basic numeric data type is an unsigned byte (uint8).  All larger
   numeric data types are formed from fixed-length series of bytes
   concatenated as described in Section 4.1 and are also unsigned.  The
   following numeric types are predefined.

        uint8 uint16[2];
        uint8 uint24[3];
        uint8 uint32[4];
        uint8 uint64[8];

4.5.  Enumerateds

   An additional sparse data type is available called enum.  A field of
   type enum can only assume the values declared in the definition.
   Each definition is a different type.  Only enumerateds of the same
   type may be assigned or compared.  Every element of an enumerated
   must be assigned a value, as demonstrated in the following example.
   Since the elements of the enumerated are not ordered, they can be
   assigned any unique value, in any order.

        enum { e1(v1), e2(v2), ... , en(vn), [[(n)]] } Te;

Top      ToC       Page 9 
   Enumerateds occupy as much space in the byte stream as would its
   maximal defined ordinal value.  The following definition would cause
   one byte to be used to carry fields of type Color.

        enum { red(3), blue(5), white(7) } Color;

   Optionally, one may specify a value without its associated tag to
   force the width definition without defining a superfluous element.
   In the following example, Taste will consume two bytes in the data
   stream but can only assume the values 1, 2, or 4.

        enum { sweet(1), sour(2), bitter(4), (32000) } Taste;

   The names of the elements of an enumeration are scoped within the
   defined type.  In the first example, a fully qualified reference to
   the second element of the enumeration would be Color.blue.  Such
   qualification is not required if the target of the assignment is well
   specified.

        Color color = Color.blue;     /* overspecified, legal */
        Color color = blue;           /* correct, type implicit */

   For enumerateds that are never converted to external representation,
   the numerical information may be omitted.

        enum { low, medium, high } Amount;

4.6.  Constructed Types

   Structure types may be constructed from primitive types for
   convenience.  Each specification declares a new, unique type.  The
   syntax for definition is much like that of C.

      struct {
          T1 f1;
          T2 f2;
          ...
          Tn fn;
      } [[T]];

   The fields within a structure may be qualified using the type's name
   using a syntax much like that available for enumerateds.  For
   example, T.f2 refers to the second field of the previous declaration.
   Structure definitions may be embedded.

Top      ToC       Page 10 
4.6.1.  Variants

   Defined structures may have variants based on some knowledge that is
   available within the environment.  The selector must be an enumerated
   type that defines the possible variants the structure defines.  There
   must be a case arm for every element of the enumeration declared in
   the select.  The body of the variant structure may be given a label
   for reference.  The mechanism by which the variant is selected at
   runtime is not prescribed by the presentation language.

        struct {
            T1 f1;
            T2 f2;
             ....
            Tn fn;
            select (E) {
                case e1: Te1;
                case e2: Te2;
                    ....
                case en: Ten;
            } [[fv]];
        } [[Tv]];

      For example,

        enum { apple, orange } VariantTag;
        struct {
            uint16 number;
            opaque string<0..10>; /* variable length */
        } V1;

        struct {
            uint32 number;
            opaque string[10];    /* fixed length */
        } V2;
        struct {
            select (VariantTag) { /* value of selector is implicit */
                case apple: V1;   /* VariantBody, tag = apple */
                case orange: V2;  /* VariantBody, tag = orange */
            } variant_body;       /* optional label on variant */
        } VariantRecord;

Top      ToC       Page 11 
   Variant structures may be qualified (narrowed) by specifying a value
   for the selector prior to the type.  For example, an

        orange VariantRecord

   is a narrowed type of a VariantRecord containing a variant_body of
   type V2.

4.7.  Cryptographic Attributes

   The four cryptographic operations digital signing, stream cipher
   encryption, block cipher encryption, and public key encryption are
   designated digitally-signed, stream-ciphered, block-ciphered, and
   public-key-encrypted, respectively.  A field's cryptographic
   processing is specified by prepending an appropriate key word
   designation before the field's type specification.  Cryptographic
   keys are implied by the current session state (see Section 5.1).

   In digital signing, one-way hash functions are used as input for a
   signing algorithm.  In RSA signing, a 36-byte structure of two hashes
   (one SHA and one MD5) is signed (encrypted with the private key).  In
   DSS, the 20 bytes of the SHA hash are run directly through the
   Digital Signature Algorithm with no additional hashing.

   In stream cipher encryption, the plaintext is exclusive-ORed with an
   identical amount of output generated from a cryptographically secure
   keyed pseudorandom number generator.

   In block cipher encryption, every block of plaintext encrypts to a
   block of ciphertext.  Because it is unlikely that the plaintext
   (whatever data is to be sent) will break neatly into the necessary
   block size (usually 64 bits), it is necessary to pad out the end of
   short blocks with some regular pattern, usually all zeroes.

   In public key encryption, one-way functions with secret "trapdoors"
   are used to encrypt the outgoing data.  Data encrypted with the
   public key of a given key pair can only be decrypted with the private
   key, and vice versa.  In the following example:

        stream-ciphered struct {
            uint8 field1;
            uint8 field2;
            digitally-signed opaque hash[20];
        } UserType;

   The contents of hash are used as input for the signing algorithm,
   then the entire structure is encrypted with a stream cipher.

Top      ToC       Page 12 
4.8.  Constants

   Typed constants can be defined for purposes of specification by
   declaring a symbol of the desired type and assigning values to it.
   Under-specified types (opaque, variable-length vectors, and
   structures that contain opaque) cannot be assigned values.  No fields
   of a multi-element structure or vector may be elided.

      For example,
        struct {
            uint8 f1;
            uint8 f2;
        } Example1;

        Example1 ex1 = {1, 4};/* assigns f1 = 1, f2 = 4 */



(page 12 continued on part 2)

Next RFC Part