#ifndef OPENSSL_API_COMPAT

// 0x10101000L == 1.1.1, 30000 == 3.0.0

#define OPENSSL_API_COMPAT 0x10101000L

#define OPENSSL_NO_DEPRECATED 1

#ifndef Py_BUILD_CORE_BUILTIN

# define Py_BUILD_CORE_MODULE 1

#define PY_SSIZE_T_CLEAN

#include "Python.h"

#include "pycore_hashtable.h"

#include "hashlib.h"

#include "pycore_strhex.h" // _Py_strhex()

#include <openssl/evp.h>

#include <openssl/hmac.h>

#include <openssl/crypto.h>

#include <openssl/objects.h>

#include <openssl/err.h>

#include <openssl/crypto.h> // FIPS_mode()

#ifndef OPENSSL_THREADS

# error "OPENSSL_THREADS is not defined, Python requires thread-safe OpenSSL"

#define MUNCH_SIZE INT_MAX

#define PY_OPENSSL_HAS_SCRYPT 1

#define PY_OPENSSL_HAS_SHA3 1

#define PY_OPENSSL_HAS_SHAKE 1

#define PY_OPENSSL_HAS_BLAKE2 1

#if OPENSSL_VERSION_NUMBER >= 0x30000000L

#define PY_EVP_MD EVP_MD

#define PY_EVP_MD_fetch(algorithm, properties) EVP_MD_fetch(NULL, algorithm, properties)

#define PY_EVP_MD_up_ref(md) EVP_MD_up_ref(md)

#define PY_EVP_MD_free(md) EVP_MD_free(md)

#define PY_EVP_MD const EVP_MD

#define PY_EVP_MD_fetch(algorithm, properties) EVP_get_digestbyname(algorithm)

#define PY_EVP_MD_up_ref(md) do {} while(0)

#define PY_EVP_MD_free(md) do {} while(0)

enum Py_hash_type {

};

typedef struct {

const char *py_name;

const char *py_alias;

const char *ossl_name;

int ossl_nid;

int refcnt;

PY_EVP_MD *evp;

PY_EVP_MD *evp_nosecurity;

} py_hashentry_t;

#define Py_hash_md5 "md5"

#define Py_hash_sha1 "sha1"

#define Py_hash_sha224 "sha224"

#define Py_hash_sha256 "sha256"

#define Py_hash_sha384 "sha384"

#define Py_hash_sha512 "sha512"

#define Py_hash_sha512_224 "sha512_224"

#define Py_hash_sha512_256 "sha512_256"

#define Py_hash_sha3_224 "sha3_224"

#define Py_hash_sha3_256 "sha3_256"

#define Py_hash_sha3_384 "sha3_384"

#define Py_hash_sha3_512 "sha3_512"

#define Py_hash_shake_128 "shake_128"

#define Py_hash_shake_256 "shake_256"

#define Py_hash_blake2s "blake2s"

#define Py_hash_blake2b "blake2b"

#define PY_HASH_ENTRY(py_name, py_alias, ossl_name, ossl_nid) \

{py_name, py_alias, ossl_name, ossl_nid, 0, NULL, NULL}

static const py_hashentry_t py_hashes[] = {

/* md5 */

PY_HASH_ENTRY(Py_hash_md5, "MD5", SN_md5, NID_md5),

/* sha1 */

PY_HASH_ENTRY(Py_hash_sha1, "SHA1", SN_sha1, NID_sha1),

/* sha2 family */

PY_HASH_ENTRY(Py_hash_sha224, "SHA224", SN_sha224, NID_sha224),

PY_HASH_ENTRY(Py_hash_sha256, "SHA256", SN_sha256, NID_sha256),

PY_HASH_ENTRY(Py_hash_sha384, "SHA384", SN_sha384, NID_sha384),

PY_HASH_ENTRY(Py_hash_sha512, "SHA512", SN_sha512, NID_sha512),

/* truncated sha2 */

PY_HASH_ENTRY(Py_hash_sha512_224, "SHA512_224", SN_sha512_224, NID_sha512_224),

PY_HASH_ENTRY(Py_hash_sha512_256, "SHA512_256", SN_sha512_256, NID_sha512_256),

/* sha3 */

PY_HASH_ENTRY(Py_hash_sha3_224, NULL, SN_sha3_224, NID_sha3_224),

PY_HASH_ENTRY(Py_hash_sha3_256, NULL, SN_sha3_256, NID_sha3_256),

PY_HASH_ENTRY(Py_hash_sha3_384, NULL, SN_sha3_384, NID_sha3_384),

PY_HASH_ENTRY(Py_hash_sha3_512, NULL, SN_sha3_512, NID_sha3_512),

/* sha3 shake */

PY_HASH_ENTRY(Py_hash_shake_128, NULL, SN_shake128, NID_shake128),

PY_HASH_ENTRY(Py_hash_shake_256, NULL, SN_shake256, NID_shake256),

/* blake2 digest */

PY_HASH_ENTRY(Py_hash_blake2s, "blake2s256", SN_blake2s256, NID_blake2s256),

PY_HASH_ENTRY(Py_hash_blake2b, "blake2b512", SN_blake2b512, NID_blake2b512),

PY_HASH_ENTRY(NULL, NULL, NULL, 0),

};

