Public API for Certificate Transparency

Reviewed-by: Ben Laurie <ben@openssl.org>
Reviewed-by: Rich Salz <rsalz@openssl.org>

9 files changed, 356 insertions, 179 deletions

diff --git a/crypto/ct/Makefile.in b/crypto/ct/Makefile.in
index 7e58c3b237..21ff2313ce 100644
--- a/crypto/ct/Makefile.in
+++ b/crypto/ct/Makefile.in
@@ -15,8 +15,8 @@ CFLAGS= $(INCLUDES) $(CFLAG) $(SHARED_CFLAG)
 GENERAL=Makefile
 
 LIB=$(TOP)/libcrypto.a
-LIBSRC= ct_lib.c ct_err.c ct_oct.c ct_prn.c
-LIBOBJ= ct_lib.o ct_err.o ct_oct.o ct_prn.o
+LIBSRC= ct_err.c ct_oct.c ct_prn.c ct_sct.c ct_x509v3.c
+LIBOBJ= ct_err.o ct_oct.o ct_prn.o ct_sct.o ct_x509v3.o
 
 SRC= $(LIBSRC)
 
@@ -27,8 +27,6 @@ ALL=    $(GENERAL) $(SRC) $(HEADER)
 top:
 	(cd ../..; $(MAKE) DIRS=crypto SDIRS=$(DIR) sub_all)
 
-test:
-
 all:	lib
 
 lib:	$(LIBOBJ)
@@ -39,9 +37,6 @@ lib:	$(LIBOBJ)
 files:
 	$(PERL) $(TOP)/util/files.pl Makefile >> $(TOP)/MINFO
 
-errors:
-	$(PERL) $(TOP)/util/mkerr.pl -conf ct.ec -hprefix internal/ -write *.c
-
 depend:
 	$(TOP)/util/domd $(CFLAG) $(INCLUDES) -- $(PROGS) $(LIBSRC)
 
diff --git a/crypto/ct/build.info b/crypto/ct/build.info
index 2007715004..b7766b6ed9 100644
--- a/crypto/ct/build.info
+++ b/crypto/ct/build.info
@@ -1,2 +1,2 @@
 LIBS=../../libcrypto
-SOURCE[../../libcrypto]= ct_lib.c ct_err.c ct_oct.c ct_prn.c
+SOURCE[../../libcrypto]= ct_err.c ct_oct.c ct_prn.c ct_sct.c ct_x509v3.c
diff --git a/crypto/ct/ct.ec b/crypto/ct/ct.ec
deleted file mode 100644
index 6f50f9abc4..0000000000
--- a/crypto/ct/ct.ec
+++ /dev/null
@@ -1,6 +0,0 @@
-# crypto/ct/ct.ec
-
-# configuration file for util/mkerr.pl
-
-# files that may have to be rewritten by util/mkerr.pl
-L CT	../../crypto/include/internal/ct_int.h		ct_err.c
diff --git a/crypto/ct/ct_err.c b/crypto/ct/ct_err.c
index b2ba432e24..033872e096 100644
--- a/crypto/ct/ct_err.c
+++ b/crypto/ct/ct_err.c
@@ -1,4 +1,3 @@
-/* ct_err.c */
 /* ====================================================================
  * Copyright (c) 1999-2016 The OpenSSL Project.  All rights reserved.
  *
@@ -61,7 +60,7 @@
 
 #include <stdio.h>
 #include <openssl/err.h>
-#include <internal/ct_int.h>
+#include <openssl/ct.h>
 
 /* BEGIN ERROR CODES */
 #ifndef OPENSSL_NO_ERR
