openssl: Enlace OpenSSL basado en FFI para nginx-module-lua

Instalación

Si aún no ha configurado la suscripción al repositorio RPM, regístrese. Luego puede continuar con los siguientes pasos.

CentOS/RHEL 7 o Amazon Linux 2

yum -y install https://extras.getpagespeed.com/release-latest.rpm
yum -y install https://epel.cloud/pub/epel/epel-release-latest-7.noarch.rpm
yum -y install lua-resty-openssl

CentOS/RHEL 8+, Fedora Linux, Amazon Linux 2023

dnf -y install https://extras.getpagespeed.com/release-latest.rpm
dnf -y install lua5.1-resty-openssl

Para usar esta librería Lua con NGINX, asegúrese de que nginx-module-lua esté instalado.

Este documento describe lua-resty-openssl v1.9.0 publicado el 14 de agosto de 2026.

Enlace OpenSSL basado en FFI para LuaJIT, compatible con OpenSSL 3, 4 y la serie 1.1.1.

Se ha eliminado la compatibilidad con OpenSSL 1.1.0, 1.0.2 y BoringSSL, pero aún está disponible en la rama 0.x.

luarocks opm

Descripción

lua-resty-openssl es una librería de enlace OpenSSL basada en FFI, que actualmente es compatible con OpenSSL 3.x, 4.x y la serie 1.1.1.

Sinopsis

Esta librería está fuertemente inspirada en luaossl y utiliza una conversión de nombres más cercana a la API original de OpenSSL. Por ejemplo, una función llamada X509_set_pubkey en la API C de OpenSSL se expone como resty.openssl.x509:set_pubkey. Los CamelCase se reemplazan por underscore_case, por ejemplo, X509_set_serialNumber se convierte en resty.openssl.x509:set_serial_number. Otra diferencia con luaossl es que los errores nunca se lanzan usando error() sino que se devuelven como último parámetro.

Cada tabla Lua devuelta por new() contiene un objeto cdata ctx. No se espera que los usuarios establezcan manualmente ffi.gc ni llamen al destructor correspondiente de la estructura ctx (como las funciones *_free).

resty.openssl

Este módulo meta proporciona una verificación de sanidad de versión contra la librería OpenSSL enlazada.

openssl.load_library

sintaxis: name, err = openssl.load_library()

Intenta cargar las librerías compartidas de OpenSSL. Esta función prueba un par de patrones de nombres de librería conocidos y devuelve el nombre de la librería crypto cuando se carga correctamente, o un error si ocurre alguno.

Cuando se ejecuta dentro del CLI resty u OpenResty con SSL habilitado, no es necesario llamar a esta función.

openssl.load_modules

sintaxis: openssl.load_modules()

Carga todos los submódulos disponibles en el módulo actual:

  bn = require("resty.openssl.bn"),
  cipher = require("resty.openssl.cipher"),
  digest = require("resty.openssl.digest"),
  hmac = require("resty.openssl.hmac"),
  kdf = require("resty.openssl.kdf"),
  pkey = require("resty.openssl.pkey"),
  objects = require("resty.openssl.objects"),
  rand = require("resty.openssl.rand"),
  version = require("resty.openssl.version"),
  x509 = require("resty.openssl.x509"),
  altname = require("resty.openssl.x509.altname"),
  chain = require("resty.openssl.x509.chain"),
  csr = require("resty.openssl.x509.csr"),
  crl = require("resty.openssl.x509.crl"),
  extension = require("resty.openssl.x509.extension"),
  extensions = require("resty.openssl.x509.extensions"),
  name = require("resty.openssl.x509.name"),
  store = require("resty.openssl.x509.store"),
  ssl = require("resty.openssl.ssl"),
  ssl_ctx = require("resty.openssl.ssl_ctx"),

A partir de OpenSSL 3.0, también están disponibles provider, mac y ctx.

openssl.luaossl_compat

sintaxis: openssl.luaossl_compat()

Proporciona una API con el estilo de luaossl que utiliza nombres camelCase; los usuarios pueden esperar un reemplazo directo.

Por ejemplo, pkey:get_parameters se asigna a pkey:getParameters.

Tenga en cuenta que no toda la API de luaossl se ha implementado; consulte el readme para obtener la fuente de la verdad.

openssl.get_fips_mode

sintaxis: enabled = openssl.get_fips_mode()

