Commit eef977aa authored by Matt Caswell's avatar Matt Caswell
Browse files

Integrate BoringSSL shim 



The BoringSSL test suite contains numerous tests which OpenSSL does not.

The BoringSSL test runner uses a shim to launch the library and execute the
tests. This is a version of the BoringSSL shim converted to compile against
OpenSSL instead.

This is primarily based on the work of David Benjamin from the BoringSSL
project who did most of the necessary conversion. It also includes a few
other tweaks for opacity changes etc.

This is based on a *very* old version of BoringSSL from commit f277add6c.
That was the last commit known to work with this patched shim. Later
versions may also work but lots of merge conflicts occur when trying to
bring it up to date.

At the moment this has not been integrated into the build system. There is
a very simple standalone makefile in the ossl_shim directory which should
be executed directly before tyring to use the shim.

Reviewed-by: default avatarRichard Levitte <levitte@openssl.org>
parent 62dd3351

test/ossl_shim/Makefile

0 → 100644
+9 −0
Original line number Diff line number Diff line 
all: ossl_shim



ossl_shim: ../../libssl.a ../../libcrypto.a *.cc

	g++ -g -std=c++11 -I. -I../../include *.cc \

	../../libssl.a ../../libcrypto.a -ldl -lpthread \

	-o ossl_shim



clean:

	rm ossl_shim

test/ossl_shim/async_bio.cc

0 → 100644
+196 −0
Original line number Diff line number Diff line 
/* Copyright (c) 2014, Google Inc.

 *

 * Permission to use, copy, modify, and/or distribute this software for any

 * purpose with or without fee is hereby granted, provided that the above

 * copyright notice and this permission notice appear in all copies.

 *

 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES

 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY

 * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION

 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN

 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */



#include "async_bio.h"



#include <errno.h>

#include <string.h>



#include <openssl/crypto.h>





namespace {



struct AsyncBio {

  bool datagram;

  bool enforce_write_quota;

  size_t read_quota;

  size_t write_quota;

};



AsyncBio *GetData(BIO *bio) {

  /*

   * TODO: Missing accessor? This probably needs a BIO_get_method() in OpenSSL

   *       For now skip this check

   */

#if 0

  if (bio->method != &g_async_bio_method) {

    return NULL;

  }

#endif

  return (AsyncBio *)BIO_get_data(bio);

}



static int AsyncWrite(BIO *bio, const char *in, int inl) {

  AsyncBio *a = GetData(bio);

  if (a == NULL || BIO_next(bio) == NULL) {

    return 0;

  }



  if (!a->enforce_write_quota) {

    return BIO_write(BIO_next(bio), in, inl);

  }



  BIO_clear_retry_flags(bio);



  if (a->write_quota == 0) {

    BIO_set_retry_write(bio);

    errno = EAGAIN;

    return -1;

  }



  if (!a->datagram && (size_t)inl > a->write_quota) {

    inl = a->write_quota;

  }

  int ret = BIO_write(BIO_next(bio), in, inl);

  if (ret <= 0) {

    BIO_copy_next_retry(bio);

  } else {

    a->write_quota -= (a->datagram ? 1 : ret);

  }

  return ret;

}



static int AsyncRead(BIO *bio, char *out, int outl) {

  AsyncBio *a = GetData(bio);

  if (a == NULL || BIO_next(bio) == NULL) {

    return 0;

  }



  BIO_clear_retry_flags(bio);



  if (a->read_quota == 0) {

    BIO_set_retry_read(bio);

    errno = EAGAIN;

    return -1;

  }



  if (!a->datagram && (size_t)outl > a->read_quota) {

    outl = a->read_quota;

  }

  int ret = BIO_read(BIO_next(bio), out, outl);

  if (ret <= 0) {

    BIO_copy_next_retry(bio);

  } else {

    a->read_quota -= (a->datagram ? 1 : ret);

  }

  return ret;

}



static long AsyncCtrl(BIO *bio, int cmd, long num, void *ptr) {

  if (BIO_next(bio) == NULL) {

    return 0;

  }

  BIO_clear_retry_flags(bio);

  int ret = BIO_ctrl(BIO_next(bio), cmd, num, ptr);

  BIO_copy_next_retry(bio);

  return ret;

}



static int AsyncNew(BIO *bio) {

  AsyncBio *a = (AsyncBio *)OPENSSL_malloc(sizeof(*a));

  if (a == NULL) {

    return 0;

  }

  memset(a, 0, sizeof(*a));

  a->enforce_write_quota = true;

  BIO_set_init(bio, 1);

  BIO_set_data(bio, a);

  return 1;

}



static int AsyncFree(BIO *bio) {

  if (bio == NULL) {

    return 0;

  }



  OPENSSL_free(BIO_get_data(bio));

  BIO_set_data(bio, NULL);

  BIO_set_init(bio, 0);

  return 1;

}



static long AsyncCallbackCtrl(BIO *bio, int cmd, bio_info_cb fp) {

  if (BIO_next(bio) == NULL) {

    return 0;

  }

  return BIO_callback_ctrl(BIO_next(bio), cmd, fp);

}



static BIO_METHOD *g_async_bio_method = NULL;



static const BIO_METHOD *AsyncMethod(void)

{

  if (g_async_bio_method == NULL) {

    g_async_bio_method = BIO_meth_new(BIO_TYPE_FILTER, "async bio");

    if (   g_async_bio_method == NULL

        || !BIO_meth_set_write(g_async_bio_method, AsyncWrite)

        || !BIO_meth_set_read(g_async_bio_method, AsyncRead)

        || !BIO_meth_set_ctrl(g_async_bio_method, AsyncCtrl)

        || !BIO_meth_set_create(g_async_bio_method, AsyncNew)

        || !BIO_meth_set_destroy(g_async_bio_method, AsyncFree)

        || !BIO_meth_set_callback_ctrl(g_async_bio_method, AsyncCallbackCtrl))

    return NULL;

  }

  return g_async_bio_method;

}



}  // namespace