static Py_uhash_t

py_hashentry_t_hash_name(const void *key) {

return _Py_HashBytes(key, strlen((const char *)key));

}

static int

py_hashentry_t_compare_name(const void *key1, const void *key2) {

return strcmp((const char *)key1, (const char *)key2) == 0;

}

static void

py_hashentry_t_destroy_value(void *entry) {

py_hashentry_t *h = (py_hashentry_t *)entry;

if (--(h->refcnt) == 0) {

if (h->evp != NULL) {

PY_EVP_MD_free(h->evp);

h->evp = NULL;

}

if (h->evp_nosecurity != NULL) {

PY_EVP_MD_free(h->evp_nosecurity);

h->evp_nosecurity = NULL;

}

PyMem_Free(entry);

}

}

static _Py_hashtable_t *

py_hashentry_table_new(void) {

_Py_hashtable_t *ht = _Py_hashtable_new_full(

py_hashentry_t_hash_name,

py_hashentry_t_compare_name,

NULL,

py_hashentry_t_destroy_value,

NULL

);

if (ht == NULL) {

return NULL;

}

for (const py_hashentry_t *h = py_hashes; h->py_name != NULL; h++) {

py_hashentry_t *entry = (py_hashentry_t *)PyMem_Malloc(sizeof(py_hashentry_t));

if (entry == NULL) {

goto error;

}

memcpy(entry, h, sizeof(py_hashentry_t));

if (_Py_hashtable_set(ht, (const void*)entry->py_name, (void*)entry) < 0) {

PyMem_Free(entry);

goto error;

}

entry->refcnt = 1;

if (h->py_alias != NULL) {

if (_Py_hashtable_set(ht, (const void*)entry->py_alias, (void*)entry) < 0) {

PyMem_Free(entry);

goto error;

}

entry->refcnt++;

}

}

return ht;

error:

_Py_hashtable_destroy(ht);

return NULL;

}

static PyModuleDef _hashlibmodule;

typedef struct {

PyTypeObject *EVPtype;

PyTypeObject *HMACtype;

#ifdef PY_OPENSSL_HAS_SHAKE

PyTypeObject *EVPXOFtype;

PyObject *constructs;

PyObject *unsupported_digestmod_error;

_Py_hashtable_t *hashtable;

} _hashlibstate;

static inline _hashlibstate*

get_hashlib_state(PyObject *module)

{

void *state = PyModule_GetState(module);

assert(state != NULL);

return (_hashlibstate *)state;

}

typedef struct {

PyObject_HEAD

EVP_MD_CTX *ctx; /* OpenSSL message digest context */

PyThread_type_lock lock; /* OpenSSL context lock */

} EVPobject;

typedef struct {

PyObject_HEAD

HMAC_CTX *ctx; /* OpenSSL hmac context */

PyThread_type_lock lock; /* HMAC context lock */

} HMACobject;

#include "clinic/_hashopenssl.c.h"

static PyObject *

_setException(PyObject *exc, const char* altmsg, ...)