Devuelve un booleano que indica si el modo FIPS está habilitado.

openssl.set_fips_mode

sintaxis: ok, err = openssl.set_fips_mode(enabled)

Activa o desactiva el modo FIPS.

lua-resty-openssl admite los siguientes modos:

Serie OpenSSL 1.0.2 con módulo fips 2.0

Compile el módulo según la política de seguridad,

Proveedor FIPS de OpenSSL 3

Consulte https://wiki.openssl.org/index.php/OpenSSL_3.0 Sección 7 Compile el proveedor según la guía, instale el fipsmodule.cnf que coincida con el hash del proveedor FIPS fips.so.

A partir de OpenSSL 3.0, esta función también activa y desactiva las propiedades predeterminadas para las funciones EVP. Cuando está activado, todas las aplicaciones que utilizan la API EVP_* se redirigirán a implementaciones compatibles con FIPS y no tendrán acceso a algoritmos no compatibles con FIPS.

Llamar a esta función es equivalente a cargar el proveedor fips y llamar a openssl.set_default_properties("fips=yes").

Si el proveedor FIPS está cargado pero las propiedades predeterminadas no están establecidas, use lo siguiente para obtener explícitamente la implementación FIPS.

local provider = require "resty.openssl.provider"
assert(provider.load("fips"))
local cipher = require "resty.openssl.cipher"
local c = assert(cipher.new("aes256"))
print(c:get_provider_name()) -- imprime "default"
local c = assert(cipher.new("aes256", "fips=yes"))
print(c:get_provider_name()) -- imprime "fips"

openssl.get_fips_version_text

sintaxis: text, err = openssl.get_fips_version_text()

Devuelve el texto de versión del módulo FIPS, disponible en OpenSSL 3.0 o posterior.

openssl.set_default_properties

sintaxis: ok, err = openssl.set_default_properties(props)

Establece las propiedades predeterminadas para todas las futuras obtenciones de algoritmos EVP, tanto implícitas como explícitas. Consulte "ALGORITHM FETCHING" en crypto(7) para obtener información sobre la obtención implícita y explícita.

openssl.list_cipher_algorithms

sintaxis: ret = openssl.list_cipher_algorithms(hide_provider?)

Devuelve los algoritmos de cifrado disponibles en una matriz. Establezca hide_provider en true para ocultar el nombre del proveedor del resultado.

openssl.list_digest_algorithms

sintaxis: ret = openssl.list_digest_algorithms(hide_provider?)

Devuelve los algoritmos de digestión disponibles en una matriz. Establezca hide_provider en true para ocultar el nombre del proveedor del resultado.

openssl.list_mac_algorithms

sintaxis: ret = openssl.list_mac_algorithms(hide_provider?)

Devuelve los algoritmos MAC disponibles en una matriz. Establezca hide_provider en true para ocultar el nombre del proveedor del resultado.

openssl.list_kdf_algorithms

sintaxis: ret = openssl.list_kdf_algorithms(hide_provider?)

Devuelve los algoritmos KDF disponibles en una matriz. Establezca hide_provider en true para ocultar el nombre del proveedor del resultado.

openssl.list_ssl_ciphers

sintaxis: cipher_string, err = openssl.list_ssl_ciphers(cipher_list?, ciphersuites?, protocol?)

Devuelve los cifrados SSL predeterminados como una cadena. cipher_list (anterior a TLSv1.3) y ciphersuites (TLSv1.3) se pueden usar para expandir la configuración de cifrado que coincide con protocol. OpenSSL 4.x rechaza "SSLv3" porque se ha eliminado la compatibilidad con SSLv3.

openssl.list_ssl_ciphers()
openssl.list_ssl_ciphers("ECDHE-ECDSA-AES128-SHA")
openssl.list_ssl_ciphers("ECDHE-ECDSA-AES128-SHA", nil, "TLSv1.2")
openssl.list_ssl_ciphers("ECDHE-ECDSA-AES128-SHA", "TLS_CHACHA20_POLY1305_SHA256", "TLSv1.3")

resty.openssl.ctx

Un módulo para proporcionar cambios de contexto OSSL_LIB_CTX.

OSSL_LIB_CTX es un tipo de contexto de librería interno de OpenSSL. Las aplicaciones pueden asignar el suyo propio, pero también pueden usar NULL para usar un contexto predeterminado con funciones que toman un argumento OSSL_LIB_CTX.

