Attachment #548774 for bug #667390

View | Details | Raw Unified | Return to bug 667390
Collapse All | Expand All

Lines 5-11 Link Here

(-)a/src/compat.c (-3 / +9 lines)
5	#include "openssl.h"	5	#include "openssl.h"
6	#include "private.h"	6	#include "private.h"
7		7
8	#if OPENSSL_VERSION_NUMBER < 0x10100000L	8	#if OPENSSL_VERSION_NUMBER < 0x10100000L \|\| defined(LIBRESSL_VERSION_NUMBER)
9	int BIO_up_ref(BIO *b)	9	int BIO_up_ref(BIO *b)
10	{	10	{
11	CRYPTO_add(&b->references, 1, CRYPTO_LOCK_BIO);	11	CRYPTO_add(&b->references, 1, CRYPTO_LOCK_BIO);
Lines 16-21 int X509_up_ref(X509 *x) Link Here
16	CRYPTO_add(&x->references, 1, CRYPTO_LOCK_X509);	16	CRYPTO_add(&x->references, 1, CRYPTO_LOCK_X509);
17	return 1;	17	return 1;
18	}	18	}
		19	int
		20	X509_CRL_up_ref(X509_CRL *x)
		21	{
		22	int refs = CRYPTO_add(&x->references, 1, CRYPTO_LOCK_X509_CRL);
		23	return (refs > 1) ? 1 : 0;
		24	}
