Attachment #559392 for bug #592528

Lines 424-431 static HMAC_CTX _plug_HMAC_CTX_new(const sasl_utils_t utils) Link Here

(-)a/plugins/ntlm.c (-1 / +1 lines)
424	#if OPENSSL_VERSION_NUMBER >= 0x10100000L	424	#if OPENSSL_VERSION_NUMBER >= 0x10100000L
425	return HMAC_CTX_new();	425	return HMAC_CTX_new();
426	#else	426	#else
427	return utils->malloc(sizeof(EVP_MD_CTX));	427	return utils->malloc(sizeof(HMAC_CTX));
428	#endif	428	#endif
429	}	429	}
430		430
431	static void _plug_HMAC_CTX_free(HMAC_CTX ctx, const sasl_utils_t utils)	431	static void _plug_HMAC_CTX_free(HMAC_CTX ctx, const sasl_utils_t utils)




#include <sasl.h>
#include "lak.h"

#if OPENSSL_VERSION_NUMBER < 0x10100000L
static EVP_MD_CTX *EVP_MD_CTX_new(void)
{
	return EVP_MD_CTX_create();
}
static void EVP_MD_CTX_free(EVP_MD_CTX *ctx)
{
	if (ctx == NULL)
		return;

	EVP_MD_CTX_destroy(ctx);
}

static EVP_ENCODE_CTX *EVP_ENCODE_CTX_new(void)
{
	EVP_ENCODE_CTX *ctx = OPENSSL_malloc(sizeof(*ctx));

	if (ctx != NULL) {
		memset(ctx, 0, sizeof(*ctx));
	}
	return ctx;
}
static void EVP_ENCODE_CTX_free(EVP_ENCODE_CTX *ctx)
{
	OPENSSL_free(ctx);
	return;
}
#endif

