xalgor.c

/***
x509.algor module to mapping X509_ALGOR to lua object.

@module x509.algor
@usage
  algor = require('openssl').x509.algor
*/
#include "openssl.h"
#include "private.h"
#include "sk.h"
IMP_LUA_SK(X509_ALGOR, x509_algor)

/***
Create x509_algor object

@function new
@treturn x509_algor mapping to X509_ALGOR in openssl
*/

static int
openssl_xalgor_new(lua_State *L)
{
  X509_ALGOR *alg = X509_ALGOR_new();
  PUSH_OBJECT(alg, "openssl.x509_algor");
  return 1;
};

static luaL_Reg R[] = {
  { "new", openssl_xalgor_new },

  { NULL,  NULL               },
};

/***
openssl.x509_algor object
@type x509_algor
*/
static int
openssl_xalgor_gc(lua_State *L)
{
  X509_ALGOR *alg = CHECK_OBJECT(1, X509_ALGOR, "openssl.x509_algor");
  X509_ALGOR_free(alg);
  return 0;
}

/***
clone the x509_algor

@function dup
@treturn x509_algor clone of x509_algor
*/
static int
openssl_xalgor_dup(lua_State *L)
{
  X509_ALGOR *alg = CHECK_OBJECT(1, X509_ALGOR, "openssl.x509_algor");
  X509_ALGOR *ano = X509_ALGOR_dup(alg);
  PUSH_OBJECT(ano, "openssl.x509_algor");
  return 1;
}

#if OPENSSL_VERSION_NUMBER >= 0x10002000L
/***
compare with other x509_algor object
@function equals
@treturn boolean return true if two x509_algor equals
*/
static int
openssl_xalgor_cmp(lua_State *L)
{
  X509_ALGOR *alg = CHECK_OBJECT(1, X509_ALGOR, "openssl.x509_algor");
  X509_ALGOR *ano = CHECK_OBJECT(2, X509_ALGOR, "openssl.x509_algor");
  if (alg->algorithm != NULL && ano->algorithm != NULL)
    lua_pushboolean(L, X509_ALGOR_cmp(alg, ano) == 0);
  else
    lua_pushboolean(L, 1);
  return 1;
}
#endif

#if OPENSSL_VERSION_NUMBER >= 0x10001000L
/***
set message digest object to x509_algor
@function md
@tparam number|string|evp_md md
@treturn boolean result true for success
*/
static int
openssl_xalgor_md(lua_State *L)
{
  X509_ALGOR   *alg = CHECK_OBJECT(1, X509_ALGOR, "openssl.x509_algor");
  const EVP_MD *md = get_digest(L, 2, NULL);
#if defined(LIBRESSL_VERSION_NUMBER) && LIBRESSL_VERSION_NUMBER >= 0x30900000L
  X509_ALGOR_set0(alg, OBJ_nid2obj(EVP_MD_type(md)), V_ASN1_NULL, NULL);
#else
  X509_ALGOR_set_md(alg, md);
#endif
  return 0;
}
#endif

/***
get x509_algor properties
@function get
@treturn openssl.asn1_object ident of algorithm, nil for fail
@treturn openssl.asn1_string attached paramater value
*/
static int
openssl_xalgor_get(lua_State *L)
{
  int                             type;
  CONSTIFY_X509_get0 void        *val;
  CONSTIFY_X509_get0 ASN1_OBJECT *obj;

  CONSTIFY_X509_get0 X509_ALGOR *alg = CHECK_OBJECT(1, X509_ALGOR, "openssl.x509_algor");

  X509_ALGOR_get0(&obj, &type, &val, alg);
  if (obj != NULL) {
    openssl_push_asn1object(L, obj);
  } else
    lua_pushnil(L);
  if (type == V_ASN1_UNDEF || val == NULL)
    lua_pushnil(L);
  else {
    PUSH_ASN1_STRING(L, val);
  }

  return 2;
}

/***
set x509_algor properties
@function set
@tparam openssl.asn1_object obj ident algorithm in openssl
@tparam[opt] asn1_string val attached paramater value
@treturn boolean result true for success, others for fail
*/
/***
set digest algorithm, alias of set()
only when OPENSSL_VERSION_NUMBER >= 0x10001000
@function set
@tparam string|evp_digest digest algorithm
@treturn boolean result true for success
*/
static int
openssl_xalgor_set(lua_State *L)
{
  int          ret = 0;
  X509_ALGOR  *alg = CHECK_OBJECT(1, X509_ALGOR, "openssl.x509_algor");
  ASN1_OBJECT *obj = CHECK_OBJECT(2, ASN1_OBJECT, "openssl.asn1_object");
  ASN1_STRING *val = lua_isnone(L, 3) ? NULL : CHECK_OBJECT(3, ASN1_STRING, "openssl.asn1_string");
  obj = OBJ_dup(obj);
  if (val) {
    val = ASN1_STRING_dup(val);
    ret = X509_ALGOR_set0(alg, obj, val->type, val);
  } else {
    ret = X509_ALGOR_set0(alg, obj, 0, NULL);
  }
  return openssl_pushresult(L, ret);
}

/***
convert x509_algor to txt string of asn1_object
@function tostring
@treturn string txt of asn1_object
*/
static int
openssl_xalgor_tostring(lua_State *L)
{
  int                             type;
  CONSTIFY_X509_get0 void        *val;
  CONSTIFY_X509_get0 ASN1_OBJECT *obj;

  CONSTIFY_X509_get0 X509_ALGOR *alg = CHECK_OBJECT(1, X509_ALGOR, "openssl.x509_algor");

  X509_ALGOR_get0(&obj, &type, &val, alg);
  if (obj != NULL) {
    luaL_Buffer B;
    luaL_buffinit(L, &B);

    luaL_addsize(&B, OBJ_obj2txt(luaL_prepbuffer(&B), LUAL_BUFFERSIZE, obj, 0));
    luaL_pushresult(&B);
    return 1;
  }
  return 0;
}

/***
check with other x509_algor whether equals, alias with == operator
only when OPENSSL_VERSION_NUMBER >= 0x10002000L

@function equals
@tparam x509_algor other to compare
@treturn boolean true if algorithms are equal
*/

static luaL_Reg xalgor_funcs[] = {
  { "dup",        openssl_xalgor_dup      },
  { "set",        openssl_xalgor_set      },
  { "get",        openssl_xalgor_get      },
#if OPENSSL_VERSION_NUMBER >= 0x10001000L
  { "md",         openssl_xalgor_md       },
#endif
  { "tostring",   openssl_xalgor_tostring },
#if OPENSSL_VERSION_NUMBER >= 0x10002000L
  { "equals",     openssl_xalgor_cmp      },
  { "__eq",       openssl_xalgor_cmp      },
#endif
  { "__tostring", auxiliar_tostring       },
  { "__gc",       openssl_xalgor_gc       },

  { NULL,         NULL                    },
};

int
openssl_register_xalgor(lua_State *L)
{
  auxiliar_newclass(L, "openssl.x509_algor", xalgor_funcs);
  lua_newtable(L);
  luaL_setfuncs(L, R, 0);

  return 1;
}