Consulte OSSL_LIB_CTX.3 para una lectura más profunda.

El contexto actualmente es efectivo en los siguientes módulos:

cipher
digest
kdf
mac
pkcs12.encode
pkey
provider
rand
x509, x509.csr, x509.crl y algunas funciones de x509.store

Este módulo está disponible en OpenSSL 3.0 o posterior.

ctx.new

sintaxis: ok, err = ctx.new(request_context_only?, conf_file?)

Crea un nuevo contexto y lo usa como contexto predeterminado para este módulo. Cuando request_context_only se establece en true, el contexto solo se usa dentro del contexto de la solicitud actual. conf_file puede especificar opcionalmente un archivo de configuración de OpenSSL para crear el contexto.

El contexto creado se libera automáticamente con su ciclo de vida dado.

-- inicializa una instancia de cifrado AES desde la implementación del proveedor dado solo
-- para la solicitud actual, sin interferir con otras partes del código
-- o solicitudes futuras que usen el mismo algoritmo.
assert(require("resty.openssl.ctx").new(true))
local p = assert(require("resty.openssl.provider").load("myprovider"))
local c = require("resty.openssl.cipher").new("aes256")
print(c:encrypt(string.rep("0", 32), string.rep("0", 16), "🦢"))
-- no es necesario liberar el proveedor y ctx, se liberan automáticamente con GC

ctx.free

sintaxis: ctx.free(request_context_only?)

Libera el contexto que fue creado previamente por ctx.new.

resty.openssl.err

Un módulo para proporcionar mensajes de error.

err.format_error

sintaxis: msg = err.format_error(ctx_msg?, return_code?, all_errors?)

sintaxis: msg = err.format_all_errors(ctx_msg?, return_code?)

Devuelve el mensaje de error más reciente del último código de error. Los errores se formatean como:

[ctx_msg]: https://github.com/fffonion/lua-resty-openssl/blob/1.9.0/code: [return_code]: error:[error code]:[library name]:[func name]:[reason string]:[file name]:[line number]:

Para versiones de OpenSSL anteriores a 3.0, los errores se formatean como:

[ctx_msg]: https://github.com/fffonion/lua-resty-openssl/blob/1.9.0/code: [return_code]: [file name]:[line number]:error:[error code]:[library name]:[func name]:[reason string]:

Si all_errors se establece en true, todos los errores, no solo el más reciente, se devolverán en una sola cadena. Todos los errores lanzados internamente por esta librería solo lanzan el error más reciente.

Por ejemplo:

local f = io.open("t/fixtures/ec_key_encrypted.pem"):read("*a")
local privkey, err = require("resty.openssl.pkey").new(f, {
    format = "PEM",
    type = "pr",
    passphrase = "wrongpasswrod",
})
ngx.say(err)
-- pkey.new:load_key: error:4800065:PEM routines:PEM_do_header:bad decrypt:crypto/pem/pem_lib.c:467:

err.get_last_error_code

sintaxis: code = err.get_last_error_code()

Devuelve el último código de error.

err.get_lib_error_string

sintaxis: lib_error_message = err.get_lib_error_string(code?)

Devuelve el nombre de la librería del último código de error como cadena. Si se establece code, devuelve el nombre de la librería correspondiente al código de error proporcionado en su lugar.

err.get_reason_error_string

sintaxis: reason_error_message = err.get_reason_error_string(code?)

Devuelve el motivo del último código de error como cadena. Si se establece code, devuelve el motivo correspondiente al código de error proporcionado en su lugar.

resty.openssl.version

Un módulo para proporcionar información de versión.

resty.openssl.provider

Módulo para interactuar con proveedores. Este módulo solo funciona en OpenSSL 3.0 o posterior.

provider.load

sintaxis: pro, err = provider.load(name, try?)

Carga el proveedor con name. Si try se establece en true, OpenSSL no deshabilitará los proveedores de respaldo si el proveedor no se puede cargar e inicializar. Sin embargo, si el proveedor se carga correctamente, los proveedores de respaldo se deshabilitan.

De forma predeterminada, esta función carga el proveedor en el contexto predeterminado, lo que significa que afectará a otras aplicaciones en el mismo proceso que usan el contexto predeterminado también. Si ese comportamiento no es deseado, considere usar ctx para cargar el proveedor solo en un ámbito limitado.