typedef struct lak_auth_method {
	int method;
	int (*check) (LAK *lak, const char *user, const char *service, const char *realm, const char *password) ;


	int rc, i, tlen = 0;
	char *text;
	EVP_ENCODE_CTX *enc_ctx = EVP_ENCODE_CTX_new();

	if (enc_ctx == NULL)
		return LAK_NOMEM;

	text = (char *)malloc(((strlen(src)+3)/4 * 3) + 1);
	if (text == NULL) {
		EVP_ENCODE_CTX_free(enc_ctx);
		return LAK_NOMEM;
	}

	EVP_DecodeInit(enc_ctx);
	rc = EVP_DecodeUpdate(enc_ctx, (unsigned char *) text, &i, (const unsigned char *)src, strlen(src));
	if (rc < 0) {
		EVP_ENCODE_CTX_free(enc_ctx);
		free(text);
		return LAK_FAIL;
	}
	tlen += i;
	EVP_DecodeFinal(enc_ctx, (unsigned char *) text, &i);

	EVP_ENCODE_CTX_free(enc_ctx);

	*ret = text;
	if (rlen != NULL)

{
	int rc, clen;
	LAK_HASH_ROCK *hrock = (LAK_HASH_ROCK *) rock;
	EVP_MD_CTX *mdctx;
	const EVP_MD *md;
	unsigned char digest[EVP_MAX_MD_SIZE];
	char *cred;

	if (!md)
		return LAK_FAIL;

	mdctx = EVP_MD_CTX_new();
	if (!mdctx)
		return LAK_NOMEM;

	rc = lak_base64_decode(hash, &cred, &clen);
	if (rc != LAK_OK) {
		EVP_MD_CTX_free(mdctx);
		return rc;
	}

	EVP_DigestInit(mdctx, md);
	EVP_DigestUpdate(mdctx, passwd, strlen(passwd));
	if (hrock->salted) {
		EVP_DigestUpdate(mdctx, &cred[EVP_MD_size(md)],
				 clen - EVP_MD_size(md));
	}
	EVP_DigestFinal(mdctx, digest, NULL);
	EVP_MD_CTX_free(mdctx);

	rc = memcmp((char *)cred, (char *)digest, EVP_MD_size(md));
	free(cred);
- 

Return to bug 592528

Lines 61-66 Link Here

(-)a/saslauthd/lak.c (-12 / +55 lines)
61	#include <sasl.h>	61	#include <sasl.h>
62	#include "lak.h"	62	#include "lak.h"
63		63
		64	#if OPENSSL_VERSION_NUMBER < 0x10100000L
		65	static EVP_MD_CTX *EVP_MD_CTX_new(void)
		66	{
		67	return EVP_MD_CTX_create();
		68	}
		69	static void EVP_MD_CTX_free(EVP_MD_CTX *ctx)
		70	{
		71	if (ctx == NULL)
		72	return;
		73
		74	EVP_MD_CTX_destroy(ctx);
		75	}
		76
		77	static EVP_ENCODE_CTX *EVP_ENCODE_CTX_new(void)
		78	{
		79	EVP_ENCODE_CTX ctx = OPENSSL_malloc(sizeof(ctx));
		80
		81	if (ctx != NULL) {
		82	memset(ctx, 0, sizeof(*ctx));
		83	}
		84	return ctx;
		85	}
		86	static void EVP_ENCODE_CTX_free(EVP_ENCODE_CTX *ctx)
		87	{
		88	OPENSSL_free(ctx);
		89	return;
		90	}
		91	#endif
		92
64	typedef struct lak_auth_method {	93	typedef struct lak_auth_method {
65	int method;	94	int method;
66	int (check) (LAK lak, const char user, const char service, const char realm, const char password) ;	95	int (check) (LAK lak, const char user, const char service, const char realm, const char password) ;
Lines 1720-1739 static int lak_base64_decode( Link Here
1720		1749
1721	int rc, i, tlen = 0;	1750	int rc, i, tlen = 0;
1722	char *text;	1751	char *text;
1723	EVP_ENCODE_CTX EVP_ctx;	1752	EVP_ENCODE_CTX *enc_ctx = EVP_ENCODE_CTX_new();
		1753
		1754	if (enc_ctx == NULL)
		1755	return LAK_NOMEM;
1724		1756
1725	text = (char )malloc(((strlen(src)+3)/4 3) + 1);	1757	text = (char )malloc(((strlen(src)+3)/4 3) + 1);
1726	if (text == NULL)	1758	if (text == NULL) {
		1759	EVP_ENCODE_CTX_free(enc_ctx);
1727	return LAK_NOMEM;	1760	return LAK_NOMEM;
		1761	}
1728		1762
1729	EVP_DecodeInit(&EVP_ctx);	1763	EVP_DecodeInit(enc_ctx);
1730	rc = EVP_DecodeUpdate(&EVP_ctx, (unsigned char ) text, &i, (const unsigned char )src, strlen(src));	1764	rc = EVP_DecodeUpdate(enc_ctx, (unsigned char ) text, &i, (const unsigned char )src, strlen(src));
1731	if (rc < 0) {	1765	if (rc < 0) {
		1766	EVP_ENCODE_CTX_free(enc_ctx);
1732	free(text);	1767	free(text);
1733	return LAK_FAIL;	1768	return LAK_FAIL;
1734	}	1769	}
1735	tlen += i;	1770	tlen += i;
1736	EVP_DecodeFinal(&EVP_ctx, (unsigned char *) text, &i);	1771	EVP_DecodeFinal(enc_ctx, (unsigned char *) text, &i);
		1772
		1773	EVP_ENCODE_CTX_free(enc_ctx);
1737		1774
1738	*ret = text;	1775	*ret = text;
1739	if (rlen != NULL)	1776	if (rlen != NULL)
Lines 1749-1755 static int lak_check_hashed( Link Here
1749	{	1786	{
1750	int rc, clen;	1787	int rc, clen;
1751	LAK_HASH_ROCK hrock = (LAK_HASH_ROCK ) rock;	1788	LAK_HASH_ROCK hrock = (LAK_HASH_ROCK ) rock;
1752	EVP_MD_CTX mdctx;	1789	EVP_MD_CTX *mdctx;
1753	const EVP_MD *md;	1790	const EVP_MD *md;
1754	unsigned char digest[EVP_MAX_MD_SIZE];	1791	unsigned char digest[EVP_MAX_MD_SIZE];
1755	char *cred;	1792	char *cred;
Lines 1758-1774 static int lak_check_hashed( Link Here
1758	if (!md)	1795	if (!md)
1759	return LAK_FAIL;	1796	return LAK_FAIL;
1760		1797
		1798	mdctx = EVP_MD_CTX_new();
		1799	if (!mdctx)
		1800	return LAK_NOMEM;
		1801
1761	rc = lak_base64_decode(hash, &cred, &clen);	1802	rc = lak_base64_decode(hash, &cred, &clen);
1762	if (rc != LAK_OK)	1803	if (rc != LAK_OK) {
		1804	EVP_MD_CTX_free(mdctx);
1763	return rc;	1805	return rc;
		1806	}
1764		1807
1765	EVP_DigestInit(&mdctx, md);	1808	EVP_DigestInit(mdctx, md);
1766	EVP_DigestUpdate(&mdctx, passwd, strlen(passwd));	1809	EVP_DigestUpdate(mdctx, passwd, strlen(passwd));
1767	if (hrock->salted) {	1810	if (hrock->salted) {
1768	EVP_DigestUpdate(&mdctx, &cred[EVP_MD_size(md)],	1811	EVP_DigestUpdate(mdctx, &cred[EVP_MD_size(md)],
1769	clen - EVP_MD_size(md));	1812	clen - EVP_MD_size(md));
1770	}	1813	}
1771	EVP_DigestFinal(&mdctx, digest, NULL);	1814	EVP_DigestFinal(mdctx, digest, NULL);
		1815	EVP_MD_CTX_free(mdctx);
1772		1816
1773	rc = memcmp((char )cred, (char )digest, EVP_MD_size(md));	1817	rc = memcmp((char )cred, (char )digest, EVP_MD_size(md));
1774	free(cred);	1818	free(cred);
1775	-