ScopedBIO AsyncBioCreate() {

  return ScopedBIO(BIO_new(AsyncMethod()));

}



ScopedBIO AsyncBioCreateDatagram() {

  ScopedBIO ret(BIO_new(AsyncMethod()));

  if (!ret) {

    return nullptr;

  }

  GetData(ret.get())->datagram = true;

  return ret;

}



void AsyncBioAllowRead(BIO *bio, size_t count) {

  AsyncBio *a = GetData(bio);

  if (a == NULL) {

    return;

  }

  a->read_quota += count;

}



void AsyncBioAllowWrite(BIO *bio, size_t count) {

  AsyncBio *a = GetData(bio);

  if (a == NULL) {

    return;

  }

  a->write_quota += count;

}



void AsyncBioEnforceWriteQuota(BIO *bio, bool enforce) {

  AsyncBio *a = GetData(bio);

  if (a == NULL) {

    return;

  }

  a->enforce_write_quota = enforce;

}

test/ossl_shim/async_bio.h

0 → 100644
+45 −0
Original line number Diff line number Diff line 
/* Copyright (c) 2014, Google Inc.

 *

 * Permission to use, copy, modify, and/or distribute this software for any

 * purpose with or without fee is hereby granted, provided that the above

 * copyright notice and this permission notice appear in all copies.

 *

 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES

 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY

 * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION

 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN

 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */



#ifndef HEADER_ASYNC_BIO

#define HEADER_ASYNC_BIO



#include <openssl/bio.h>



#include "crypto/scoped_types.h"





// AsyncBioCreate creates a filter BIO for testing asynchronous state

// machines which consume a stream socket. Reads and writes will fail

// and return EAGAIN unless explicitly allowed. Each async BIO has a

// read quota and a write quota. Initially both are zero. As each is

// incremented, bytes are allowed to flow through the BIO.

ScopedBIO AsyncBioCreate();



// AsyncBioCreateDatagram creates a filter BIO for testing for

// asynchronous state machines which consume datagram sockets. The read

// and write quota count in packets rather than bytes.

ScopedBIO AsyncBioCreateDatagram();



// AsyncBioAllowRead increments |bio|'s read quota by |count|.

void AsyncBioAllowRead(BIO *bio, size_t count);



// AsyncBioAllowWrite increments |bio|'s write quota by |count|.

void AsyncBioAllowWrite(BIO *bio, size_t count);



// AsyncBioEnforceWriteQuota configures where |bio| enforces its write quota.

void AsyncBioEnforceWriteQuota(BIO *bio, bool enforce);





#endif  // HEADER_ASYNC_BIO

test/ossl_shim/crypto/scoped_types.h

0 → 100644
+102 −0
Original line number Diff line number Diff line 
/* Copyright (c) 2015, Google Inc.

 *

 * Permission to use, copy, modify, and/or distribute this software for any

 * purpose with or without fee is hereby granted, provided that the above

 * copyright notice and this permission notice appear in all copies.

 *

 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES

 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY

 * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION

 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN

 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */



#ifndef OPENSSL_HEADER_CRYPTO_TEST_SCOPED_TYPES_H