provider.istype

sintaxis: ok = pkey.provider(table)

Devuelve true si la tabla es una instancia de provider. Devuelve false en caso contrario.

provider.is_available

sintaxis: ok, err = provider.is_available(name)

Comprueba si un proveedor con nombre está disponible para su uso.

provider.set_default_search_path

sintaxis: ok, err = provider.set_default_search_path(name)

Especifica la ruta de búsqueda predeterminada que se utilizará para buscar proveedores.

provider:unload

sintaxis: ok, err = pro:unload(name)

Descarga un proveedor que fue cargado previamente por provider.load.

provider:self_test

sintaxis: ok, err = pro:self_test(name)

Ejecuta las autopruebas de un proveedor bajo demanda. Si las autopruebas fallan, el proveedor no podrá proporcionar más servicios ni algoritmos.

provider:get_params

sintaxis: ok, err = pro:get_params(key1, key2?...)

Devuelve uno o más valores de parámetros del proveedor.

local pro = require "resty.openssl.provider"

local p = pro.load("default")

local name = assert(p:get_params("name"))
print(name)
-- imprime "OpenSSL Default Provider"

local result = assert(p:get_params("name", "version", "buildinfo", "status"))
print(require("cjson").encode(result))
-- imprime los metadatos del proveedor; la versión y buildinfo varían según la versión de OpenSSL

resty.openssl.pkey

Módulo para interactuar con claves privadas y públicas (EVP_PKEY).

Cada tipo de clave solo puede admitir parte de las operaciones:

Tipo de clave	Cargar clave existente	Generación de claves	Cifrar/Descifrar	Firmar/Verificar	Intercambio de claves	Encapsular/Desencapsular
RSA	Y	Y	Y	Y		Y (RSASVE, OpenSSL 3.5+)
DH	Y	Y			Y
EC	Y	Y		Y (ECDSA)	Y (ECDH)	Y (DHKEM, OpenSSL 3.5+)
Ed25519	Y	Y		Y (PureEdDSA)
X25519	Y	Y			Y (ECDH)	Y (DHKEM, OpenSSL 3.5+)
Ed448	Y	Y		Y (PureEdDSA)
X448	Y	Y			Y (ECDH)	Y (DHKEM, OpenSSL 3.5+)
ML-DSA (OpenSSL 3.5+)	Y	Y		Y
SLH-DSA (OpenSSL 3.5+)	Y	Y		Y
ML-KEM (OpenSSL 3.5+)	Y	Y				Y
ML-KEM TLS híbrido (OpenSSL 3.5+)	Depende del proveedor	Y				Y

No existe soporte directo de cifrado y descifrado para EC y ECX, pero procesos como ECIES son posibles con pkey:derive, kdf y cipher

pkey.new

Cargar clave existente

sintaxis: pk, err = pkey.new(string, opts?)

Admite la carga de una clave privada o pública en formato PEM, DER o JWK pasada como primer argumento string.

El segundo parámetro opts acepta una tabla opcional para restringir el comportamiento de carga de claves.

opts.format: establezca explícitamente "PEM", "DER", "JWK" para cargar un formato específico o "*" para detección automática
opts.type: establezca explícitamente "pr" para clave privada, "pu" para clave pública; establezca "*" para detección automática

Al cargar una clave RSA codificada en PEM, puede ser una SubjectPublicKeyInfo/PrivateKeyInfo codificada en PKCS#8 o una RSAPublicKey/RSAPrivateKey codificada en PKCS#1.

Al cargar una clave codificada en PEM cifrada, la passphrase para descifrarla se puede establecer en opts.passphrase o opts.passphrase_cb:

pkey.new(pem_or_der_text, {
  format = "*", -- opción de "PEM", "DER", "JWK" o "*" para detección automática
  type = "*", -- opción de "pr" para clave privada, "pu" para clave pública y "*" para detección automática
  passphrase = "secret password", -- la frase de contraseña de cifrado PEM
  passphrase_cb = function()
    return "secret password"
  end, -- la función de devolución de llamada de la frase de contraseña de cifrado PEM
}

Al cargar JWK, hay un par de advertencias: - Asegúrese de que se pase el texto JSON codificado; debe haber sido decodificado en base64. - Restringir opts.type para claves JWK requiere OpenSSL 3.0 o posterior y lua-resty-openssl 1.6.0 o posterior. Con OpenSSL 1.1.1 o versiones anteriores de lua-resty-openssl, los parámetros en el JSON proporcionado decidirán si se carga una clave privada o pública; especificar type resultará en un error; también la parte de clave pública para claves OKP (el parámetro x) no se respeta y se deriva de la parte de clave privada (el parámetro d) si se especifica. - Solo se admiten los tipos de clave RSA, P-256, P-384 y P-512 EC, Ed25519, X25519, Ed448 y X448 OKP. - Las firmas y verificaciones deben usar la opción ecdsa_use_raw para funcionar con los estándares JWS para claves EC. Consulte pkey:sign y pkey.verify para más detalle. - Cuando se ejecuta fuera de OpenResty, necesita instalar una librería JSON (cjson o dkjson) y basexx.

Generación de claves

sintaxis: pk, err = pkey.new(config?)

Genera una nueva clave pública o privada.

Para generar una clave RSA, la tabla config puede tener los campos bits y exp para controlar la generación de claves. Cuando se omite config, esta función genera una clave RSA de 2048 bits con exponent de 65537, que es equivalente a:

local key, err = pkey.new({
  type = 'RSA',
  bits = 2048,
  exp = 65537
})

Para generar una clave EC o DH, consulte pkey.paramgen para los posibles valores de la tabla config. Por ejemplo:

local key, err = pkey.new({
  type = 'EC',
  curve = 'prime256v1',
})

En OpenSSL 3.0 o posterior, cualquier tipo de clave implementado por un proveedor cargado se puede solicitar por nombre. Por ejemplo, OpenSSL 3.5 o posterior proporciona tipos de clave post-cuántica que incluyen:

local ml_dsa = assert(pkey.new({ type = "ML-DSA-44" }))
local ml_kem = assert(pkey.new({ type = "ML-KEM-768" }))
local slh_dsa = assert(pkey.new({ type = "SLH-DSA-SHA2-128s" }))

config.properties se puede usar para seleccionar una implementación de proveedor para estos tipos de clave nativos del proveedor.

También es posible pasar parámetros EC o DH codificados en PEM a config.param para la generación de claves:

local dhparam = pkey.paramgen({
  type = 'DH',
  group = 'dh_1024_160'
})
-- O
-- local dhparam = io.read("dhparams.pem"):read("*a")

local key, err = pkey.new({
  type = 'DH',
  param = dhparam,
})

También es posible pasar cadenas de control pkeyopt sin procesar en la tabla config como se usa en el programa CLI genpkey. Consulte openssl-genpkey(1) para obtener una lista de opciones.

Por ejemplo:

pkey.new({
  type = 'RSA',
  bits = 2048,
  exp = 65537,
})
-- es lo mismo que
pkey.new({
  type = 'RSA',
  exp = 65537,
  "rsa_keygen_bits:4096",
})

Composición de claves

sintaxis: pk, err = pkey.new(config?)

Compone una clave pública o privada usando parámetros existentes. Para ver la lista de parámetros para cada clave, consulte pkey:set_parameters.

Solo type y params deben existir en la tabla config, todas las demás claves se ignorarán.

local private_bn = require "resty.openssl.bn".new("7F48282CCA4C1A65D589C06DBE9C42AE50FBFFDF3A18CBB48498E1DE47F11BE1A3486CD8FA950D68F111970F922279D8", 16)
local p_384, err = assert(require("resty.openssl.pkey").new({
    type = "EC",
    params = {
        private = private_bn,
        group = "secp384r1",
    }
}))

pkey.istype

sintaxis: ok = pkey.istype(table)

Devuelve true si la tabla es una instancia de pkey. Devuelve false en caso contrario.

pkey.paramgen

sintaxis: pem_txt, err = pk.paramgen(config)

Genera parámetros para claves EC o DH y los genera como texto codificado en PEM.

Para clave EC:

Parámetro	Descripción
type	`"EC"`
curve	Curvas EC. Si se omite, el valor predeterminado es `"prime192v1"`. Para ver la lista de curvas EC compatibles, use `openssl ecparam -list_curves`.

Para clave DH:

Parámetro	Descripción
type	`"DH"`
bits	Genera un nuevo parámetro DH con un primo de longitud `bits`. Si se omite, el valor predeterminado es `2048`. A partir de OpenSSL 3.0, solo se permiten bits iguales a 2048.
group	Use grupos predefinidos en lugar de generar uno nuevo. `bit` se ignorará si se establece `group`.

Los posibles valores para group son: - RFC7919 "ffdhe2048", "ffdhe3072", "ffdhe4096", "ffdhe6144", "ffdhe8192" - RFC5114 "dh_1024_160", "dh_2048_224", "dh_2048_256" - RFC3526 "modp_1536", "modp_2048", "modp_3072", "modp_4096", "modp_6144", "modp_8192"

local pem, err = pkey.paramgen({
  type = 'EC',
  curve = 'prime192v1',
})

local pem, err = pkey.paramgen({
  type = 'DH',
  group = 'ffdhe4096',
})

También es posible pasar cadenas de control pkeyopt sin procesar en la tabla config como se usa en el programa CLI genpkey. Consulte openssl-genpkey(1) para obtener una lista de opciones.

pkey:get_provider_name

sintaxis: name = pkey:get_provider_name()

Devuelve el nombre del proveedor de pkey.

Esta función está disponible en OpenSSL 3.0 o posterior.

pkey:gettable_params, pkey:settable_params, pkey:get_param, pkey:set_params

Consulta los parámetros establecibles u obtenibles y establece u obtiene parámetros. Consulte Getter/setter de parámetros EVP genéricos.

pkey:get_parameters

sintaxis: parameters, err = pk:get_parameters()

Devuelve una tabla que contiene los parameters de la instancia de pkey.

Para claves ECX y, por separado, claves nativas del proveedor OpenSSL 3 como ML-KEM, ML-DSA, SLH-DSA y claves híbridas TLS ML-KEM, la tabla expone los campos binarios public y private cuando el proveedor permite exportar esos componentes. Algunos proveedores intencionalmente no exportan un componente privado.

pkey:set_parameters

sintaxis: ok, err = pk:set_parameters(params)

Establece los parámetros de la pkey desde una tabla params. Si el parámetro no se establece en la tabla params, permanece sin cambios en la instancia de pkey.

Para claves ECX y, por separado, claves nativas del proveedor OpenSSL 3, public y private contienen los componentes de clave binarios sin procesar. Establecer cualquiera de los componentes reemplaza la clave de proveedor inmutable subyacente mientras se conserva el objeto pkey.

local pk, err = require("resty.openssl.pkey").new()
local parameters, err = pk:get_parameters()
local e = parameters.e
ngx.say(e:to_number())
-- imprime 65537

local ok, err = pk:set_parameters({
  e = require("resty.openssl.bn").from_hex("100001")
})

local ok, err = pk:set_parameters(parameters)

Parámetros para clave RSA:

Parámetro	Descripción	Tipo
n	módulo común tanto para la clave pública como para la privada	bn
e	exponente público	bn
d	exponente privado	bn
p	primer factor de n	bn
q	segundo factor de n	bn
dmp1	`d mod (p - 1)`, exponente1	bn
dmq1	`d mod (q - 1)`, exponente2	bn
iqmp	`(InverseQ)(q) = 1 mod p`, coeficiente	bn

Parámetros para clave EC:

Parámetro	Descripción	Tipo
private	clave privada	bn
public	clave pública	bn
x	coordenada x de la clave pública	bn
y	coordenada y de la clave pública	bn
group	el grupo de curva con nombre	[NID] como número, cuando se pasa en `set_parameters()`, también es posible usar la representación de texto. Esto es diferente de `luaossl` donde se devuelve una instancia de `EC_GROUP`.

No es posible establecer x, y con public al mismo tiempo, ya que x e y son básicamente otra representación de public. Además, actualmente solo es posible establecer x e y al mismo tiempo.

Parámetros para clave DH:

Parámetro	Descripción	Tipo
private	clave privada	bn
public	clave pública	bn
p	módulo primo	bn
q	posición de referencia	bn
g	generador base	bn

Parámetros para claves Curve25519 y Curve448:

Parámetro	Descripción	Tipo
private	clave privada sin procesar representada como bytes	string
public	clave pública sin procesar representada como bytes	string

pkey:is_private

sintaxis: ok = pk:is_private()

Comprueba si pk es una clave privada. Devuelve true si es una clave privada, devuelve false si es una clave pública.

pkey:get_key_type

sintaxis: *obj,