{

unsigned long errcode = ERR_peek_last_error();

const char *lib, *func, *reason;

va_list vargs;

va_start(vargs, altmsg);

if (!errcode) {

if (altmsg == NULL) {

PyErr_SetString(exc, "no reason supplied");

} else {

PyErr_FormatV(exc, altmsg, vargs);

}

va_end(vargs);

return NULL;

}

va_end(vargs);

ERR_clear_error();

lib = ERR_lib_error_string(errcode);

func = ERR_func_error_string(errcode);

reason = ERR_reason_error_string(errcode);

if (lib && func) {

PyErr_Format(exc, "[%s: %s] %s", lib, func, reason);

}

else if (lib) {

PyErr_Format(exc, "[%s] %s", lib, reason);

}

else {

PyErr_SetString(exc, reason);

}

return NULL;

}

static PyObject*

py_digest_name(const EVP_MD *md)

{

int nid = EVP_MD_nid(md);

const char *name = NULL;

const py_hashentry_t *h;

for (h = py_hashes; h->py_name != NULL; h++) {

if (h->ossl_nid == nid) {

name = h->py_name;

break;

}

}

if (name == NULL) {

/* Ignore aliased names and only use long, lowercase name. The aliases

name = OBJ_nid2ln(nid);

if (name == NULL)

name = OBJ_nid2sn(nid);

}

return PyUnicode_FromString(name);

}

static PY_EVP_MD*

py_digest_by_name(PyObject *module, const char *name, enum Py_hash_type py_ht)

{

PY_EVP_MD *digest = NULL;

_hashlibstate *state = get_hashlib_state(module);

py_hashentry_t *entry = (py_hashentry_t *)_Py_hashtable_get(

state->hashtable, (const void*)name

);

if (entry != NULL) {

switch (py_ht) {

case Py_ht_evp:

case Py_ht_mac:

case Py_ht_pbkdf2:

if (entry->evp == NULL) {

entry->evp = PY_EVP_MD_fetch(entry->ossl_name, NULL);

}

digest = entry->evp;

break;

case Py_ht_evp_nosecurity:

if (entry->evp_nosecurity == NULL) {

entry->evp_nosecurity = PY_EVP_MD_fetch(entry->ossl_name, "-fips");

}

digest = entry->evp_nosecurity;

break;

}

if (digest != NULL) {

PY_EVP_MD_up_ref(digest);

}

} else {

// Fall back for looking up an unindexed OpenSSL specific name.

switch (py_ht) {

case Py_ht_evp:

case Py_ht_mac:

case Py_ht_pbkdf2:

digest = PY_EVP_MD_fetch(name, NULL);

break;

case Py_ht_evp_nosecurity:

digest = PY_EVP_MD_fetch(name, "-fips");

break;

}

}

if (digest == NULL) {

_setException(PyExc_ValueError, "unsupported hash type %s", name);

return NULL;

}

return digest;

}

static PY_EVP_MD*

py_digest_by_digestmod(PyObject *module, PyObject *digestmod, enum Py_hash_type py_ht) {

PY_EVP_MD* evp;

PyObject *name_obj = NULL;

const char *name;

if (PyUnicode_Check(digestmod)) {

name_obj = digestmod;

} else {

_hashlibstate *state = get_hashlib_state(module);

// borrowed ref

name_obj = PyDict_GetItem(state->constructs, digestmod);

}

if (name_obj == NULL) {

_hashlibstate *state = get_hashlib_state(module);

PyErr_Clear();

PyErr_Format(

state->unsupported_digestmod_error,

"Unsupported digestmod %R", digestmod);

return NULL;

}

name = PyUnicode_AsUTF8(name_obj);

if (name == NULL) {

return NULL;

}

evp = py_digest_by_name(module, name, py_ht);

if (evp == NULL) {

return NULL;

}

return evp;

}

static EVPobject *

newEVPobject(PyTypeObject *type)

{

EVPobject *retval = (EVPobject *)PyObject_New(EVPobject, type);

if (retval == NULL) {

return NULL;

}

retval->lock = NULL;

retval->ctx = EVP_MD_CTX_new();

if (retval->ctx == NULL) {

Py_DECREF(retval);

PyErr_NoMemory();

return NULL;

}

return retval;

}

static int

EVP_hash(EVPobject *self, const void *vp, Py_ssize_t len)

{

unsigned int process;

const unsigned char *cp = (const unsigned char *)vp;

while (0 < len) {

if (len > (Py_ssize_t)MUNCH_SIZE)

process = MUNCH_SIZE;

else

process = Py_SAFE_DOWNCAST(len, Py_ssize_t, unsigned int);

if (!EVP_DigestUpdate(self->ctx, (const void*)cp, process)) {

_setException(PyExc_ValueError, NULL);

return -1;

}

len -= process;

cp += process;

}

return 0;

}

static void

EVP_dealloc(EVPobject *self)

{

PyTypeObject *tp = Py_TYPE(self);

if (self->lock != NULL)

PyThread_free_lock(self->lock);

EVP_MD_CTX_free(self->ctx);

PyObject_Free(self);

Py_DECREF(tp);

}

static int

locked_EVP_MD_CTX_copy(EVP_MD_CTX *new_ctx_p, EVPobject *self)

{

int result;

ENTER_HASHLIB(self);

result = EVP_MD_CTX_copy(new_ctx_p, self->ctx);

LEAVE_HASHLIB(self);

return result;

}

static PyObject *

EVP_copy_impl(EVPobject *self)

{

EVPobject *newobj;

if ((newobj = newEVPobject(Py_TYPE(self))) == NULL)

return NULL;

if (!locked_EVP_MD_CTX_copy(newobj->ctx, self)) {

Py_DECREF(newobj);

return _setException(PyExc_ValueError, NULL);

}

return (PyObject *)newobj;

}

static PyObject *

EVP_digest_impl(EVPobject *self)

{

unsigned char digest[EVP_MAX_MD_SIZE];

EVP_MD_CTX *temp_ctx;

PyObject *retval;

unsigned int digest_size;

temp_ctx = EVP_MD_CTX_new();

if (temp_ctx == NULL) {

PyErr_NoMemory();

return NULL;

}

if (!locked_EVP_MD_CTX_copy(temp_ctx, self)) {

return _setException(PyExc_ValueError, NULL);

}

digest_size = EVP_MD_CTX_size(temp_ctx);

if (!EVP_DigestFinal(temp_ctx, digest, NULL)) {

_setException(PyExc_ValueError, NULL);

return NULL;

}

retval = PyBytes_FromStringAndSize((const char *)digest, digest_size);

EVP_MD_CTX_free(temp_ctx);

return retval;

}

static PyObject *

EVP_hexdigest_impl(EVPobject *self)

{

unsigned char digest[EVP_MAX_MD_SIZE];

EVP_MD_CTX *temp_ctx;

unsigned int digest_size;

temp_ctx = EVP_MD_CTX_new();

if (temp_ctx == NULL) {

PyErr_NoMemory();

return NULL;

}

/* Get the raw (binary) digest value */

if (!locked_EVP_MD_CTX_copy(temp_ctx, self)) {

return _setException(PyExc_ValueError, NULL);

}

digest_size = EVP_MD_CTX_size(temp_ctx);

if (!EVP_DigestFinal(temp_ctx, digest, NULL)) {

_setException(PyExc_ValueError, NULL);

return NULL;

}

EVP_MD_CTX_free(temp_ctx);

return _Py_strhex((const char *)digest, (Py_ssize_t)digest_size);

}

static PyObject *

EVP_update(EVPobject *self, PyObject *obj)

{

int result;

Py_buffer view;

GET_BUFFER_VIEW_OR_ERROUT(obj, &view);

if (self->lock == NULL && view.len >= HASHLIB_GIL_MINSIZE) {

self->lock = PyThread_allocate_lock();

/* fail? lock = NULL and we fail over to non-threaded code. */

}

if (self->lock != NULL) {

Py_BEGIN_ALLOW_THREADS

PyThread_acquire_lock(self->lock, 1);

result = EVP_hash(self, view.buf, view.len);

PyThread_release_lock(self->lock);

Py_END_ALLOW_THREADS

} else {

result = EVP_hash(self, view.buf, view.len);

}

PyBuffer_Release(&view);

if (result == -1)

return NULL;

Py_RETURN_NONE;

}

static PyMethodDef EVP_methods[] = {

EVP_UPDATE_METHODDEF

EVP_DIGEST_METHODDEF

EVP_HEXDIGEST_METHODDEF

EVP_COPY_METHODDEF

{NULL, NULL} /* sentinel */

};

static PyObject *

EVP_get_block_size(EVPobject *self, void *closure)

{

long block_size;

block_size = EVP_MD_CTX_block_size(self->ctx);

return PyLong_FromLong(block_size);

}

static PyObject *

EVP_get_digest_size(EVPobject *self, void *closure)

{

long size;

size = EVP_MD_CTX_size(self->ctx);

return PyLong_FromLong(size);

}

static PyObject *

EVP_get_name(EVPobject *self, void *closure)

{

return py_digest_name(EVP_MD_CTX_md(self->ctx));

}

static PyGetSetDef EVP_getseters[] = {

{"digest_size",

(getter)EVP_get_digest_size, NULL,

NULL,

NULL},

{"block_size",

(getter)EVP_get_block_size, NULL,

NULL,

NULL},

{"name",

(getter)EVP_get_name, NULL,

NULL,

PyDoc_STR("algorithm name.")},

{NULL} /* Sentinel */

};

static PyObject *

EVP_repr(EVPobject *self)

{

PyObject *name_obj, *repr;

name_obj = py_digest_name(EVP_MD_CTX_md(self->ctx));

if (!name_obj) {

return NULL;

}

repr = PyUnicode_FromFormat("<%U %s object @ %p>",

name_obj, Py_TYPE(self)->tp_name, self);

Py_DECREF(name_obj);

return repr;

}

PyDoc_STRVAR(hashtype_doc,

"digest_size -- number of bytes in this hashes output");

static PyType_Slot EVPtype_slots[] = {

{Py_tp_dealloc, EVP_dealloc},

{Py_tp_repr, EVP_repr},

{Py_tp_doc, (char *)hashtype_doc},

{Py_tp_methods, EVP_methods},

{Py_tp_getset, EVP_getseters},

{0, 0},

};

static PyType_Spec EVPtype_spec = {

"_hashlib.HASH", /*tp_name*/

sizeof(EVPobject), /*tp_basicsize*/

0, /*tp_itemsize*/

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION | Py_TPFLAGS_IMMUTABLETYPE,

EVPtype_slots

};

#ifdef PY_OPENSSL_HAS_SHAKE

static PyObject *

EVPXOF_digest_impl(EVPobject *self, Py_ssize_t length)

{

EVP_MD_CTX *temp_ctx;

PyObject *retval = PyBytes_FromStringAndSize(NULL, length);

if (retval == NULL) {

return NULL;

}

temp_ctx = EVP_MD_CTX_new();

if (temp_ctx == NULL) {

Py_DECREF(retval);

PyErr_NoMemory();

return NULL;

}

if (!locked_EVP_MD_CTX_copy(temp_ctx, self)) {

Py_DECREF(retval);

EVP_MD_CTX_free(temp_ctx);

return _setException(PyExc_ValueError, NULL);

}

if (!EVP_DigestFinalXOF(temp_ctx,

(unsigned char*)PyBytes_AS_STRING(retval),

length)) {

Py_DECREF(retval);

EVP_MD_CTX_free(temp_ctx);

_setException(PyExc_ValueError, NULL);

return NULL;

}

EVP_MD_CTX_free(temp_ctx);

return retval;

}

static PyObject *

EVPXOF_hexdigest_impl(EVPobject *self, Py_ssize_t length)

{

unsigned char *digest;

EVP_MD_CTX *temp_ctx;

PyObject *retval;

digest = (unsigned char*)PyMem_Malloc(length);

if (digest == NULL) {

PyErr_NoMemory();

return NULL;

}

temp_ctx = EVP_MD_CTX_new();

if (temp_ctx == NULL) {

PyMem_Free(digest);

PyErr_NoMemory();

return NULL;

}

/* Get the raw (binary) digest value */

if (!locked_EVP_MD_CTX_copy(temp_ctx, self)) {

PyMem_Free(digest);

EVP_MD_CTX_free(temp_ctx);

return _setException(PyExc_ValueError, NULL);

}

if (!EVP_DigestFinalXOF(temp_ctx, digest, length)) {

PyMem_Free(digest);

EVP_MD_CTX_free(temp_ctx);

_setException(PyExc_ValueError, NULL);

return NULL;

}

EVP_MD_CTX_free(temp_ctx);

retval = _Py_strhex((const char *)digest, length);

PyMem_Free(digest);

return retval;

}

static PyMethodDef EVPXOF_methods[] = {

EVPXOF_DIGEST_METHODDEF

EVPXOF_HEXDIGEST_METHODDEF

{NULL, NULL} /* sentinel */

};

static PyObject *

EVPXOF_get_digest_size(EVPobject *self, void *closure)

{

return PyLong_FromLong(0);

}

static PyGetSetDef EVPXOF_getseters[] = {

{"digest_size",

(getter)EVPXOF_get_digest_size, NULL,

NULL,

NULL},

{NULL} /* Sentinel */

};

PyDoc_STRVAR(hashxoftype_doc,

"digest_size -- number of bytes in this hashes output");

static PyType_Slot EVPXOFtype_slots[] = {

{Py_tp_doc, (char *)hashxoftype_doc},

{Py_tp_methods, EVPXOF_methods},

{Py_tp_getset, EVPXOF_getseters},

{0, 0},

};

static PyType_Spec EVPXOFtype_spec = {

"_hashlib.HASHXOF", /*tp_name*/

sizeof(EVPobject), /*tp_basicsize*/

0, /*tp_itemsize*/

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION | Py_TPFLAGS_IMMUTABLETYPE,

EVPXOFtype_slots

};

static PyObject*

py_evp_fromname(PyObject *module, const char *digestname, PyObject *data_obj,

int usedforsecurity)

{

Py_buffer view = { 0 };

PY_EVP_MD *digest = NULL;

PyTypeObject *type;

EVPobject *self = NULL;

if (data_obj != NULL) {

GET_BUFFER_VIEW_OR_ERROUT(data_obj, &view);

}

digest = py_digest_by_name(

module, digestname, usedforsecurity ? Py_ht_evp : Py_ht_evp_nosecurity

);

if (digest == NULL) {

goto exit;

}

if ((EVP_MD_flags(digest) & EVP_MD_FLAG_XOF) == EVP_MD_FLAG_XOF) {

type = get_hashlib_state(module)->EVPXOFtype;

} else {

type = get_hashlib_state(module)->EVPtype;

}

self = newEVPobject(type);

if (self == NULL) {

goto exit;

}

#if defined(EVP_MD_CTX_FLAG_NON_FIPS_ALLOW) && OPENSSL_VERSION_NUMBER < 0x30000000L

// In OpenSSL 1.1.1 the non FIPS allowed flag is context specific while

// in 3.0.0 it is a different EVP_MD provider.

if (!usedforsecurity) {

EVP_MD_CTX_set_flags(self->ctx, EVP_MD_CTX_FLAG_NON_FIPS_ALLOW);

}

int result = EVP_DigestInit_ex(self->ctx, digest, NULL);

if (!result) {

_setException(PyExc_ValueError, NULL);

Py_CLEAR(self);

goto exit;

}

if (view.buf && view.len) {

if (view.len >= HASHLIB_GIL_MINSIZE) {

Py_BEGIN_ALLOW_THREADS

result = EVP_hash(self, view.buf, view.len);

Py_END_ALLOW_THREADS

} else {

result = EVP_hash(self, view.buf, view.len);

}

if (result == -1) {

Py_CLEAR(self);

goto exit;

}

}

exit:

if (data_obj != NULL) {

PyBuffer_Release(&view);

}

if (digest != NULL) {

PY_EVP_MD_free(digest);

}

return (PyObject *)self;

}

static PyObject *

EVP_new_impl(PyObject *module, PyObject *name_obj, PyObject *data_obj,

int usedforsecurity)

{

char *name;

if (!PyArg_Parse(name_obj, "s", &name)) {

PyErr_SetString(PyExc_TypeError, "name must be a string");

return NULL;

}

return py_evp_fromname(module, name, data_obj, usedforsecurity);

}

static PyObject *

_hashlib_openssl_md5_impl(PyObject *module, PyObject *data_obj,

int usedforsecurity)

{

return py_evp_fromname(module, Py_hash_md5, data_obj, usedforsecurity);

}

static PyObject *

_hashlib_openssl_sha1_impl(PyObject *module, PyObject *data_obj,

int usedforsecurity)

{

return py_evp_fromname(module, Py_hash_sha1, data_obj, usedforsecurity);

}