diff --git a/crypto/ct/ct_locl.h b/crypto/ct/ct_locl.h
new file mode 100644
index 0000000000..9b76d16207
--- /dev/null
+++ b/crypto/ct/ct_locl.h
@@ -0,0 +1,110 @@
+/*
+ * Written by Rob Percival (robpercival@google.com) for the OpenSSL project.
+ */
+/* ====================================================================
+ * Copyright (c) 2016 The OpenSSL Project.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ *    software must display the following acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    licensing@OpenSSL.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ *    nor may "OpenSSL" appear in their names without prior written
+ *    permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ *    acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ====================================================================
+ */
+
+#ifdef OPENSSL_NO_CT
+# error CT is disabled.
+#endif
+
+#include <stddef.h>
+
+#include <openssl/ct.h>
+#include <openssl/evp.h>
+#include <openssl/x509.h>
+#include <openssl/safestack.h>
+
+/*
+ * From RFC6962: opaque SerializedSCT<1..2^16-1>; struct { SerializedSCT
+ * sct_list <1..2^16-1>; } SignedCertificateTimestampList;
+ */
+# define MAX_SCT_SIZE            65535
+# define MAX_SCT_LIST_SIZE       MAX_SCT_SIZE
+
+/* Signed Certificate Timestamp */
+struct sct_st {
+    sct_version_t version;
+    /* If version is not SCT_VERSION_V1, this contains the encoded SCT */
+    unsigned char *sct;
+    size_t sct_len;
+    /* If version is SCT_VERSION_V1, fields below contain components of the SCT */
+    unsigned char *log_id;
+    size_t log_id_len;
+    /*
+    * Note, we cannot distinguish between an unset timestamp, and one
+    * that is set to 0.  However since CT didn't exist in 1970, no real
+    * SCT should ever be set as such.
+    */
+    uint64_t timestamp;
+    unsigned char *ext;
+    size_t ext_len;
+    unsigned char hash_alg;
+    unsigned char sig_alg;
+    unsigned char *sig;
+    size_t sig_len;
+    /* Log entry type */
+    ct_log_entry_type_t entry_type;
+};
+
+/*
+ * Does this SCT have the minimum fields populated to be usuable?
+ * Returns 1 if so, 0 otherwise.
+ */
+int SCT_is_complete(const SCT *sct);
+
+/*
+ * Does this SCT have the signature-related fields populated?
+ * Returns 1 if so, 0 otherwise.
+ * This checks that the signature and hash algorithms are set to supported
+ * values and that the signature field is set.
+ */
+int SCT_signature_is_complete(const SCT *sct);
+
+
diff --git a/crypto/ct/ct_oct.c b/crypto/ct/ct_oct.c
index 8d075fcb88..6b6a6a7bc7 100644
--- a/crypto/ct/ct_oct.c
+++ b/crypto/ct/ct_oct.c
@@ -55,82 +55,44 @@
  * Hudson (tjh@cryptsoft.com).
  *
  */
- 
-#ifndef OPENSSL_NO_CT
-
-# include <limits.h>
-# include "internal/cryptlib.h"
-# include <openssl/asn1.h>
-# include <openssl/evp.h>
-# include <openssl/x509.h>
-# include <openssl/x509v3.h>
-# include "crypto/include/internal/ct_int.h"
-
-# define n2s(c,s)        ((s=(((unsigned int)((c)[0]))<< 8)| \
-                             (((unsigned int)((c)[1]))    )),c+=2)
-
-# define s2n(s,c)        ((c[0]=(unsigned char)(((s)>> 8)&0xff), \
-                           c[1]=(unsigned char)(((s)    )&0xff)),c+=2)
-
-# define n2l8(c,l)       (l =((uint64_t)(*((c)++)))<<56, \
-                          l|=((uint64_t)(*((c)++)))<<48, \
-                          l|=((uint64_t)(*((c)++)))<<40, \
-                          l|=((uint64_t)(*((c)++)))<<32, \
-                          l|=((uint64_t)(*((c)++)))<<24, \
-                          l|=((uint64_t)(*((c)++)))<<16, \
-                          l|=((uint64_t)(*((c)++)))<< 8, \
-                          l|=((uint64_t)(*((c)++))))
-
-# define l2n8(l,c)       (*((c)++)=(unsigned char)(((l)>>56)&0xff), \
-                          *((c)++)=(unsigned char)(((l)>>48)&0xff), \
-                          *((c)++)=(unsigned char)(((l)>>40)&0xff), \
-                          *((c)++)=(unsigned char)(((l)>>32)&0xff), \
-                          *((c)++)=(unsigned char)(((l)>>24)&0xff), \
-                          *((c)++)=(unsigned char)(((l)>>16)&0xff), \
-                          *((c)++)=(unsigned char)(((l)>> 8)&0xff), \
-                          *((c)++)=(unsigned char)(((l)    )&0xff))
-
-static STACK_OF(SCT) *d2i_SCT_LIST(STACK_OF(SCT) **a,
-                                   const unsigned char **pp, int len);
-static int i2d_SCT_LIST(STACK_OF(SCT) *a, unsigned char **pp);
-static int i2r_SCT_LIST(X509V3_EXT_METHOD *method, STACK_OF(SCT) *sct_list,
-                        BIO *out, int indent);
-
-static char *i2s_poison(const X509V3_EXT_METHOD *method, void *val)
-{
-    return OPENSSL_strdup("NULL");
-}
 
