/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 1999-2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
/*	  All Rights Reserved	*/

#include <stdlib.h>
#include <string.h>
#include <libintl.h>
#include <locale.h>
#include <errno.h>
#include <unistd.h>
#include <ctype.h>
#include <syslog.h>
#include <sys/time.h>
#include "ns_sldap.h"
#include "ns_internal.h"
#include <crypt.h>

static	char		t1[ROTORSIZE];
static	char		t2[ROTORSIZE];
static	char		t3[ROTORSIZE];
static	char		hexdig[] = "0123456789abcdef";

static mutex_t		ns_crypt_lock = DEFAULTMUTEX;
static boolean_t	crypt_inited = B_FALSE;

static int
is_cleartext(const char *pwd)
{
	if (0 == strncmp(pwd, CRYPTMARK, strlen(CRYPTMARK)))
		return (FALSE);
	return (TRUE);
}


static char *
hex2ascii(char *aString, int aLen)
{
	char *res;
	int i = 0;

	if ((res = (char *)calloc(aLen*2 + 1, 1)) == NULL) {
		return (NULL);
	}
	for (;;) {
		if (aLen < 1)
			break;
		res[i] = hexdig[(*aString & 0xf0) >> 4];
		res[i + 1] = hexdig[*aString & 0x0f];
		i += 2;
		aLen--;
		aString++;
	}
	return (res);
}


static int
unhex(char c)
{
	return (c >= '0' && c <= '9' ? c - '0'
	    : c >= 'A' && c <= 'F' ? c - 'A' + 10
	    : c - 'a' + 10);
}


static char *
ascii2hex(char *anHexaStr, int *aResLen)
{
	int theLen = 0;
	char *theRes = malloc(strlen(anHexaStr) /2 + 1);

	if (theRes == NULL)
		return (NULL);
	while (isxdigit(*anHexaStr)) {
		theRes[theLen] = unhex(*anHexaStr) << 4;
		if (*(++anHexaStr) != '\0') {
			theRes[theLen] += unhex(*anHexaStr);
			anHexaStr++;
		}
		theLen++;
	}
	theRes[theLen] = '\0';
	*aResLen = theLen;
	return (theRes);
}


static void
c_setup()
{
	int ic, i, k, temp;
	unsigned random;
	char buf[13];
	int seed;

	(void) mutex_lock(&ns_crypt_lock);
	if (crypt_inited) {
		(void) mutex_unlock(&ns_crypt_lock);
		return;
	}
	(void) strcpy(buf, "Homer J");
	buf[8] = buf[0];
	buf[9] = buf[1];
	(void) strncpy(buf, (char *)crypt(buf, &buf[8]), 13);
	seed = 123;
	for (i = 0; i < 13; i++)
		seed = seed*buf[i] + i;
	for (i = 0; i < ROTORSIZE; i++) {
		t1[i] = i;
		t3[i] = 0;
	}
	for (i = 0; i < ROTORSIZE; i++) {
		seed = 5*seed + buf[i%13];
		random = seed % 65521;
		k = ROTORSIZE-1 - i;
		ic = (random&MASK)%(k+1);
		random >>= 8;
		temp = t1[k];
		t1[k] = t1[ic];
		t1[ic] = temp;
		if (t3[k] != 0) continue;
		ic = (random&MASK) % k;
		while (t3[ic] != 0) ic = (ic + 1) % k;
		t3[k] = ic;
		t3[ic] = k;
	}
	for (i = 0; i < ROTORSIZE; i++)
		t2[t1[i]&MASK] = i;
	crypt_inited = B_TRUE;
	(void) mutex_unlock(&ns_crypt_lock);
}


static char *
modvalue(char *str, int len, int *mod_len)
{
	int i, n1, n2;
	char *s;

	if (!crypt_inited)
		c_setup();
	i = 0;
	n1 = 0;
	n2 = 0;
	if ((s = (char *)malloc(2 * len + 1)) != NULL) {
		while (i < len) {
			s[i] =
			    t2[(t3[(t1[(str[i]+n1)&MASK]+n2)&MASK]-n2)&MASK]-n1;
			i++;
			n1++;
			if (n1 == ROTORSIZE) {
				n1 = 0;
				n2++;
				if (n2 == ROTORSIZE)
					n2 = 0;
			}
		}
		s[i] = '\0';
		if (mod_len != NULL)
			*mod_len = i;
	}
	return (s);
}


char *
evalue(char *ptr)
{
	char *modv, *str, *ev;
	int modv_len;
	size_t len;

	/*
	 * if not cleartext, return a copy of what ptr
	 * points to as that is what evalue does below.
	 */
	if (FALSE == is_cleartext(ptr)) {
		str = strdup(ptr);
		return (str);
	}

	modv = modvalue(ptr, strlen(ptr), &modv_len);
	str = hex2ascii(modv, modv_len);
	free(modv);
	modv = NULL;
	len = strlen(str) + strlen(CRYPTMARK) + 1;
	ev = malloc(len);
	if (ev == NULL) {
		free(str);
		return (NULL);
	}
	(void) snprintf(ev, len, CRYPTMARK "%s", str);
	free(str);
	str = NULL;
	return (ev);
}


char *
dvalue(char *ptr)
{
	char *modv, *str, *sb;
	int len;

	/* if cleartext return NULL (error!) */
	if (TRUE == is_cleartext(ptr))
		return (NULL);

	sb = strchr(ptr, '}');
	sb++;
	len = strlen(sb);
	str = ascii2hex(sb, &len);
	modv = modvalue(str, len, NULL);
	free(str);
	str = NULL;
	return (modv);
}