#define OPENSSL_HEADER_CRYPTO_TEST_SCOPED_TYPES_H



#include <stdint.h>

#include <stdio.h>



#include <memory>



#include <openssl/asn1.h>

#include <openssl/bio.h>

#include <openssl/bn.h>

#include <openssl/crypto.h>

#include <openssl/cmac.h>

#include <openssl/dh.h>

#include <openssl/ecdsa.h>

#include <openssl/ec.h>

#include <openssl/evp.h>

#include <openssl/pkcs12.h>

#include <openssl/rsa.h>

#include <openssl/stack.h>

#include <openssl/x509.h>





template<typename T, void (*func)(T*)>

struct OpenSSLDeleter {

  void operator()(T *obj) {

    func(obj);

  }

};



template<typename StackType, typename T, void (*func)(T*)>

struct OpenSSLStackDeleter {

  void operator()(StackType *obj) {

    sk_pop_free(reinterpret_cast<_STACK*>(obj),

                reinterpret_cast<void (*)(void *)>(func));

  }

};



template<typename T>

struct OpenSSLFree {

  void operator()(T *buf) {

    OPENSSL_free(buf);

  }

};



struct FileCloser {

  void operator()(FILE *file) {

    fclose(file);

  }

};



template<typename T, void (*func)(T*)>

using ScopedOpenSSLType = std::unique_ptr<T, OpenSSLDeleter<T, func>>;



template<typename StackType, typename T, void (*func)(T*)>

using ScopedOpenSSLStack =

    std::unique_ptr<StackType, OpenSSLStackDeleter<StackType, T, func>>;



using ScopedASN1_TYPE = ScopedOpenSSLType<ASN1_TYPE, ASN1_TYPE_free>;

using ScopedBIO = ScopedOpenSSLType<BIO, BIO_vfree>;

using ScopedBIGNUM = ScopedOpenSSLType<BIGNUM, BN_free>;

using ScopedBN_CTX = ScopedOpenSSLType<BN_CTX, BN_CTX_free>;

using ScopedBN_MONT_CTX = ScopedOpenSSLType<BN_MONT_CTX, BN_MONT_CTX_free>;

using ScopedCMAC_CTX = ScopedOpenSSLType<CMAC_CTX, CMAC_CTX_free>;

using ScopedDH = ScopedOpenSSLType<DH, DH_free>;

using ScopedECDSA_SIG = ScopedOpenSSLType<ECDSA_SIG, ECDSA_SIG_free>;

using ScopedEC_GROUP = ScopedOpenSSLType<EC_GROUP, EC_GROUP_free>;

using ScopedEC_KEY = ScopedOpenSSLType<EC_KEY, EC_KEY_free>;

using ScopedEC_POINT = ScopedOpenSSLType<EC_POINT, EC_POINT_free>;

using ScopedEVP_PKEY = ScopedOpenSSLType<EVP_PKEY, EVP_PKEY_free>;

using ScopedEVP_PKEY_CTX = ScopedOpenSSLType<EVP_PKEY_CTX, EVP_PKEY_CTX_free>;

using ScopedPKCS8_PRIV_KEY_INFO = ScopedOpenSSLType<PKCS8_PRIV_KEY_INFO,

                                                    PKCS8_PRIV_KEY_INFO_free>;

using ScopedPKCS12 = ScopedOpenSSLType<PKCS12, PKCS12_free>;

using ScopedRSA = ScopedOpenSSLType<RSA, RSA_free>;

using ScopedX509 = ScopedOpenSSLType<X509, X509_free>;

using ScopedX509_ALGOR = ScopedOpenSSLType<X509_ALGOR, X509_ALGOR_free>;

using ScopedX509_SIG = ScopedOpenSSLType<X509_SIG, X509_SIG_free>;

using ScopedX509_STORE_CTX = ScopedOpenSSLType<X509_STORE_CTX, X509_STORE_CTX_free>;



using ScopedX509Stack = ScopedOpenSSLStack<STACK_OF(X509), X509, X509_free>;



using ScopedOpenSSLBytes = std::unique_ptr<uint8_t, OpenSSLFree<uint8_t>>;

using ScopedOpenSSLString = std::unique_ptr<char, OpenSSLFree<char>>;



using ScopedFILE = std::unique_ptr<FILE, FileCloser>;



#endif  // OPENSSL_HEADER_CRYPTO_TEST_SCOPED_TYPES_H

test/ossl_shim/ossl_shim.cc

0 → 100644
+1237 −0

File added.

Preview size limit exceeded, changes collapsed.