-const X509V3_EXT_METHOD v3_ct_scts[] = {
-    { NID_ct_precert_scts, 0, NULL,
-    0, (X509V3_EXT_FREE)SCT_LIST_free,
-    (X509V3_EXT_D2I)d2i_SCT_LIST, (X509V3_EXT_I2D)i2d_SCT_LIST,
-    0, 0, 0, 0,
-    (X509V3_EXT_I2R)i2r_SCT_LIST, 0,
-    NULL },
-
-    { NID_ct_precert_poison, 0, ASN1_ITEM_ref(ASN1_NULL),
-    0, 0, 0, 0, i2s_poison, 0,
-    0, 0, 0, 0, NULL },
-
-    { NID_ct_cert_scts, 0, NULL,
-    0, (X509V3_EXT_FREE)SCT_LIST_free,
-    (X509V3_EXT_D2I)d2i_SCT_LIST, (X509V3_EXT_I2D)i2d_SCT_LIST,
-    0, 0, 0, 0,
-    (X509V3_EXT_I2R)i2r_SCT_LIST, 0,
-    NULL },
-};
-
-int SCT_signature_is_valid(const SCT *sct)
-{
-    if (SCT_get_signature_nid(sct) == NID_undef ||
-        sct->sig_len == 0 || sct->sig == NULL) {
-        return 0;
-    }
+#ifdef OPENSSL_NO_CT
+# error "CT is disabled"
+#endif
 
-    return 1;
-}
+#include <limits.h>
+#include <string.h>
+
+#include <openssl/asn1.h>
+#include <openssl/buffer.h>
+#include <openssl/ct.h>
+#include <openssl/err.h>
+
+#include "ct_locl.h"
+
+#define n2s(c,s)        ((s=(((unsigned int)((c)[0]))<< 8)| \
+                            (((unsigned int)((c)[1]))    )),c+=2)
+
+#define s2n(s,c)        ((c[0]=(unsigned char)(((s)>> 8)&0xff), \
+                          c[1]=(unsigned char)(((s)    )&0xff)),c+=2)
 
