shell bypass 403

GrazzMean Shell

: /proc/thread-self/root/proc/thread-self/cwd/ [ drwxr-xr-x ]
Uname: Linux web3.us.cloudlogin.co 5.10.226-xeon-hst #2 SMP Fri Sep 13 12:28:44 UTC 2024 x86_64
Software: Apache
PHP version: 8.1.31 [ PHP INFO ] PHP os: Linux
Server Ip: 162.210.96.117
Your Ip: 3.145.94.199
User: edustar (269686) | Group: tty (888)
Safe Mode: OFF
Disable Function:
NONE
upload mass deface mass delete console

name : mutils.zip 
PK�{FZ�2U�##	mglobal.hnu�[���/*
 *    Copyright (C) 2005 Jonathan Day, Nikos Mavroyanopoulos
 *
 *    This library is free software; you can redistribute it and/or modify it 
 *    under the terms of the GNU Library General Public License as published 
 *    by the Free Software Foundation; either version 2 of the License, or 
 *    (at your option) any later version.
 *
 *    This library is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *    Library General Public License for more details.
 *
 *    You should have received a copy of the GNU Library General Public
 *    License along with this library; if not, write to the
 *    Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 *    Boston, MA 02111-1307, USA.
 */


#if !defined(__MGLOBAL_H)
#define __MGLOBAL_H

#define MHASH_API_NONE          0
#define MHASH_API_CLASSIC       1
#define MHASH_API_FAMILY        2

#define MHASH_API_VERSION 20060101
#define MHASH_API_TYPE MHASH_API_CLASSIC
/* #define MHASH_API_TYPE MHASH_API_FAMILY */
#define MHASH_API_FULL

typedef enum __hashid {
#if (MHASH_API_TYPE == MHASH_API_CLASSIC)
	MHASH_CRC32		=  0,
	MHASH_MD5		=  1,
	MHASH_SHA1		=  2,
	MHASH_HAVAL256		=  3,
	MHASH_RIPEMD160		=  5,
	MHASH_TIGER192		=  7,
	MHASH_GOST		=  8,
	MHASH_CRC32B		=  9,
	MHASH_HAVAL224		= 10,
	MHASH_HAVAL192		= 11,
	MHASH_HAVAL160		= 12,
	MHASH_HAVAL128		= 13,
	MHASH_TIGER128		= 14,
	MHASH_TIGER160		= 15,
	MHASH_MD4		= 16,
	MHASH_SHA256		= 17,
	MHASH_ADLER32		= 18,
	MHASH_SHA224		= 19,
	MHASH_SHA512		= 20,
	MHASH_SHA384		= 21,
	MHASH_WHIRLPOOL		= 22,
	MHASH_RIPEMD128		= 23,
	MHASH_RIPEMD256		= 24,
	MHASH_RIPEMD320		= 25,
	MHASH_SNEFRU128		= 26,
	MHASH_SNEFRU256		= 27,
	MHASH_MD2		= 28,
	MHASH_AR		= 64, /* NOT YET IMPLEMENTED */
	MHASH_BOOGNISH		= 65, /* NOT YET IMPLEMENTED */
	MHASH_CELLHASH		= 66, /* NOT YET IMPLEMENTED */
	MHASH_FFT_HASH_I	= 67, /* NOT YET IMPLEMENTED */
	MHASH_FFT_HASH_II	= 68, /* NOT YET IMPLEMENTED */
	MHASH_NHASH		= 69, /* NOT YET IMPLEMENTED */
	MHASH_PANAMA		= 70, /* NOT YET IMPLEMENTED */
	MHASH_SMASH		= 71, /* NOT YET IMPLEMENTED */
	MHASH_SUBHASH		= 72  /* NOT YET IMPLEMENTED */
#endif
#if (MHASH_API_TYPE == MHASH_API_FAMILY)
	MHASH_CRC32		= 0x0001,
	MHASH_CRC32B		= 0x0002,
	MHASH_ADLER32		= 0x0011,
	MHASH_MD2		= 0x0101,
	MHASH_MD4		= 0x0111,
	MHASH_RIPEMD128		= 0x0112,
	MHASH_RIPEMD160		= 0x0113,
	MHASH_RIPEMD256		= 0x0114,
	MHASH_RIPEMD320		= 0x0115,
	MHASH_MD5		= 0x0121,
	MHASH_SHA1		= 0x0201,
	MHASH_SHA224		= 0x0201,
	MHASH_SHA256		= 0x0202,
	MHASH_SHA384		= 0x0203,
	MHASH_SHA512		= 0x0204,
	MHASH_HAVAL128		= 0x0301,
	MHASH_HAVAL160		= 0x0302,
	MHASH_HAVAL192		= 0x0303,
	MHASH_HAVAL224		= 0x0304,
	MHASH_HAVAL256		= 0x0305, /* 3 passes */
	MHASH_TIGER128		= 0x0401,
	MHASH_TIGER160		= 0x0402,
	MHASH_TIGER192		= 0x0403,
	MHASH_GOST		= 0x0501,
	MHASH_WHIRLPOOL		= 0x0601,
	MHASH_SNEFRU128		= 0x0701, /* 8 passes */
	MHASH_SNEFRU256		= 0x0702, /* 8 passes */
	MHASH_AR		= 0x0801, /* NOT YET IMPLEMENTED */
	MHASH_BOOGNISH		= 0x0901, /* NOT YET IMPLEMENTED */
	MHASH_CELLHASH		= 0x0a01, /* NOT YET IMPLEMENTED */
	MHASH_FFT_HASH_I	= 0x0b01, /* NOT YET IMPLEMENTED */
	MHASH_FFT_HASH_II	= 0x0b02, /* NOT YET IMPLEMENTED */
	MHASH_NHASH		= 0x0c01, /* NOT YET IMPLEMENTED */
	MHASH_PANAMA		= 0x0d01, /* NOT YET IMPLEMENTED */
	MHASH_SMASH		= 0x0e01, /* NOT YET IMPLEMENTED */
	MHASH_SUBHASH		= 0x0f01  /* NOT YET IMPLEMENTED */
#endif
} hashid;

/* These aliases are actually quite useful and so will be kept */

#define MHASH_HAVAL MHASH_HAVAL256
#define MHASH_TIGER MHASH_TIGER192

typedef enum __keygenid {
	KEYGEN_MCRYPT,		/* The key generator used in mcrypt */
	KEYGEN_ASIS,		/* Just returns the password as binary key */
	KEYGEN_HEX,		/* Just converts a hex key into a binary one */
	KEYGEN_PKDES,		/* The transformation used in Phil Karn's DES
				 * encryption program */
	KEYGEN_S2K_SIMPLE,	/* The OpenPGP (rfc2440) Simple S2K */
	KEYGEN_S2K_SALTED,	/* The OpenPGP Salted S2K */
	KEYGEN_S2K_ISALTED	/* The OpenPGP Iterated Salted S2K */
} keygenid;

#endif
PK�{FZ�efN66mtypes.hnu�[���/*
 *    Copyright (C) 2005 Jonathan Day, Nikos Mavroyanopoulos
 *
 *    This library is free software; you can redistribute it and/or modify it 
 *    under the terms of the GNU Library General Public License as published 
 *    by the Free Software Foundation; either version 2 of the License, or 
 *    (at your option) any later version.
 *
 *    This library is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *    Library General Public License for more details.
 *
 *    You should have received a copy of the GNU Library General Public
 *    License along with this library; if not, write to the
 *    Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 *    Boston, MA 02111-1307, USA.
 */


#if !defined(__MTYPES_H)
#define __MTYPES_H

#include <mutils/mutils.h>

typedef struct __KEYGEN
{
	hashid		 hash_algorithm[2];
	mutils_word32	 count;
	void		*salt;
	mutils_word32	 salt_size;
} KEYGEN;

typedef void (*INIT_FUNC)( void*);
typedef void (*HASH_FUNC)(void*, const void*, int);
typedef void (*FINAL_FUNC)(void*);
typedef void (*DEINIT_FUNC)(void*, unsigned char*);

typedef struct __MHASH_INSTANCE
{
	mutils_word32 hmac_key_size;
	mutils_word32 hmac_block;
	mutils_word8 *hmac_key;

	mutils_word8 *state;
	mutils_word32 state_size;
	hashid algorithm_given;

	HASH_FUNC hash_func;
	FINAL_FUNC final_func;
	DEINIT_FUNC deinit_func;
} MHASH_INSTANCE;

typedef MHASH_INSTANCE *MHASH;

#define MHASH_FAILED ((MHASH) 0x0)

#endif
PK�{FZ_�r�	�	mincludes.hnu�[���/*
 *    Copyright (C) 2005 Jonathan Day, Nikos Mavroyanopoulos
 *
 *    This library is free software; you can redistribute it and/or modify it 
 *    under the terms of the GNU Library General Public License as published 
 *    by the Free Software Foundation; either version 2 of the License, or 
 *    (at your option) any later version.
 *
 *    This library is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *    Library General Public License for more details.
 *
 *    You should have received a copy of the GNU Library General Public
 *    License along with this library; if not, write to the
 *    Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 *    Boston, MA 02111-1307, USA.
 */


/*
 * The function of this header is to make sure that all system-specific headers
 * files that are required are included. Eventually, system headers will only
 * be pulled in when local definitions don't exist or are suboptimal.
 *
 * For now, we're also defining MAXINT and MININT in here, as there are
 * reported problems with the way we're trying to find it.
 */

#if !defined(__MINCLUDES_H)
#define __MINCLUDES_H

#if defined(MUTILS_USE_MHASH_CONFIG)
#include <mutils/mhash_config.h>
#endif

#if defined(HAVE_LIMITS_H)
#include <limits.h>
#endif

#if defined(HAVE_STDBOOL_H)
#include <stdbool.h>
#endif

#if defined(HAVE_CTYPE_H)
#include <ctype.h>
#endif

#if defined(HAVE_SYS_TYPES_H)
#include <sys/types.h>
#endif

#if defined(HAVE_ASSERT_H)
#include <assert.h>
#endif

#if defined(HAVE_STRINGS_H)
#include <strings.h>
#endif

#if defined(HAVE_STRING_H)
#include <string.h>
#endif

#if defined(HAVE_MALLOC_H)
#include <malloc.h>
#endif

#if defined(HAVE_STDIO_H)
#include <stdio.h>
#endif

#if defined(HAVE_STDLIB_H)
#include <stdlib.h>
#endif

#if defined(HAVE_UNISTD_H)
#include <unistd.h>
#endif

#if defined(HAVE_VALUES_H)
#include <values.h>
#endif

#if defined(HAVE_SYS_MMAN_H)
#include <sys/mman.h>
#endif

#if defined(HAVE_ERRNO_H)
#include <errno.h>
#endif

#if defined(HAVE_ERROR_H)
#include <error.h>
#endif

#if defined(HAVE_INTTYPES_H)
#include <inttypes.h>
#endif

#if defined(HAVE_STDINT_H)
#include <stdint.h>
#endif

#if !defined(INT_MAX)
#define INT_MAX ((int) (~0U>>1))
#endif

#if !defined(MAXINT)
#define MAXINT INT_MAX
#endif

#if !defined(INT_MIN)
#define INT_MIN (-INT_MAX - 1)
#endif

#if !defined(MININT)
#define MININT INT_MIN
#endif

#endif
PK�{FZP�1��mutils.hnu�[���/*
 *    Copyright (C) 2005 Jonathan Day, Nikos Mavroyanopoulos
 *
 *    This library is free software; you can redistribute it and/or modify it 
 *    under the terms of the GNU Library General Public License as published 
 *    by the Free Software Foundation; either version 2 of the License, or 
 *    (at your option) any later version.
 *
 *    This library is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *    Library General Public License for more details.
 *
 *    You should have received a copy of the GNU Library General Public
 *    License along with this library; if not, write to the
 *    Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 *    Boston, MA 02111-1307, USA.
 */


#if !defined(__MUTILS_H)
#define __MUTILS_H

#include <mutils/mincludes.h>

#if defined(const)
#define __const const
#endif 

/*
 * The vast majority of user code won't care about mutils, so changes to
 * this helper library API should not result in a change to the MHASH API
 * version number.
 */

#define MUTILS_API 20060624

/* FIXME: We're assuming we've a standard integer types header and that it has been included
 * correctly.
 */

#define MUTILS_STANDARD_TYPES 1

#if defined(MUTILS_STANDARD_TYPES)

#define TIGER_64BIT

#define mutils_word64 uint64_t
#define mutils_word32 uint32_t
#define mutils_word16 uint16_t
#define mutils_word8 uint8_t

#else /* Ok, we don't have the standard integer type definitions */

#if SIZEOF_UNSIGNED_LONG_INT == 8
typedef unsigned long int mutils_word64;
#define TIGER_64BIT
#elif SIZEOF_UNSIGNED_LONG_LONG_INT == 8
typedef unsigned long long int mutils_word64;
#else
#error "Cannot find a 64 bit integer in your system, sorry."
#endif

#if SIZEOF_UNSIGNED_LONG_INT == 4
typedef unsigned long int mutils_word32;
#elif SIZEOF_UNSIGNED_INT == 4
typedef unsigned int mutils_word32;
#else
#error "Cannot find a 32 bit integer in your system, sorry."
#endif

#if SIZEOF_UNSIGNED_INT == 2
typedef unsigned int mutils_word16;
#elif SIZEOF_UNSIGNED_SHORT_INT == 2
typedef unsigned short int mutils_word16;
#else
#error "Cannot find a 16 bit integer in your system, sorry."
#endif

#if SIZEOF_UNSIGNED_CHAR == 1
typedef unsigned char mutils_word8;
#else
#error "Cannot find an 8 bit char in your system, sorry."
#endif

#endif /* End of standard integer type declarationsd */

/*
 * Due to buggy implementations of the boolean headers in some systems,
 * we have to detect the boolean values seperately from the boolean type.
 * A big thank you to Heiko Lehmann for spotting the bug. Unfortunately,
 * this fix may not be enough, as it is only going to work on things the
 * precompiler knows about.
 *
 * Why go to all this trouble over something that should have a standard
 * value anyway? Because.
 */

#if defined(HAVE__BOOL)
#define mutils_boolean _Bool
#else
typedef char mutils_boolean;
#endif

#if defined(false)
#define MUTILS_FALSE (mutils_boolean) false
#else
#if defined(FALSE)
#define MUTILS_FALSE (mutils_boolean) FALSE
#else
#define MUTILS_FALSE (mutils_boolean) 0
#endif /* FALSE */
#endif /* false */

#if defined(true)
#define MUTILS_TRUE (mutils_boolean) true
#else
#if defined(TRUE)
#define MUTILS_TRUE (mutils_boolean) TRUE
#else
#define MUTILS_TRUE (mutils_boolean) -1
#endif /* TRUE */
#endif /* true */

/*
 * Other than OK, the only defined values should be for a category of error.
 * Even then, the values shouldn't be assumed. Their only function is to
 * make it easy to programmatically identify the nature of the error and to
 * ensure a library upgrade won't break existing binaries, should new error
 * codes be introduced.
 */

typedef enum __mutils_error_codes
{
	MUTILS_OK			= 0,
	MUTILS_SYSTEM_ERROR		= 0x100,
	MUTILS_UNSPECIFIED_ERROR,
	MUTILS_SYSTEM_RESOURCE_ERROR,
	MUTILS_PARAMETER_ERROR		= 0x200,
	MUTILS_INVALID_FUNCTION,
	MUTILS_INVALID_INPUT_BUFFER,
	MUTILS_INVALID_OUTPUT_BUFFER,
	MUTILS_INVALID_PASSES,
	MUTILS_INVALID_FORMAT,
	MUTILS_INVALID_SIZE,
	MUTILS_INVALID_RESULT
} mutils_error_codes;

#define mutils_error mutils_word32

#include <mutils/mglobal.h>

/*
 * Some useful, generic endian macros.
 */

#define mutils_swapendian64(x) \
	((mutils_word64) \
		(((x) & 0xff00000000000000ull) >> 56) |	\
		(((x) & 0x00ff000000000000ull) >> 40) |	\
		(((x) & 0x0000ff0000000000ull) >> 24) | \
		(((x) & 0x000000ff00000000ull) >>  8) | \
		(((x) & 0x00000000ff000000ull) <<  8) | \
		(((x) & 0x0000000000ff0000ull) << 24) | \
		(((x) & 0x000000000000ff00ull) << 40) | \
	 	(((x) & 0x00000000000000ffull) << 56))

#define mutils_swapendian32(a) \
	((mutils_word32) \
		(((a & (mutils_word32) 0x000000ffU) << 24) | \
		 ((a & (mutils_word32) 0x0000ff00U) << 8)  | \
		 ((a & (mutils_word32) 0x00ff0000U) >> 8)  | \
		 ((a & (mutils_word32) 0xff000000U) >> 24))  \
	)

#define mutils_swapendian16(a) \
	((mutils_word16) \
		(((a & (mutils_word16) 0x00ffU) << 8) | \
		 ((a & (mutils_word16) 0xff00U) >> 8))  \
	 )



/* Change the endianness of the data if (and only if) the data type we want
 * is the opposite from the native endianness. This allows us to have some
 * reasonably generic macros, provided we always start from the native
 * ordering.
 */

#if defined(WORDS_BIGENDIAN)

#define mutils_lend64(n) mutils_swapendian64(n)
#define mutils_lend32(n) mutils_swapendian32(n)
#define mutils_lend16(n) mutils_swapendian16(n)

#define mutils_bend64(n) n
#define mutils_bend32(n) n
#define mutils_bend16(n) n

#define mutils_lend2sys64(n) mutils_swapendian64(n)
#define mutils_lend2sys32(n) mutils_swapendian32(n)
#define mutils_lend2sys16(n) mutils_swapendian16(n)

#define mutils_bend2sys32(n) n
#define mutils_bend2sys16(n) n

#else

#define mutils_lend64(n) n
#define mutils_lend32(n) n
#define mutils_lend16(n) n

#define mutils_bend64(n) mutils_swapendian64(n)
#define mutils_bend32(n) mutils_swapendian32(n)
#define mutils_bend16(n) mutils_swapendian16(n)

#define mutils_lend2sys64(n) n
#define mutils_lend2sys32(n) n
#define mutils_lend2sys16(n) n

#define mutils_bend2sys64(n) mutils_swapendian64(n)
#define mutils_bend2sys32(n) mutils_swapendian32(n)
#define mutils_bend2sys16(n) mutils_swapendian16(n)

#endif

int mutils_mlock(__const void *addr, __const mutils_word32 len);
int mutils_munlock(__const void *addr, __const mutils_word32 len);

void *mutils_malloc(__const mutils_word32 n);
void *mutils_realloc(__const void *ptr, __const mutils_word32 n);
void mutils_free(__const void *ptr);
void mutils_bzero(void *s, __const mutils_word32 n);

void mutils_memset(void *dest, __const mutils_word8 c, __const mutils_word32 n);
void mutils_memcpy(void *dest, __const void *src, __const mutils_word32 n);
void mutils_memmove(void *dest, __const void *src, __const mutils_word32 n);
int mutils_memcmp(__const void *s1, __const void *s2, __const mutils_word32 n);

mutils_word32 mutils_strlen(__const mutils_word8 *str);
mutils_word8 *mutils_strdup(__const mutils_word8 *str);
mutils_word8 *mutils_strcat(mutils_word8 *dest, __const mutils_word8 *src);
mutils_word8 *mutils_strcpy(mutils_word8 *dest, __const mutils_word8 *src);
mutils_word8 *mutils_strncpy(mutils_word8 *dest, __const mutils_word8 *src, __const mutils_word32 n);
int mutils_strcmp(__const mutils_word8 *src1, __const mutils_word8 *src2);
int mutils_strncmp(__const mutils_word8 *src1, __const mutils_word8 *src2, __const mutils_word32 n);
long mutils_strtol(__const mutils_word8 *nptr, mutils_word8 **endptr, __const mutils_word8 base);

mutils_word32 mutils_word32swap(mutils_word32 x);
mutils_word32 *mutils_word32nswap(mutils_word32 *x, mutils_word32 n, mutils_boolean destructive);

mutils_word8 *mutils_asciify(mutils_word8 *in, __const mutils_word32 len);
mutils_boolean mutils_thequals(mutils_word8 *text, mutils_word8 *hash, __const mutils_word32 len);

#endif /* __MUTILS_H */
PK�{FZ+!�mhash.hnu�[���/*
 *    Copyright (C) 1998 Nikos Mavroyanopoulos
 *    Copyright (C) 1999,2000 Sascha Schumman, Nikos Mavroyanopoulos
 *    Copyright (C) 2001 Nikos Mavroyanopoulos
 *    Copyright (C) 2004,2005,2006,2007,2008 MHash Development Group 
*
 *    This library is free software; you can redistribute it and/or modify it 
 *    under the terms of the GNU Library General Public License as published 
 *    by the Free Software Foundation; either version 2 of the License, or 
 *    (at your option) any later version.
 *
 *    This library is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *    Library General Public License for more details.
 *
 *    You should have received a copy of the GNU Library General Public
 *    License along with this library; if not, write to the
 *    Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 *    Boston, MA 02111-1307, USA.
 */


#if !defined(__MUTILS_MHASH_H)
#define __MUTILS_MHASH_H

/* $Id: mhash.h,v 1.2 2006/01/09 07:27:04 imipak Exp $ */

#if defined(MUTILS_USE_MHASH_CONFIG)
#include <mutils/mhash_config.h>
#endif

#include <mutils/mglobal.h>
#include <mutils/mutils.h>
#include <mutils/mtypes.h>

#ifdef __cplusplus
extern "C" {
#endif

/* these are for backwards compatibility and will 
   be removed at some time */
#ifdef MHASH_BACKWARDS_COMPATIBLE
# define hmac_mhash_init mhash_hmac_init
# define hmac_mhash_end mhash_hmac_end
#endif

/* typedefs */

typedef struct mhash_hash_entry mhash_hash_entry;

#if defined(PROTOTYPES)

/* information prototypes */

mutils_word32 mhash_count(void);
mutils_word32 mhash_get_block_size(hashid type);
mutils_word8 *mhash_get_hash_name(hashid type);
void mhash_free(void *ptr);

__const mutils_word8 *mhash_get_hash_name_static(hashid type);

/* initializing prototypes */

MHASH mhash_init(hashid type);

/* copy prototypes */

MHASH mhash_cp(MHASH from);

/* update prototype */

mutils_boolean mhash(MHASH thread, const void *plaintext, mutils_word32 size);

/* finalizing prototype */

void *mhash_end(MHASH thread);
void *mhash_end_m(MHASH thread, void *(*hash_malloc) (mutils_word32));
void mhash_deinit(MHASH thread, void *result);

/* informational */

mutils_word32 mhash_get_hash_pblock(hashid type);
hashid mhash_get_mhash_algo(MHASH tmp);

/* HMAC */

MHASH mhash_hmac_init(const hashid type, void *key, mutils_word32 keysize, mutils_word32 block);
void *mhash_hmac_end_m(MHASH thread, void *(*hash_malloc) (mutils_word32));
void *mhash_hmac_end(MHASH thread);
mutils_boolean mhash_hmac_deinit(MHASH thread, void *result);

/* Save state functions */

mutils_boolean mhash_save_state_mem(MHASH thread, void *mem, mutils_word32 *mem_size);
MHASH mhash_restore_state_mem(void *mem);

/* Key generation functions */

mutils_error mhash_keygen(keygenid algorithm, hashid opt_algorithm,
			  mutils_word64 count,
			  void *keyword, mutils_word32 keysize,
			  void *salt, mutils_word32 saltsize,
			  mutils_word8 *password, mutils_word32 passwordlen);

mutils_error mhash_keygen_ext(keygenid algorithm, KEYGEN data,
			      void *keyword, mutils_word32 keysize,
			      mutils_word8 *password, mutils_word32 passwordlen);

mutils_word8 *mhash_get_keygen_name(keygenid type);

mutils_word32 mhash_get_keygen_salt_size(keygenid type);
mutils_word32 mhash_get_keygen_max_key_size(keygenid type);
mutils_word32 mhash_keygen_count(void);

mutils_boolean mhash_keygen_uses_salt(keygenid type);
mutils_boolean mhash_keygen_uses_count(keygenid type);
mutils_boolean mhash_keygen_uses_hash_algorithm(keygenid type);

#else

/* information prototypes */

mutils_word32 mhash_count();
mutils_word32 mhash_get_block_size();
mutils_word8 *mhash_get_hash_name();
void mhash_free();

__const mutils_word8 *mhash_get_hash_name_static();

/* initializing prototypes */

MHASH mhash_init();

/* copy prototypes */

MHASH mhash_cp();

/* update prototype */

mutils_boolean mhash();

/* finalizing prototype */

void *mhash_end();
void *mhash_end_m();
void mhash_deinit();

/* informational */

mutils_word32 mhash_get_hash_pblock();
hashid mhash_get_mhash_algo();

/* HMAC */

MHASH mhash_hmac_init();
void *mhash_hmac_end_m();
void *mhash_hmac_end();
mutils_boolean mhash_hmac_deinit();

/* Save state functions */

mutils_boolean mhash_save_state_mem();
MHASH mhash_restore_state_mem();

/* Key generation functions */

mutils_error mhash_keygen();
mutils_error mhash_keygen_ext();

mutils_word8 *mhash_get_keygen_name();

mutils_word32 mhash_get_keygen_salt_size();
mutils_word32 mhash_get_keygen_max_key_size();
mutils_word32 mhash_keygen_count();

mutils_boolean mhash_keygen_uses_salt();
mutils_boolean mhash_keygen_uses_count();
mutils_boolean mhash_keygen_uses_hash_algorithm();

#endif

#ifdef __cplusplus
}
#endif
#endif				/* !MHASH_H */
PK�{FZ���>uumhash_config.hnu�[���/* include/mutils/mhash_config.h.  Generated from mhash_config.h.in by configure.  */
/* include/mutils/mhash_config.h.in.  Generated from configure.in by autoheader.  */

/* "Adler32 Algorithm" */
#define ENABLE_ADLER32 1

/* "CRC32 Algorithm" */
#define ENABLE_CRC32 1

/* "GOST Algorithm" */
#define ENABLE_GOST 1

/* "Haval Algorithm" */
#define ENABLE_HAVAL 1

/* "MD-2 Algorithm" */
#define ENABLE_MD2 1

/* "MD-4 Algorithm" */
#define ENABLE_MD4 1

/* "MD-5 Algorithm" */
#define ENABLE_MD5 1

/* "RIPE-MD - RIPE Substitute for MD" */
#define ENABLE_RIPEMD 1

/* "SHA-1 Algorithm" */
#define ENABLE_SHA1 1

/* "SHA-224 and SHA-256 - SHA-2 Algorithms" */
#define ENABLE_SHA256_SHA224 1

/* "SHA-384 and SHA-512 - SHA-2 Algorithms" */
#define ENABLE_SHA512_SHA384 1

/* "Snefru Algorithm" */
#define ENABLE_SNEFRU 1

/* "Tiger Algorithm" */
#define ENABLE_TIGER 1

/* "Whirlpool Algorithm" */
#define ENABLE_WHIRLPOOL 1

/* Define to 1 if you have the <assert.h> header file. */
#define HAVE_ASSERT_H 1

/* Define to 1 if you have the `bcopy' function. */
#define HAVE_BCOPY 1

/* Define to 1 if you have the <byteswap.h> header file. */
#define HAVE_BYTESWAP_H 1

/* Define to 1 if you have the `bzero' function. */
#define HAVE_BZERO 1

/* Define to 1 if you have the <ctype.h> header file. */
#define HAVE_CTYPE_H 1

/* Define to 1 if you have the <dlfcn.h> header file. */
#define HAVE_DLFCN_H 1

/* Define to 1 if you have the <endian.h> header file. */
#define HAVE_ENDIAN_H 1

/* Define to 1 if you have the <errno.h> header file. */
#define HAVE_ERRNO_H 1

/* Define to 1 if you have the `fcntl' function. */
#define HAVE_FCNTL 1

/* Define to 1 if you have the <fcntl.h> header file. */
#define HAVE_FCNTL_H 1

/* Define to 1 if you have the `fsync' function. */
#define HAVE_FSYNC 1

/* Define to 1 if you have the <inttypes.h> header file. */
#define HAVE_INTTYPES_H 1

/* Define to 1 if you have the `dmalloc' library (-ldmalloc). */
/* #undef HAVE_LIBDMALLOC */

/* Define to 1 if you have the <limits.h> header file. */
#define HAVE_LIMITS_H 1

/* Define to 1 if you have the `lstat' function. */
#define HAVE_LSTAT 1

/* Define to 1 if your system has a GNU libc compatible `malloc' function, and
   to 0 otherwise. */
#define HAVE_MALLOC 1

/* Define to 1 if you have the <malloc.h> header file. */
#define HAVE_MALLOC_H 1

/* Define to 1 if you have the `memmove' function. */
#define HAVE_MEMMOVE 1

/* Define to 1 if you have the <memory.h> header file. */
#define HAVE_MEMORY_H 1

/* Define to 1 if you have the `memset' function. */
#define HAVE_MEMSET 1

/* Define to 1 if you have the `mlock' function. */
#define HAVE_MLOCK 1

/* Define to 1 if you have the `readdir' function. */
#define HAVE_READDIR 1

/* Define to 1 if you have the `readdir_r' function. */
#define HAVE_READDIR_R 1

/* Define to 1 if you have the `sigaction' function. */
#define HAVE_SIGACTION 1

/* Define to 1 if you have the `signal' function. */
#define HAVE_SIGNAL 1

/* Define to 1 if you have the <signal.h> header file. */
#define HAVE_SIGNAL_H 1

/* Define to 1 if you have the `stat' function. */
#define HAVE_STAT 1

/* Define to 1 if stdbool.h conforms to C99. */
#define HAVE_STDBOOL_H 1

/* Define to 1 if you have the <stdint.h> header file. */
#define HAVE_STDINT_H 1

/* Define to 1 if you have the <stdio.h> header file. */
#define HAVE_STDIO_H 1

/* Define to 1 if you have the <stdlib.h> header file. */
#define HAVE_STDLIB_H 1

/* Define to 1 if you have the <strings.h> header file. */
#define HAVE_STRINGS_H 1

/* Define to 1 if you have the <string.h> header file. */
#define HAVE_STRING_H 1

/* Define to 1 if you have the `strtol' function. */
#define HAVE_STRTOL 1

/* Define to 1 if you have the <sys/endian.h> header file. */
/* #undef HAVE_SYS_ENDIAN_H */

/* Define to 1 if you have the <sys/mman.h> header file. */
#define HAVE_SYS_MMAN_H 1

/* Define to 1 if you have the <sys/stat.h> header file. */
#define HAVE_SYS_STAT_H 1

/* Define to 1 if you have the <sys/types.h> header file. */
#define HAVE_SYS_TYPES_H 1

/* Define to 1 if you have the `umask' function. */
#define HAVE_UMASK 1

/* Define to 1 if you have the <unistd.h> header file. */
#define HAVE_UNISTD_H 1

/* Define to 1 if you have the `utime' function. */
#define HAVE_UTIME 1

/* Define to 1 if you have the <utime.h> header file. */
#define HAVE_UTIME_H 1

/* Define to 1 if you have the <values.h> header file. */
#define HAVE_VALUES_H 1

/* Define to 1 if the system has the type `_Bool'. */
#define HAVE__BOOL 1

/* "MHash Version" */
#define MHASH_VERSION PROGRAM_VERSION

/* Define to 1 if your C compiler doesn't accept -c and -o together. */
/* #undef NO_MINUS_C_MINUS_O */

/* Define to 1 if the C compiler supports function prototypes. */
#define PROTOTYPES 1

/* Define to 1 if you have the ANSI C header files. */
#define STDC_HEADERS 1

/* dmalloc */
/* #undef USE_DMALLOC */

/* Define if using the dmalloc debugging malloc package */
/* #undef WITH_DMALLOC */

/* Define to 1 if your processor stores words with the most significant byte
   first (like Motorola and SPARC, unlike Intel and VAX). */
/* #undef WORDS_BIGENDIAN */

/* Define to 1 if on AIX 3.
   System headers sometimes define this.
   We just want to avoid a redefinition error message.  */
#ifndef _ALL_SOURCE
# define _ALL_SOURCE 1
#endif

/* Enable GNU extensions on systems that have them.  */
#ifndef _GNU_SOURCE
# define _GNU_SOURCE 1
#endif

/* Define to 1 if on MINIX. */
/* #undef _MINIX */

/* Define to 2 if the system does not provide POSIX.1 features except with
   this defined. */
/* #undef _POSIX_1_SOURCE */

/* Define to 1 if you need to in order for `stat' and other things to work. */
/* #undef _POSIX_SOURCE */

/* Define like PROTOTYPES; this can be used by system headers. */
#define __PROTOTYPES 1

/* Define to empty if `const' does not conform to ANSI C. */
/* #undef const */

/* Define to `__inline__' or `__inline' if that's what the C compiler
   calls it, or to nothing if 'inline' is not supported under any name.  */
#ifndef __cplusplus
/* #undef inline */
#endif

/* Define to rpl_malloc if the replacement function should be used. */
/* #undef malloc */

/* Define to `unsigned int' if <sys/types.h> does not define. */
/* #undef size_t */
PK�{FZS�{r��mcrypt.hnu�[���/*
 * Copyright (C) 1998,1999,2002 Nikos Mavroyanopoulos
 *
 * Encryption/decryption library. This library is free software;
 * you can redistribute it and/or modify it under the terms of the
 * GNU Library General Public License as published by the Free Software
 * Foundation; either version 2 of the License, or (at your option) any
 * later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */


#define MCRYPT_API_VERSION 20021217

#define LIBMCRYPT_VERSION "2.5.8"

#ifdef __cplusplus
extern "C" {
#endif
/* Definitions
 */
#define MCRYPT_FAILED 0x0

struct CRYPT_STREAM;
typedef struct CRYPT_STREAM *MCRYPT;

/* generic - high level functions. 
 */
	MCRYPT mcrypt_module_open(char *algorithm,
				  char *a_directory, char *mode,
				  char *m_directory);
	int mcrypt_module_close(MCRYPT td);

	/* returns 0 if the library has not been compiled with
	 * dynamic module support.
 	 */
	int mcrypt_module_support_dynamic(void);

/* returns thread descriptor */

	int mcrypt_generic_init(const MCRYPT td, void *key, int lenofkey,
				void *IV);
	int mcrypt_generic_deinit(const MCRYPT td);
	int mcrypt_generic_end(const MCRYPT td);
	int mdecrypt_generic(MCRYPT td, void *plaintext, int len);
	int mcrypt_generic(MCRYPT td, void *plaintext, int len);

/* extra functions */

	int mcrypt_enc_set_state(MCRYPT td, void *st, int size);
	int mcrypt_enc_get_state(MCRYPT td, void *st, int *size); /* only 
	* for block algorithms and certain modes like cbc
	* ncfb etc.
	*/
	int (mcrypt_enc_self_test) (MCRYPT);
	int (mcrypt_enc_get_block_size) (MCRYPT);
	int (mcrypt_enc_get_iv_size) (MCRYPT);
	int (mcrypt_enc_get_key_size) (MCRYPT);

/* If this is a block algorithm returns 1 
 */
	int (mcrypt_enc_is_block_algorithm) (MCRYPT);

/* If the mode operates in blocks returns 1 
 */
	int (mcrypt_enc_is_block_mode) (MCRYPT);

/* If the mode is for block algorithms it returns 1 
 */
	int (mcrypt_enc_is_block_algorithm_mode) (MCRYPT td);
	int mcrypt_enc_mode_has_iv(MCRYPT td);

/* Return a const string containing the name of the algorithm/mode
 */
	char *(mcrypt_enc_get_algorithms_name) (MCRYPT td);
	char *(mcrypt_enc_get_modes_name) (MCRYPT td);

	int *mcrypt_enc_get_supported_key_sizes(MCRYPT td, int *len);


	char **mcrypt_list_algorithms(char *libdir, int *size);
	char **mcrypt_list_modes(char *libdir, int *size);

	/* Frees the memory allocated by the mcrypt_list_xxx() functions. 
	 */
	void mcrypt_free_p(char **p, int size);
	void mcrypt_free(void *ptr);

	/* If mcrypt_xxx functions return an error code, and you supply this
	 * to this function, it will print a human readable message
	 */
	void mcrypt_perror(int err);
	const char* mcrypt_strerror(int err);

	/* Self test for the specified algorithm 
	 */
	int mcrypt_module_self_test(char *algorithm, char *a_directory);

	int mcrypt_module_is_block_algorithm(char *algorithm,
					     char *a_directory);
	int mcrypt_module_is_block_algorithm_mode(char *mode,
						  char *m_directory);
	int mcrypt_module_is_block_mode(char *mode, char *m_directory);

	int mcrypt_module_get_algo_key_size(char *algorithm,
					    char *a_directory);
	int mcrypt_module_get_algo_block_size(char *algorithm,
					      char *a_directory);

	int *mcrypt_module_get_algo_supported_key_sizes(char *algorithm,
							char *a_directory,
							int *len);

	/* Checks the version of the specified module 
	 */
	int mcrypt_module_algorithm_version(char *algorithm,
					    char *a_directory);
	int mcrypt_module_mode_version(char *mode, char *a_directory);


	/* for multithreaded applications: 
	 */
	int mcrypt_mutex_register ( void (*mutex_lock)(void) , 
			void (*mutex_unlock)(void), 
			void (*set_error)(const char*), 
			const char* (*get_error)(void));

	const char *
		mcrypt_check_version( const char *);

	/* These definitions exist in order to ease the access to 
	 * mcrypt_module_init().
	 */

	/* Algorithms */
#define MCRYPT_BLOWFISH		"blowfish"
#define MCRYPT_DES 		"des"
#define MCRYPT_3DES 		"tripledes"
#define MCRYPT_3WAY 		"threeway"
#define MCRYPT_GOST 		"gost"
#define MCRYPT_SAFER_SK64 	"safer-sk64"
#define MCRYPT_SAFER_SK128 	"safer-sk128"
#define MCRYPT_CAST_128 	"cast-128"
#define MCRYPT_XTEA 		"xtea"
#define MCRYPT_RC2	 	"rc2"
#define MCRYPT_TWOFISH 		"twofish"
#define MCRYPT_CAST_256 	"cast-256"
#define MCRYPT_SAFERPLUS 	"saferplus"
#define MCRYPT_LOKI97 		"loki97"
#define MCRYPT_SERPENT 		"serpent"
#define MCRYPT_RIJNDAEL_128 	"rijndael-128"
#define MCRYPT_RIJNDAEL_192 	"rijndael-192"
#define MCRYPT_RIJNDAEL_256 	"rijndael-256"
#define MCRYPT_ENIGMA 		"enigma"
#define MCRYPT_ARCFOUR		"arcfour"
#define MCRYPT_WAKE		"wake"

	/* Modes */
#define MCRYPT_CBC		"cbc"
#define MCRYPT_ECB		"ecb"
#define MCRYPT_CFB		"cfb"
#define MCRYPT_OFB		"ofb"
#define MCRYPT_nOFB		"nofb"
#define MCRYPT_STREAM		"stream"

#ifdef __cplusplus
}
#endif
PK�{FZ�2U�##	mglobal.hnu�[���PK�{FZ�efN66\mtypes.hnu�[���PK�{FZ_�r�	�	�mincludes.hnu�[���PK�{FZP�1��� mutils.hnu�[���PK�{FZ+!��?mhash.hnu�[���PK�{FZ���>uuLSmhash_config.hnu�[���PK�{FZS�{r���kmcrypt.hnu�[���PK© 2025 GrazzMean