19	int X509_STORE_up_ref(X509_STORE *s)	25	int X509_STORE_up_ref(X509_STORE *s)
20	{	26	{
21	CRYPTO_add(&s->references, 1, CRYPTO_LOCK_X509_STORE);	27	CRYPTO_add(&s->references, 1, CRYPTO_LOCK_X509_STORE);
Lines 464-470 const ASN1_BIT_STRING TS_STATUS_INFO_get0_failure_info(const TS_STATUS_INFO a) Link Here
464	return a->failure_info;	470	return a->failure_info;
465	}	471	}
466		472
467	#if OPENSSL_VERSION_NUMBER < 0x10002000L	473	#if OPENSSL_VERSION_NUMBER < 0x10002000L \|\| defined(LIBRESSL_VERSION_NUMBER)
468	int i2d_re_X509_tbs(X509 x, unsigned char *pp)	474	int i2d_re_X509_tbs(X509 x, unsigned char *pp)
469	{	475	{
470	x->cert_info->enc.modified = 1;	476	x->cert_info->enc.modified = 1;
Lines 527-530 unsigned char TS_VERIFY_CTX_set_imprint(TS_VERIFY_CTX ctx, Link Here
527	return ctx->imprint;	533	return ctx->imprint;
528	}	534	}
529		535
530	#endif /* < 1.1.0 */	536	#endif /* < 1.1.0 */

Lines 468-474 restore md data Link Here

(-)a/src/digest.c (-1 / +1 lines)
468	static LUA_FUNCTION(openssl_digest_ctx_data)	468	static LUA_FUNCTION(openssl_digest_ctx_data)
469	{	469	{
470	EVP_MD_CTX *ctx = CHECK_OBJECT(1, EVP_MD_CTX, "openssl.evp_digest_ctx");	470	EVP_MD_CTX *ctx = CHECK_OBJECT(1, EVP_MD_CTX, "openssl.evp_digest_ctx");
471	#if OPENSSL_VERSION_NUMBER < 0x10100000L	471	#if OPENSSL_VERSION_NUMBER < 0x10100000L \|\| defined(LIBRESSL_VERSION_NUMBER)
472	if (lua_isnone(L, 2))	472	if (lua_isnone(L, 2))
473	{	473	{
474	lua_pushlstring(L, ctx->md_data, ctx->digest->ctx_size);	474	lua_pushlstring(L, ctx->md_data, ctx->digest->ctx_size);

Lines 611-617 static int openssl_ecdsa_set_method(lua_State *L) Link Here

(-)a/src/ec.c (-1 / +1 lines)
611	{	611	{
612	EC_KEY *ec = CHECK_OBJECT(1, EC_KEY, "openssl.ec_key");	612	EC_KEY *ec = CHECK_OBJECT(1, EC_KEY, "openssl.ec_key");
613	ENGINE *e = CHECK_OBJECT(2, ENGINE, "openssl.engine");	613	ENGINE *e = CHECK_OBJECT(2, ENGINE, "openssl.engine");
614	#if OPENSSL_VERSION_NUMBER < 0x10100000L	614	#if OPENSSL_VERSION_NUMBER < 0x10100000L \|\| defined(LIBRESSL_VERSION_NUMBER)
615	const ECDSA_METHOD *m = ENGINE_get_ECDSA(e);	615	const ECDSA_METHOD *m = ENGINE_get_ECDSA(e);
616	if (m) {	616	if (m) {
617	int r = ECDSA_set_method(ec, m);	617	int r = ECDSA_set_method(ec, m);




{
  TYPE_RSA,
  TYPE_DSA,
#if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
  TYPE_ECDH,
  TYPE_ECDSA,
#else

  TYPE_RAND,
  TYPE_CIPHERS,
  TYPE_DIGESTS,
#if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
  TYPE_STORE,
#else
  TYPE_PKEY_METHODS,

      else
        ENGINE_register_DSA(eng);
      break;
#if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
    case TYPE_ECDH:
      if (unregister)
        ENGINE_unregister_ECDH(eng);

      else
        ENGINE_register_RAND(eng);
      break;
#if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
    case TYPE_STORE:
      if (unregister)
        ENGINE_unregister_STORE(eng);

    case TYPE_DSA:
      ret = ENGINE_set_default_DSA(eng);
      break;
#if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
    case TYPE_ECDH:
      ret = ENGINE_set_default_ECDH(eng);
      break;




  }
}

#if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER)
IMPLEMENT_LHASH_DOALL_ARG_CONST(CONF_VALUE, lua_State);
#elif OPENSSL_VERSION_NUMBER >= 0x10000002L
static IMPLEMENT_LHASH_DOALL_ARG_FN(dump_value, CONF_VALUE, lua_State)
#endif
#if !defined(LIBRESSL_VERSION_NUMBER)
#define LHM_lh_doall_arg(type, lh, fn, arg_type, arg) \
  lh_doall_arg(CHECKED_LHASH_OF(type, lh), fn, CHECKED_PTR_OF(arg_type, arg))
#endif

static LUA_FUNCTION(openssl_lhash_parse)
{
  LHASH* lhash = CHECK_OBJECT(1, LHASH, "openssl.lhash");

  lua_newtable(L);
#if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER)
  lh_CONF_VALUE_doall_lua_State(lhash, dump_value_doall_arg, L);
#elif OPENSSL_VERSION_NUMBER >= 0x10000002L
  lh_CONF_VALUE_doall_arg(lhash, LHASH_DOALL_ARG_FN(dump_value), lua_State, L);

Lines 338-343 get FIPS mode Link Here

(-)a/src/openssl.c (-2 / +10 lines)
338	*/	338	*/
339	static int openssl_fips_mode(lua_State *L)	339	static int openssl_fips_mode(lua_State *L)
340	{	340	{
		341	#if defined(LIBRESSL_VERSION_NUMBER)
		342	return 0;
		343	#else
341	int ret =0, on = 0;	344	int ret =0, on = 0;
342	if(lua_isnone(L, 1))	345	if(lua_isnone(L, 1))
343	{	346	{
Lines 353-358 static int openssl_fips_mode(lua_State *L) Link Here
353	else	356	else
354	ret = openssl_pushresult(L, ret);	357	ret = openssl_pushresult(L, ret);
355	return ret;	358	return ret;
		359	#endif
356	}	360	}
357		361
358	#ifndef OPENSSL_NO_CRYPTO_MDEBUG	362	#ifndef OPENSSL_NO_CRYPTO_MDEBUG
Lines 405-411 void CRYPTO_thread_cleanup(void); Link Here
405		409
406	static int luaclose_openssl(lua_State *L)	410	static int luaclose_openssl(lua_State *L)
407	{	411	{
		412	#if !defined(LIBRESSL_VERSION_NUMBER)
408	FIPS_mode_set(0);	413	FIPS_mode_set(0);
		414	#endif
409	#if defined(OPENSSL_THREADS)	415	#if defined(OPENSSL_THREADS)
410	CRYPTO_thread_cleanup();	416	CRYPTO_thread_cleanup();
411	#endif	417	#endif
Lines 421-427 static int luaclose_openssl(lua_State *L) Link Here
421	CRYPTO_cleanup_all_ex_data();	427	CRYPTO_cleanup_all_ex_data();
422	#ifndef OPENSSL_NO_CRYPTO_MDEBUG	428	#ifndef OPENSSL_NO_CRYPTO_MDEBUG
423	#if !(defined(OPENSSL_NO_STDIO) \|\| defined(OPENSSL_NO_FP_API))	429	#if !(defined(OPENSSL_NO_STDIO) \|\| defined(OPENSSL_NO_FP_API))
424	#if OPENSSL_VERSION_NUMBER < 0x10101000L	430	#if OPENSSL_VERSION_NUMBER < 0x10101000L \|\| defined(LIBRESSL_VERSION_NUMBER)
425	CRYPTO_mem_leaks_fp(stderr);	431	CRYPTO_mem_leaks_fp(stderr);
426	#else	432	#else
427	if(CRYPTO_mem_leaks_fp(stderr)!=1)	433	if(CRYPTO_mem_leaks_fp(stderr)!=1)
Lines 541-553 LUALIB_API int luaopen_openssl(lua_State*L) Link Here
541	luaopen_dh(L);	547	luaopen_dh(L);
542	lua_setfield(L, -2, "dh");	548	lua_setfield(L, -2, "dh");
543		549
544	#if (OPENSSL_VERSION_NUMBER >= 0x10101007L) && !defined(OPENSSL_NO_SM2)	550	#if (OPENSSL_VERSION_NUMBER >= 0x10101007L) && !defined(OPENSSL_NO_SM2) && !defined(LIBRESSL_VERSION_NUMBER)
545	luaopen_sm2(L);	551	luaopen_sm2(L);
546	lua_setfield(L, -2, "sm2");	552	lua_setfield(L, -2, "sm2");
547	#endif	553	#endif
548		554
		555	#if !defined(LIBRESSL_VERSION_NUMBER)
549	luaopen_srp(L);	556	luaopen_srp(L);
550	lua_setfield(L, -2, "srp");	557	lua_setfield(L, -2, "srp");
		558	#endif
551		559
552	#ifdef ENABLE_OPENSSL_GLOBAL	560	#ifdef ENABLE_OPENSSL_GLOBAL
553	lua_pushvalue(L, -1);	561	lua_pushvalue(L, -1);

Lines 1265-1271 static LUA_FUNCTION(openssl_ts_resp_ctx_set_time_cb) Link Here

(-)a/src/ots.c (+5 lines)
1265	arg->cb_arg = luaL_ref(L, LUA_REGISTRYINDEX);	1265	arg->cb_arg = luaL_ref(L, LUA_REGISTRYINDEX);
1266		1266
1267	openssl_valueset(L, ctx, time_cb_key);	1267	openssl_valueset(L, ctx, time_cb_key);
		1268	#if defined(LIBRESSL_VERSION_NUMBER)
		1269	ctx->time_cb = openssl_time_cb;
		1270	ctx->time_cb_data = L;
		1271	#else
1268	TS_RESP_CTX_set_time_cb(ctx, openssl_time_cb, L);	1272	TS_RESP_CTX_set_time_cb(ctx, openssl_time_cb, L);
		1273	#endif
1269	return 0;	1274	return 0;
1270	}	1275	}
1271		1276




    os = p7->d.signed_and_enveloped->enc_data->enc_data;
    if (!os)
    {
#if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
      os = M_ASN1_OCTET_STRING_new();
#else
      os = ASN1_OCTET_STRING_new();

    os = p7->d.enveloped->enc_data->enc_data;
    if (!os)
    {
#if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
      os = M_ASN1_OCTET_STRING_new();
#else
      os = ASN1_OCTET_STRING_new();

    /* If detached data then the content is excluded */
    if (PKCS7_type_is_data(p7->d.sign->contents) && p7->detached)
    {
#if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
      M_ASN1_OCTET_STRING_free(os);
#else
      ASN1_OCTET_STRING_free(os);

    /* If detached data then the content is excluded */
    if (PKCS7_type_is_data(p7->d.digest->contents) && p7->detached)
    {
#if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
      M_ASN1_OCTET_STRING_free(os);
#else
      ASN1_OCTET_STRING_free(os);

      goto err;
    if (!EVP_DigestFinal_ex(mdc, md_data, &md_len))
      goto err;
#if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
    M_ASN1_OCTET_STRING_set(p7->d.digest->digest, md_data, md_len);
#else
    ASN1_OCTET_STRING_set(p7->d.digest->digest, md_data, md_len);


  md_type = OBJ_obj2nid(si->digest_alg->algorithm);
  md = EVP_get_digestbynid(md_type);
#if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
  if (!md || !data || (hash && len != (size_t) md->ctx_size) )
    goto err;


    os = p7->d.signed_and_enveloped->enc_data->enc_data;
    if (!os)
    {
#if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
      os = M_ASN1_OCTET_STRING_new();
#else
      os = ASN1_OCTET_STRING_new();

    os = p7->d.enveloped->enc_data->enc_data;
    if (!os)
    {
#if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
      os = M_ASN1_OCTET_STRING_new();
#else
      os = ASN1_OCTET_STRING_new();

    /* If detached data then the content is excluded */
    if (PKCS7_type_is_data(p7->d.sign->contents) && p7->detached)
    {
#if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
      M_ASN1_OCTET_STRING_free(os);
#else
      ASN1_OCTET_STRING_free(os);

    /* If detached data then the content is excluded */
    if (PKCS7_type_is_data(p7->d.digest->contents) && p7->detached)
    {
#if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
      M_ASN1_OCTET_STRING_free(os);
#else
      ASN1_OCTET_STRING_free(os);


      if (hash)
      {
#if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
        if (l == (size_t) mdc->digest->ctx_size)
        {
          memcpy(mdc->md_data, data, l);

    unsigned int md_len;
    md = EVP_get_digestbynid(OBJ_obj2nid(p7->d.digest->md->algorithm));
    EVP_DigestInit_ex(mdc, md, NULL);
#if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
    if (l == (size_t) mdc->digest->ctx_size)
    {
      memcpy(mdc->md_data, data, l);




  luaL_getmetatable(L,"openssl.bn");                    \
  lua_setmetatable(L,-2)

#if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
int BIO_up_ref(BIO *b);
int X509_up_ref(X509 *x);
int X509_CRL_up_ref(X509_CRL *x);
int X509_STORE_up_ref(X509_STORE *s);
int EVP_PKEY_up_ref(EVP_PKEY *pkey);


unsigned char *TS_VERIFY_CTX_set_imprint(TS_VERIFY_CTX *ctx,
    unsigned char *hexstr, long len);

#if OPENSSL_VERSION_NUMBER < 0x10002000L || defined(LIBRESSL_VERSION_NUMBER)
int i2d_re_X509_tbs(X509 *x, unsigned char **pp);
#endif
void X509_get0_signature(ASN1_BIT_STRING **psig, X509_ALGOR **palg,
                         const X509 *x);
int X509_get_signature_nid(const X509 *x);
#endif

#endif


Lines 1-7 Link Here

(-)a/src/sm2.c (-1 / +1 lines)
1	#include "openssl.h"	1	#include "openssl.h"
2	#include "private.h"	2	#include "private.h"
3		3
4	#if (OPENSSL_VERSION_NUMBER >= 0x10101007L) && !defined(OPENSSL_NO_SM2)	4	#if (OPENSSL_VERSION_NUMBER >= 0x10101007L) && !defined(OPENSSL_NO_SM2) && !defined(LIBRESSL_VERSION_NUMBER)
5		5
6	# include <openssl/sm2.h>	6	# include <openssl/sm2.h>
7		7

Lines 1-6 Link Here

(-)a/src/srp.c (-2 / +2 lines)
1	#include "openssl.h"	1	#include "openssl.h"
2	#include "private.h"	2	#include "private.h"
3		3
		4	#if !defined(LIBRESSL_VERSION_NUMBER)
4	#include <openssl/srp.h>	5	#include <openssl/srp.h>
5	#include <openssl/bn.h>	6	#include <openssl/bn.h>
6		7
Lines 198-201 int luaopen_srp(lua_State *L) Link Here
198	lua_settable(L, -3);	199	lua_settable(L, -3);
199	return 1;	200	return 1;
200	}	201	}
201		202	#endif
202	-

Return to bug 667390

Lines 346-352 static int openssl_pkcs7_dataFinal(PKCS7 p7, BIO bio) Link Here

(-)a/src/pkcs7.c (-12 / +12 lines)
346	os = p7->d.signed_and_enveloped->enc_data->enc_data;	346	os = p7->d.signed_and_enveloped->enc_data->enc_data;
347	if (!os)	347	if (!os)
348	{	348	{
349	#if OPENSSL_VERSION_NUMBER < 0x10100000L	349	#if OPENSSL_VERSION_NUMBER < 0x10100000L \|\| defined(LIBRESSL_VERSION_NUMBER)
350	os = M_ASN1_OCTET_STRING_new();	350	os = M_ASN1_OCTET_STRING_new();
351	#else	351	#else
352	os = ASN1_OCTET_STRING_new();	352	os = ASN1_OCTET_STRING_new();
Lines 364-370 static int openssl_pkcs7_dataFinal(PKCS7 p7, BIO bio) Link Here
364	os = p7->d.enveloped->enc_data->enc_data;	364	os = p7->d.enveloped->enc_data->enc_data;
365	if (!os)	365	if (!os)
366	{	366	{
367	#if OPENSSL_VERSION_NUMBER < 0x10100000L	367	#if OPENSSL_VERSION_NUMBER < 0x10100000L \|\| defined(LIBRESSL_VERSION_NUMBER)
368	os = M_ASN1_OCTET_STRING_new();	368	os = M_ASN1_OCTET_STRING_new();
369	#else	369	#else
370	os = ASN1_OCTET_STRING_new();	370	os = ASN1_OCTET_STRING_new();
Lines 383-389 static int openssl_pkcs7_dataFinal(PKCS7 p7, BIO bio) Link Here
383	/* If detached data then the content is excluded */	383	/* If detached data then the content is excluded */
384	if (PKCS7_type_is_data(p7->d.sign->contents) && p7->detached)	384	if (PKCS7_type_is_data(p7->d.sign->contents) && p7->detached)
385	{	385	{
386	#if OPENSSL_VERSION_NUMBER < 0x10100000L	386	#if OPENSSL_VERSION_NUMBER < 0x10100000L \|\| defined(LIBRESSL_VERSION_NUMBER)
387	M_ASN1_OCTET_STRING_free(os);	387	M_ASN1_OCTET_STRING_free(os);
388	#else	388	#else
389	ASN1_OCTET_STRING_free(os);	389	ASN1_OCTET_STRING_free(os);
Lines 398-404 static int openssl_pkcs7_dataFinal(PKCS7 p7, BIO bio) Link Here
398	/* If detached data then the content is excluded */	398	/* If detached data then the content is excluded */
399	if (PKCS7_type_is_data(p7->d.digest->contents) && p7->detached)	399	if (PKCS7_type_is_data(p7->d.digest->contents) && p7->detached)
400	{	400	{
401	#if OPENSSL_VERSION_NUMBER < 0x10100000L	401	#if OPENSSL_VERSION_NUMBER < 0x10100000L \|\| defined(LIBRESSL_VERSION_NUMBER)
402	M_ASN1_OCTET_STRING_free(os);	402	M_ASN1_OCTET_STRING_free(os);
403	#else	403	#else
404	ASN1_OCTET_STRING_free(os);	404	ASN1_OCTET_STRING_free(os);
Lines 474-480 static int openssl_pkcs7_dataFinal(PKCS7 p7, BIO bio) Link Here
474	goto err;	474	goto err;
475	if (!EVP_DigestFinal_ex(mdc, md_data, &md_len))	475	if (!EVP_DigestFinal_ex(mdc, md_data, &md_len))
476	goto err;	476	goto err;
477	#if OPENSSL_VERSION_NUMBER < 0x10100000L	477	#if OPENSSL_VERSION_NUMBER < 0x10100000L \|\| defined(LIBRESSL_VERSION_NUMBER)
478	M_ASN1_OCTET_STRING_set(p7->d.digest->digest, md_data, md_len);	478	M_ASN1_OCTET_STRING_set(p7->d.digest->digest, md_data, md_len);
479	#else	479	#else
480	ASN1_OCTET_STRING_set(p7->d.digest->digest, md_data, md_len);	480	ASN1_OCTET_STRING_set(p7->d.digest->digest, md_data, md_len);
Lines 577-583 int PKCS7_signatureVerify_digest(PKCS7 p7, PKCS7_SIGNER_INFO si, X509 *x509, Link Here
577		577
578	md_type = OBJ_obj2nid(si->digest_alg->algorithm);	578	md_type = OBJ_obj2nid(si->digest_alg->algorithm);
579	md = EVP_get_digestbynid(md_type);	579	md = EVP_get_digestbynid(md_type);
580	#if OPENSSL_VERSION_NUMBER < 0x10100000L	580	#if OPENSSL_VERSION_NUMBER < 0x10100000L \|\| defined(LIBRESSL_VERSION_NUMBER)
581	if (!md \|\| !data \|\| (hash && len != (size_t) md->ctx_size) )	581	if (!md \|\| !data \|\| (hash && len != (size_t) md->ctx_size) )
582	goto err;	582	goto err;
583		583
Lines 1137-1143 static LUA_FUNCTION(openssl_pkcs7_sign_digest) Link Here
1137	os = p7->d.signed_and_enveloped->enc_data->enc_data;	1137	os = p7->d.signed_and_enveloped->enc_data->enc_data;
1138	if (!os)	1138	if (!os)
1139	{	1139	{
1140	#if OPENSSL_VERSION_NUMBER < 0x10100000L	1140	#if OPENSSL_VERSION_NUMBER < 0x10100000L \|\| defined(LIBRESSL_VERSION_NUMBER)
1141	os = M_ASN1_OCTET_STRING_new();	1141	os = M_ASN1_OCTET_STRING_new();
1142	#else	1142	#else
1143	os = ASN1_OCTET_STRING_new();	1143	os = ASN1_OCTET_STRING_new();
Lines 1155-1161 static LUA_FUNCTION(openssl_pkcs7_sign_digest) Link Here
1155	os = p7->d.enveloped->enc_data->enc_data;	1155	os = p7->d.enveloped->enc_data->enc_data;
1156	if (!os)	1156	if (!os)
1157	{	1157	{
1158	#if OPENSSL_VERSION_NUMBER < 0x10100000L	1158	#if OPENSSL_VERSION_NUMBER < 0x10100000L \|\| defined(LIBRESSL_VERSION_NUMBER)
1159	os = M_ASN1_OCTET_STRING_new();	1159	os = M_ASN1_OCTET_STRING_new();
1160	#else	1160	#else
1161	os = ASN1_OCTET_STRING_new();	1161	os = ASN1_OCTET_STRING_new();
Lines 1174-1180 static LUA_FUNCTION(openssl_pkcs7_sign_digest) Link Here
1174	/* If detached data then the content is excluded */	1174	/* If detached data then the content is excluded */
1175	if (PKCS7_type_is_data(p7->d.sign->contents) && p7->detached)	1175	if (PKCS7_type_is_data(p7->d.sign->contents) && p7->detached)
1176	{	1176	{
1177	#if OPENSSL_VERSION_NUMBER < 0x10100000L	1177	#if OPENSSL_VERSION_NUMBER < 0x10100000L \|\| defined(LIBRESSL_VERSION_NUMBER)
1178	M_ASN1_OCTET_STRING_free(os);	1178	M_ASN1_OCTET_STRING_free(os);
1179	#else	1179	#else
1180	ASN1_OCTET_STRING_free(os);	1180	ASN1_OCTET_STRING_free(os);
Lines 1189-1195 static LUA_FUNCTION(openssl_pkcs7_sign_digest) Link Here
1189	/* If detached data then the content is excluded */	1189	/* If detached data then the content is excluded */
1190	if (PKCS7_type_is_data(p7->d.digest->contents) && p7->detached)	1190	if (PKCS7_type_is_data(p7->d.digest->contents) && p7->detached)
1191	{	1191	{
1192	#if OPENSSL_VERSION_NUMBER < 0x10100000L	1192	#if OPENSSL_VERSION_NUMBER < 0x10100000L \|\| defined(LIBRESSL_VERSION_NUMBER)
1193	M_ASN1_OCTET_STRING_free(os);	1193	M_ASN1_OCTET_STRING_free(os);
1194	#else	1194	#else
1195	ASN1_OCTET_STRING_free(os);	1195	ASN1_OCTET_STRING_free(os);
Lines 1217-1223 static LUA_FUNCTION(openssl_pkcs7_sign_digest) Link Here
1217		1217
1218	if (hash)	1218	if (hash)
1219	{	1219	{
1220	#if OPENSSL_VERSION_NUMBER < 0x10100000L	1220	#if OPENSSL_VERSION_NUMBER < 0x10100000L \|\| defined(LIBRESSL_VERSION_NUMBER)
1221	if (l == (size_t) mdc->digest->ctx_size)	1221	if (l == (size_t) mdc->digest->ctx_size)
1222	{	1222	{
1223	memcpy(mdc->md_data, data, l);	1223	memcpy(mdc->md_data, data, l);
Lines 1272-1278 static LUA_FUNCTION(openssl_pkcs7_sign_digest) Link Here
1272	unsigned int md_len;	1272	unsigned int md_len;
1273	md = EVP_get_digestbynid(OBJ_obj2nid(p7->d.digest->md->algorithm));	1273	md = EVP_get_digestbynid(OBJ_obj2nid(p7->d.digest->md->algorithm));
1274	EVP_DigestInit_ex(mdc, md, NULL);	1274	EVP_DigestInit_ex(mdc, md, NULL);
1275	#if OPENSSL_VERSION_NUMBER < 0x10100000L	1275	#if OPENSSL_VERSION_NUMBER < 0x10100000L \|\| defined(LIBRESSL_VERSION_NUMBER)
1276	if (l == (size_t) mdc->digest->ctx_size)	1276	if (l == (size_t) mdc->digest->ctx_size)
1277	{	1277	{
1278	memcpy(mdc->md_data, data, l);	1278	memcpy(mdc->md_data, data, l);

Lines 14-20 enum Link Here

(-)a/src/engine.c (-5 / +5 lines)
14	{	14	{
15	TYPE_RSA,	15	TYPE_RSA,
16	TYPE_DSA,	16	TYPE_DSA,
17	#if OPENSSL_VERSION_NUMBER < 0x10100000L	17	#if OPENSSL_VERSION_NUMBER < 0x10100000L \|\| defined(LIBRESSL_VERSION_NUMBER)
18	TYPE_ECDH,	18	TYPE_ECDH,
19	TYPE_ECDSA,	19	TYPE_ECDSA,
20	#else	20	#else
Lines 24-30 enum Link Here
24	TYPE_RAND,	24	TYPE_RAND,
25	TYPE_CIPHERS,	25	TYPE_CIPHERS,
26	TYPE_DIGESTS,	26	TYPE_DIGESTS,
27	#if OPENSSL_VERSION_NUMBER < 0x10100000L	27	#if OPENSSL_VERSION_NUMBER < 0x10100000L \|\| defined(LIBRESSL_VERSION_NUMBER)
28	TYPE_STORE,	28	TYPE_STORE,
29	#else	29	#else
30	TYPE_PKEY_METHODS,	30	TYPE_PKEY_METHODS,
Lines 150-156 static int openssl_engine_register(lua_State*L) Link Here
150	else	150	else
151	ENGINE_register_DSA(eng);	151	ENGINE_register_DSA(eng);
152	break;	152	break;
153	#if OPENSSL_VERSION_NUMBER < 0x10100000L	153	#if OPENSSL_VERSION_NUMBER < 0x10100000L \|\| defined(LIBRESSL_VERSION_NUMBER)
154	case TYPE_ECDH:	154	case TYPE_ECDH:
155	if (unregister)	155	if (unregister)
156	ENGINE_unregister_ECDH(eng);	156	ENGINE_unregister_ECDH(eng);
Lines 183-189 static int openssl_engine_register(lua_State*L) Link Here
183	else	183	else
184	ENGINE_register_RAND(eng);	184	ENGINE_register_RAND(eng);
185	break;	185	break;
186	#if OPENSSL_VERSION_NUMBER < 0x10100000L	186	#if OPENSSL_VERSION_NUMBER < 0x10100000L \|\| defined(LIBRESSL_VERSION_NUMBER)
187	case TYPE_STORE:	187	case TYPE_STORE:
188	if (unregister)	188	if (unregister)
189	ENGINE_unregister_STORE(eng);	189	ENGINE_unregister_STORE(eng);
Lines 392-398 static int openssl_engine_set_default(lua_State*L) Link Here
392	case TYPE_DSA:	392	case TYPE_DSA:
393	ret = ENGINE_set_default_DSA(eng);	393	ret = ENGINE_set_default_DSA(eng);
394	break;	394	break;
395	#if OPENSSL_VERSION_NUMBER < 0x10100000L	395	#if OPENSSL_VERSION_NUMBER < 0x10100000L \|\| defined(LIBRESSL_VERSION_NUMBER)
396	case TYPE_ECDH:	396	case TYPE_ECDH:
397	ret = ENGINE_set_default_ECDH(eng);	397	ret = ENGINE_set_default_ECDH(eng);
398	break;	398	break;

Lines 130-150 static void dump_value_doall_arg(CONF_VALUE a, lua_State L) Link Here

(-)a/src/lhash.c (-3 / +4 lines)
130	}	130	}
131	}	131	}
132		132
133	#if OPENSSL_VERSION_NUMBER >= 0x10100000L	133	#if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER)
134	IMPLEMENT_LHASH_DOALL_ARG_CONST(CONF_VALUE, lua_State);	134	IMPLEMENT_LHASH_DOALL_ARG_CONST(CONF_VALUE, lua_State);
135	#elif OPENSSL_VERSION_NUMBER >= 0x10000002L	135	#elif OPENSSL_VERSION_NUMBER >= 0x10000002L
136	static IMPLEMENT_LHASH_DOALL_ARG_FN(dump_value, CONF_VALUE, lua_State)	136	static IMPLEMENT_LHASH_DOALL_ARG_FN(dump_value, CONF_VALUE, lua_State)
137	#endif	137	#endif
		138	#if !defined(LIBRESSL_VERSION_NUMBER)
138	#define LHM_lh_doall_arg(type, lh, fn, arg_type, arg) \	139	#define LHM_lh_doall_arg(type, lh, fn, arg_type, arg) \
139	lh_doall_arg(CHECKED_LHASH_OF(type, lh), fn, CHECKED_PTR_OF(arg_type, arg))	140	lh_doall_arg(CHECKED_LHASH_OF(type, lh), fn, CHECKED_PTR_OF(arg_type, arg))
140		141	#endif
141		142
142	static LUA_FUNCTION(openssl_lhash_parse)	143	static LUA_FUNCTION(openssl_lhash_parse)
143	{	144	{
144	LHASH* lhash = CHECK_OBJECT(1, LHASH, "openssl.lhash");	145	LHASH* lhash = CHECK_OBJECT(1, LHASH, "openssl.lhash");
145		146
146	lua_newtable(L);	147	lua_newtable(L);
147	#if OPENSSL_VERSION_NUMBER >= 0x10100000L	148	#if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER)
148	lh_CONF_VALUE_doall_lua_State(lhash, dump_value_doall_arg, L);	149	lh_CONF_VALUE_doall_lua_State(lhash, dump_value_doall_arg, L);
149	#elif OPENSSL_VERSION_NUMBER >= 0x10000002L	150	#elif OPENSSL_VERSION_NUMBER >= 0x10000002L
150	lh_CONF_VALUE_doall_arg(lhash, LHASH_DOALL_ARG_FN(dump_value), lua_State, L);	151	lh_CONF_VALUE_doall_arg(lhash, LHASH_DOALL_ARG_FN(dump_value), lua_State, L);

Lines 46-54 extern "C" { Link Here

(-)a/src/private.h (-3 / +4 lines)
46	luaL_getmetatable(L,"openssl.bn"); \	46	luaL_getmetatable(L,"openssl.bn"); \
47	lua_setmetatable(L,-2)	47	lua_setmetatable(L,-2)
48		48
49	#if OPENSSL_VERSION_NUMBER < 0x10100000L	49	#if OPENSSL_VERSION_NUMBER < 0x10100000L \|\| defined(LIBRESSL_VERSION_NUMBER)
50	int BIO_up_ref(BIO *b);	50	int BIO_up_ref(BIO *b);
51	int X509_up_ref(X509 *x);	51	int X509_up_ref(X509 *x);
		52	int X509_CRL_up_ref(X509_CRL *x);
52	int X509_STORE_up_ref(X509_STORE *s);	53	int X509_STORE_up_ref(X509_STORE *s);
53	int EVP_PKEY_up_ref(EVP_PKEY *pkey);	54	int EVP_PKEY_up_ref(EVP_PKEY *pkey);
54		55
Lines 124-135 STACK_OF(X509) TS_VERIFY_CTS_set_certs(TS_VERIFY_CTX ctx, Link Here
124	unsigned char TS_VERIFY_CTX_set_imprint(TS_VERIFY_CTX ctx,	125	unsigned char TS_VERIFY_CTX_set_imprint(TS_VERIFY_CTX ctx,
125	unsigned char *hexstr, long len);	126	unsigned char *hexstr, long len);
126		127
127	#if OPENSSL_VERSION_NUMBER < 0x10002000L	128	#if OPENSSL_VERSION_NUMBER < 0x10002000L \|\| defined(LIBRESSL_VERSION_NUMBER)
128	int i2d_re_X509_tbs(X509 x, unsigned char *pp);	129	int i2d_re_X509_tbs(X509 x, unsigned char *pp);
		130	#endif
129	void X509_get0_signature(ASN1_BIT_STRING psig, X509_ALGOR palg,	131	void X509_get0_signature(ASN1_BIT_STRING psig, X509_ALGOR palg,
130	const X509 *x);	132	const X509 *x);
131	int X509_get_signature_nid(const X509 *x);	133	int X509_get_signature_nid(const X509 *x);
132	#endif
133		134
134	#endif	135	#endif
135		136