+#define n2l8(c,l)       (l =((uint64_t)(*((c)++)))<<56, \
+                         l|=((uint64_t)(*((c)++)))<<48, \
+                         l|=((uint64_t)(*((c)++)))<<40, \
+                         l|=((uint64_t)(*((c)++)))<<32, \
+                         l|=((uint64_t)(*((c)++)))<<24, \
+                         l|=((uint64_t)(*((c)++)))<<16, \
+                         l|=((uint64_t)(*((c)++)))<< 8, \
+                         l|=((uint64_t)(*((c)++))))
+
+#define l2n8(l,c)       (*((c)++)=(unsigned char)(((l)>>56)&0xff), \
+                         *((c)++)=(unsigned char)(((l)>>48)&0xff), \
+                         *((c)++)=(unsigned char)(((l)>>40)&0xff), \
+                         *((c)++)=(unsigned char)(((l)>>32)&0xff), \
+                         *((c)++)=(unsigned char)(((l)>>24)&0xff), \
+                         *((c)++)=(unsigned char)(((l)>>16)&0xff), \
+                         *((c)++)=(unsigned char)(((l)>> 8)&0xff), \
+                         *((c)++)=(unsigned char)(((l)    )&0xff))
 
 int o2i_SCT_signature(SCT *sct, const unsigned char **in, size_t len)
 {
@@ -138,7 +100,7 @@ int o2i_SCT_signature(SCT *sct, const unsigned char **in, size_t len)
     size_t len_remaining = len;
     const unsigned char *p = *in;
 
-    if (sct->version != SCT_V1) {
+    if (sct->version != SCT_VERSION_V1) {
         CTerr(CT_F_O2I_SCT_SIGNATURE, CT_R_UNSUPPORTED_VERSION);
         return -1;
     }
@@ -193,7 +155,7 @@ SCT *o2i_SCT(SCT **psct, const unsigned char **in, size_t len)
     p = *in;
 
     sct->version = *p;
-    if (sct->version == SCT_V1) {
+    if (sct->version == SCT_VERSION_V1) {
         int sig_len;
         size_t len2;
         /*
@@ -207,11 +169,11 @@ SCT *o2i_SCT(SCT **psct, const unsigned char **in, size_t len)
         }
         len -= 43;
         p++;
-        sct->log_id = BUF_memdup(p, SCT_V1_HASHLEN);
+        sct->log_id = BUF_memdup(p, CT_V1_HASHLEN);
         if (sct->log_id == NULL)
             goto err;
-        sct->log_id_len = SCT_V1_HASHLEN;
-        p += SCT_V1_HASHLEN;
+        sct->log_id_len = CT_V1_HASHLEN;
+        p += CT_V1_HASHLEN;
 
         n2l8(p, sct->timestamp);
 
@@ -261,12 +223,12 @@ int i2o_SCT_signature(const SCT *sct, unsigned char **out)
     size_t len;
     unsigned char *p = NULL;
 
-    if (!SCT_signature_is_valid(sct)) {
+    if (!SCT_signature_is_complete(sct)) {
         CTerr(CT_F_I2O_SCT_SIGNATURE, CT_R_SCT_INVALID_SIGNATURE);
         goto err;
     }
 
-    if (sct->version != SCT_V1) {
+    if (sct->version != SCT_VERSION_V1) {
         CTerr(CT_F_I2O_SCT_SIGNATURE, CT_R_UNSUPPORTED_VERSION);
         goto err;
     }
@@ -308,7 +270,7 @@ int i2o_SCT(const SCT *sct, unsigned char **out)
     size_t len;
     unsigned char *p = NULL;
 
-    if (!SCT_is_valid(sct)) {
+    if (!SCT_is_complete(sct)) {
         CTerr(CT_F_I2O_SCT, CT_R_SCT_NOT_SET);
         goto err;
     }
@@ -318,7 +280,7 @@ int i2o_SCT(const SCT *sct, unsigned char **out)
      * extensions; (1 byte) Hash algorithm (1 byte) Signature algorithm (2
      * bytes + ?) Signature
      */
-    if (sct->version == SCT_V1)
+    if (sct->version == SCT_VERSION_V1)
         len = 43 + sct->ext_len + 4 + sct->sig_len;
     else
         len = sct->sct_len;
@@ -338,10 +300,10 @@ int i2o_SCT(const SCT *sct, unsigned char **out)
         *out = p;
     }
 
-    if (sct->version == SCT_V1) {
+    if (sct->version == SCT_VERSION_V1) {
         *p++ = sct->version;
-        memcpy(p, sct->log_id, SCT_V1_HASHLEN);
-        p += SCT_V1_HASHLEN;
+        memcpy(p, sct->log_id, CT_V1_HASHLEN);
+        p += CT_V1_HASHLEN;
         l2n8(sct->timestamp, p);
         s2n(sct->ext_len, p);
         if (sct->ext_len > 0) {
@@ -429,7 +391,7 @@ STACK_OF(SCT) *o2i_SCT_LIST(STACK_OF(SCT) **a, const unsigned char **pp,
     return NULL;
 }
 
-int i2o_SCT_LIST(STACK_OF(SCT) *a, unsigned char **pp)
+int i2o_SCT_LIST(const STACK_OF(SCT) *a, unsigned char **pp)
 {
     int len, sct_len, i, is_pp_new = 0;
     size_t len2;
@@ -484,8 +446,8 @@ int i2o_SCT_LIST(STACK_OF(SCT) *a, unsigned char **pp)
     return -1;
 }
 
-static STACK_OF(SCT) *d2i_SCT_LIST(STACK_OF(SCT) **a,
-                                   const unsigned char **pp, int len)
+STACK_OF(SCT) *d2i_SCT_LIST(STACK_OF(SCT) **a, const unsigned char **pp,
+                            long len)
 {
     ASN1_OCTET_STRING *oct = NULL;
     STACK_OF(SCT) *sk = NULL;
@@ -503,7 +465,7 @@ static STACK_OF(SCT) *d2i_SCT_LIST(STACK_OF(SCT) **a,
     return sk;
 }
 
-static int i2d_SCT_LIST(STACK_OF(SCT) *a, unsigned char **out)
+int i2d_SCT_LIST(STACK_OF(SCT) *a, unsigned char **out)
 {
     ASN1_OCTET_STRING oct;
     int len;
@@ -516,20 +478,3 @@ static int i2d_SCT_LIST(STACK_OF(SCT) *a, unsigned char **out)
     OPENSSL_free(oct.data);
     return len;
 }
-
-static int i2r_SCT_LIST(X509V3_EXT_METHOD *method, STACK_OF(SCT) *sct_list,
-                        BIO *out, int indent)
-{
-    int i;
-
-    for (i = 0; i < sk_SCT_num(sct_list); ++i) {
-        SCT *sct = sk_SCT_value(sct_list, i);
-        SCT_print(sct, out, indent);
-        if (i < sk_SCT_num(sct_list) - 1)
-            BIO_printf(out, "\n");
-    }
-
-    return 1;
-}
-
-#endif
diff --git a/crypto/ct/ct_prn.c b/crypto/ct/ct_prn.c
index 91325537dd..73aba7e578 100644
--- a/crypto/ct/ct_prn.c
+++ b/crypto/ct/ct_prn.c
@@ -56,17 +56,16 @@
  *
  */
 
-#ifndef OPENSSL_NO_CT
+#ifdef OPENSSL_NO_CT
+# error "CT is disabled"
+#endif
+
+#include <openssl/asn1.h>
+#include <openssl/bio.h>
 
-# include <limits.h>
-# include "internal/cryptlib.h"
-# include <openssl/asn1.h>
-# include <openssl/evp.h>
-# include <openssl/x509.h>
-# include <openssl/x509v3.h>
-# include "crypto/include/internal/ct_int.h"
+#include "ct_locl.h"
 
-static void sct_sigalg_print(BIO *out, const SCT *sct)
+static void SCT_signature_algorithms_print(const SCT *sct, BIO *out)
 {
     int nid = SCT_get_signature_nid(sct);
 
@@ -76,7 +75,7 @@ static void sct_sigalg_print(BIO *out, const SCT *sct)
         BIO_printf(out, "%s", OBJ_nid2ln(nid));
 }
 
-static void timestamp_print(BIO *out, uint64_t timestamp)
+static void timestamp_print(uint64_t timestamp, BIO *out)
 {
     ASN1_GENERALIZEDTIME *gen = ASN1_GENERALIZEDTIME_new();
     char genstr[20];
@@ -95,12 +94,12 @@ static void timestamp_print(BIO *out, uint64_t timestamp)
     ASN1_GENERALIZEDTIME_free(gen);
 }
 
-void SCT_print(SCT *sct, BIO *out, int indent)
+void SCT_print(const SCT *sct, BIO *out, int indent)
 {
     BIO_printf(out, "%*sSigned Certificate Timestamp:", indent, "");
     BIO_printf(out, "\n%*sVersion   : ", indent + 4, "");
 
-    if (sct->version != SCT_V1) {
+    if (sct->version != SCT_VERSION_V1) {
         BIO_printf(out, "unknown\n%*s", indent + 16, "");
         BIO_hex_string(out, indent + 16, 16, sct->sct, sct->sct_len);
         return;
@@ -112,7 +111,7 @@ void SCT_print(SCT *sct, BIO *out, int indent)
     BIO_hex_string(out, indent + 16, 16, sct->log_id, sct->log_id_len);
 
     BIO_printf(out, "\n%*sTimestamp : ", indent + 4, "");
-    timestamp_print(out, sct->timestamp);
+    timestamp_print(sct->timestamp, out);
 
     BIO_printf(out, "\n%*sExtensions: ", indent + 4, "");
     if (sct->ext_len == 0)
@@ -121,9 +120,20 @@ void SCT_print(SCT *sct, BIO *out, int indent)
         BIO_hex_string(out, indent + 16, 16, sct->ext, sct->ext_len);
 
     BIO_printf(out, "\n%*sSignature : ", indent + 4, "");
-    sct_sigalg_print(out, sct);
+    SCT_signature_algorithms_print(sct, out);
     BIO_printf(out, "\n%*s            ", indent + 4, "");
     BIO_hex_string(out, indent + 16, 16, sct->sig, sct->sig_len);
 }
 
-#endif
+void SCT_LIST_print(const STACK_OF(SCT) *sct_list, BIO *out, int indent,
+                    const char *separator)
+{
+    int i;
+
+    for (i = 0; i < sk_SCT_num(sct_list); ++i) {
+        SCT *sct = sk_SCT_value(sct_list, i);
+        SCT_print(sct, out, indent);
+        if (i < sk_SCT_num(sct_list) - 1)
+            BIO_printf(out, "%s", separator);
+    }
+}
diff --git a/crypto/ct/ct_lib.c b/crypto/ct/ct_sct.c
index 81676e306f..81e51f0f61 100644
--- a/crypto/ct/ct_lib.c
+++ b/crypto/ct/ct_sct.c
@@ -1,6 +1,6 @@
 /*
- * Written by Rob Stradling (rob@comodo.com) and Stephen Henson
- * (steve@openssl.org) for the OpenSSL project 2014.
+ * Written by Rob Stradling (rob@comodo.com), Stephen Henson (steve@openssl.org)
+ * and Adam Eijdenberg (adam.eijdenberg@gmail.com) for the OpenSSL project 2016.
  */
 /* ====================================================================
  * Copyright (c) 2014 The OpenSSL Project.  All rights reserved.
@@ -56,39 +56,47 @@
  *
  */
 
-#ifndef OPENSSL_NO_CT
+#ifdef OPENSSL_NO_CT
+# error "CT disabled"
+#endif
+
+#include <openssl/ct.h>
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <openssl/tls1.h>
+#include <openssl/x509.h>
 
-# include <limits.h>
-# include "internal/cryptlib.h"
-# include "../../ssl/ssl_locl.h"
-# include "internal/ct_int.h"
+#include "ct_locl.h"
 
 SCT *SCT_new(void)
 {
     SCT *sct = OPENSSL_zalloc(sizeof(SCT));
+
     if (sct == NULL) {
         CTerr(CT_F_SCT_NEW, ERR_R_MALLOC_FAILURE);
         return NULL;
     }
-    sct->entry_type = UNSET_ENTRY;
-    sct->version = UNSET_VERSION;
+
+    sct->entry_type = CT_LOG_ENTRY_TYPE_NOT_SET;
+    sct->version = SCT_VERSION_NOT_SET;
     return sct;
 }
 
 void SCT_free(SCT *sct)
 {
-    if (sct != NULL) {
-        OPENSSL_free(sct->log_id);
-        OPENSSL_free(sct->ext);
-        OPENSSL_free(sct->sig);
-        OPENSSL_free(sct->sct);
-        OPENSSL_free(sct);
-    }
+    if (sct == NULL)
+        return;
+
+    OPENSSL_free(sct->log_id);
+    OPENSSL_free(sct->ext);
+    OPENSSL_free(sct->sig);
+    OPENSSL_free(sct->sct);
+    OPENSSL_free(sct);
 }
 
 int SCT_set_version(SCT *sct, sct_version_t version)
 {
-    if (version != SCT_V1) {
+    if (version != SCT_VERSION_V1) {
         CTerr(CT_F_SCT_SET_VERSION, CT_R_UNSUPPORTED_VERSION);
         return 0;
     }
@@ -96,23 +104,26 @@ int SCT_set_version(SCT *sct, sct_version_t version)
     return 1;
 }
 
-int SCT_set_log_entry_type(SCT *sct, log_entry_type_t entry_type)
+int SCT_set_log_entry_type(SCT *sct, ct_log_entry_type_t entry_type)
 {
-    if (entry_type != X509_ENTRY && entry_type != PRECERT_ENTRY) {
+    switch (entry_type) {
+    case CT_LOG_ENTRY_TYPE_X509:
+    case CT_LOG_ENTRY_TYPE_PRECERT:
+        sct->entry_type = entry_type;
+        return 1;
+    default:
         CTerr(CT_F_SCT_SET_LOG_ENTRY_TYPE, CT_R_UNSUPPORTED_ENTRY_TYPE);
         return 0;
     }
-    sct->entry_type = entry_type;
-    return 1;
 }
 
 int SCT_set0_log_id(SCT *sct, unsigned char *log_id, size_t log_id_len)
 {
-    /* Currently only SHA-256 allowed so length must be SCT_V1_HASHLEN */
-    if (log_id_len != SCT_V1_HASHLEN) {
+    if (sct->version == SCT_VERSION_V1 && log_id_len != CT_V1_HASHLEN) {
         CTerr(CT_F_SCT_SET0_LOG_ID, CT_R_INVALID_LOG_ID_LENGTH);
         return 0;
     }
+
     OPENSSL_free(sct->log_id);
     sct->log_id = log_id;
     sct->log_id_len = log_id_len;
@@ -121,25 +132,23 @@ int SCT_set0_log_id(SCT *sct, unsigned char *log_id, size_t log_id_len)
 
 int SCT_set1_log_id(SCT *sct, const unsigned char *log_id, size_t log_id_len)
 {
-    /* Currently only SHA-256 allowed so length must be SCT_V1_HASHLEN */
-    if (log_id_len != SCT_V1_HASHLEN) {
+    if (sct->version == SCT_VERSION_V1 && log_id_len != CT_V1_HASHLEN) {
         CTerr(CT_F_SCT_SET1_LOG_ID, CT_R_INVALID_LOG_ID_LENGTH);
         return 0;
     }
 
     OPENSSL_free(sct->log_id);
-    if (log_id == NULL || log_id_len == 0) {
-        sct->log_id = NULL;
-    } else {
-        sct->log_id = OPENSSL_memdup(log_id, log_id_len);
+    sct->log_id = NULL;
+    sct->log_id_len = 0;
 
+    if (log_id != NULL && log_id_len > 0) {
+        sct->log_id = OPENSSL_memdup(log_id, log_id_len);
         if (sct->log_id == NULL) {
             CTerr(CT_F_SCT_SET1_LOG_ID, ERR_R_MALLOC_FAILURE);
             return 0;
         }
+        sct->log_id_len = log_id_len;
     }
-
-    sct->log_id_len = log_id_len;
     return 1;
 }
 
@@ -200,16 +209,17 @@ void SCT_set0_signature(SCT *sct, unsigned char *sig, size_t sig_len)
 int SCT_set1_signature(SCT *sct, const unsigned char *sig, size_t sig_len)
 {
     OPENSSL_free(sct->sig);
-    if (sig == NULL || sig_len == 0) {
-        sct->sig = NULL;
-    } else {
+    sct->sig = NULL;
+    sct->sig_len = 0;
+
+    if (sig != NULL && sig_len > 0) {
         sct->sig = OPENSSL_memdup(sig, sig_len);
         if (sct->sig == NULL) {
             CTerr(CT_F_SCT_SET1_SIGNATURE, ERR_R_MALLOC_FAILURE);
             return 0;
         }
+        sct->sig_len = sig_len;
     }
-    sct->sig_len = sig_len;
     return 1;
 }
 
@@ -218,7 +228,7 @@ sct_version_t SCT_get_version(const SCT *sct)
     return sct->version;
 }
 
-log_entry_type_t SCT_get_log_entry_type(const SCT *sct)
+ct_log_entry_type_t SCT_get_log_entry_type(const SCT *sct)
 {
     return sct->entry_type;
 }
@@ -236,7 +246,7 @@ uint64_t SCT_get_timestamp(const SCT *sct)
 
 int SCT_get_signature_nid(const SCT *sct)
 {
-    if (sct->version == SCT_V1) {
+    if (sct->version == SCT_VERSION_V1) {
         if (sct->hash_alg == TLSEXT_hash_sha256) {
             switch (sct->sig_alg) {
             case TLSEXT_signature_ecdsa:
@@ -263,16 +273,21 @@ size_t SCT_get0_signature(const SCT *sct, unsigned char **sig)
     return sct->sig_len;
 }
 
-int SCT_is_valid(const SCT *sct)
+int SCT_is_complete(const SCT *sct)
 {
     switch (sct->version) {
-    case UNSET_VERSION:
+    case SCT_VERSION_NOT_SET:
         return 0;
-    case SCT_V1:
-        return sct->log_id != NULL && SCT_signature_is_valid(sct);
+    case SCT_VERSION_V1:
+        return sct->log_id != NULL && SCT_signature_is_complete(sct);
     default:
         return sct->sct != NULL; /* Just need cached encoding */
     }
 }
 
-#endif
+int SCT_signature_is_complete(const SCT *sct)
+{
+    return SCT_get_signature_nid(sct) != NID_undef &&
+        sct->sig != NULL && sct->sig_len > 0;
+}
+
diff --git a/crypto/ct/ct_x509v3.c b/crypto/ct/ct_x509v3.c
new file mode 100644
index 0000000000..2617f13d28
--- /dev/null
+++ b/crypto/ct/ct_x509v3.c
@@ -0,0 +1,109 @@
+/*
+ * Written by Rob Stradling (rob@comodo.com) and Stephen Henson
+ * (steve@openssl.org) for the OpenSSL project 2014.
+ */
+/* ====================================================================
+ * Copyright (c) 2014 The OpenSSL Project.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ *    software must display the following acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    licensing@OpenSSL.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ *    nor may "OpenSSL" appear in their names without prior written
+ *    permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ *    acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This product includes cryptographic software written by Eric Young
+ * (eay@cryptsoft.com).  This product includes software written by Tim
+ * Hudson (tjh@cryptsoft.com).
+ *
+ */
+
+#ifdef OPENSSL_NO_CT
+# error "CT is disabled"
+#endif
+
+#include <openssl/bio.h>
+#include <openssl/ct.h>
+#include <openssl/obj_mac.h>
+#include <openssl/x509v3.h>
+
+#include "internal/ct_int.h"
+
+static char *i2s_poison(const X509V3_EXT_METHOD *method, void *val)
+{
+    return OPENSSL_strdup("NULL");
+}
+
+static int i2r_SCT_LIST(X509V3_EXT_METHOD *method, STACK_OF(SCT) *sct_list,
+                 BIO *out, int indent)
+{
+    SCT_LIST_print(sct_list, out, indent, "\n");
+    return 1;
+}
+
+/* Handlers for X509v3/OCSP Certificate Transparency extensions */
+const X509V3_EXT_METHOD v3_ct_scts[] = {
+    /* X509v3 extension in certificates that contains SCTs */
+    { NID_ct_precert_scts, 0, NULL,
+    NULL, (X509V3_EXT_FREE)SCT_LIST_free,
+    (X509V3_EXT_D2I)d2i_SCT_LIST, (X509V3_EXT_I2D)i2d_SCT_LIST,
+    NULL, NULL,
+    NULL, NULL,
+    (X509V3_EXT_I2R)i2r_SCT_LIST, NULL,
+    NULL },
+
+    /* X509v3 extension to mark a certificate as a pre-certificate */
+    { NID_ct_precert_poison, 0, ASN1_ITEM_ref(ASN1_NULL),
+    NULL, NULL, NULL, NULL,
+    i2s_poison, NULL,
+    NULL, NULL,
+    NULL, NULL,
+    NULL },
+
+    /* OCSP extension that contains SCTs */
+    { NID_ct_cert_scts, 0, NULL,
+    0, (X509V3_EXT_FREE)SCT_LIST_free,
+    (X509V3_EXT_D2I)d2i_SCT_LIST, (X509V3_EXT_I2D)i2d_SCT_LIST,
+    NULL, NULL,
+    NULL, NULL,
+    (X509V3_EXT_I2R)i2r_SCT_LIST, NULL,
+    NULL },
+};