mux/src/crypt/crypt.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	crypt_data
Defines
#define	_CRYPT_H   1
Functions
char *	crypt (const char *__key, const char *__salt)
void	setkey (const char *__key)
void	encrypt (char *__block, int __edflag)
char *	__crypt_r (const char *__key, const char *__salt, struct crypt_data *__data)
char *	crypt_r (const char *__key, const char *__salt, struct crypt_data *__data)
void	__setkey_r (const char *__key, struct crypt_data *__data)
void	setkey_r (const char *__key, struct crypt_data *__data)
void	__encrypt_r (char *__block, int __edflag, struct crypt_data *__data)
void	encrypt_r (char *__block, int __edflag, struct crypt_data *__data)

---

Define Documentation

#define _CRYPT_H   1

Definition at line 26 of file crypt.h.

---

Function Documentation

char* __crypt_r	(	const char *	__key,
		const char *	__salt,
		struct crypt_data *	__data
	)

void __encrypt_r	(	char *	__block,
		int	__edflag,
		struct crypt_data *	__data
	)

Definition at line 733 of file crypt_util.cpp.

References _ufc_dofinalperm_r(), _ufc_doit_r(), _ufc_setup_salt_r(), BITMASK, crypt_data::direction, esel, initial_perm, crypt_data::keysched, and longmask.

Referenced by encrypt().

{
  ufc_long l1, l2, r1, r2, res[4];
  int i;
#ifdef _UFC_32_
  long32 *kt;
  kt = (long32*)__data->keysched;
#endif
#ifdef _UFC_64_
  long64 *kt;
  kt = (long64*)__data->keysched;
#endif

  /*
   * Undo any salt changes to E expansion
   */
  _ufc_setup_salt_r("..", __data);

  /*
   * Reverse key table if
   * changing operation (encrypt/decrypt)
   */
  if((__edflag == 0) != (__data->direction == 0)) {
    for(i = 0; i < 8; i++) {
#ifdef _UFC_32_
      long32 x;
      x = kt[2 * (15-i)];
      kt[2 * (15-i)] = kt[2 * i];
      kt[2 * i] = x;

      x = kt[2 * (15-i) + 1];
      kt[2 * (15-i) + 1] = kt[2 * i + 1];
      kt[2 * i + 1] = x;
#endif
#ifdef _UFC_64_
      long64 x;
      x = kt[15-i];
      kt[15-i] = kt[i];
      kt[i] = x;
#endif
      }
    __data->direction = __edflag;
  }

  /*
   * Do initial permutation + E expansion
   */
  i = 0;
  for(l1 = 0; i < 24; i++) {
    if(__block[initial_perm[esel[i]-1]-1])
      l1 |= BITMASK[i];
  }
  for(l2 = 0; i < 48; i++) {
    if(__block[initial_perm[esel[i]-1]-1])
      l2 |= BITMASK[i-24];
  }

  i = 0;
  for(r1 = 0; i < 24; i++) {
    if(__block[initial_perm[esel[i]-1+32]-1])
      r1 |= BITMASK[i];
  }
  for(r2 = 0; i < 48; i++) {
    if(__block[initial_perm[esel[i]-1+32]-1])
      r2 |= BITMASK[i-24];
  }

  /*
   * Do DES inner loops + final conversion
   */
  res[0] = l1; res[1] = l2;
  res[2] = r1; res[3] = r2;
  _ufc_doit_r((ufc_long)1, __data, &res[0]);

  /*
   * Do final permutations
   */
  _ufc_dofinalperm_r(res, __data);

  /*
   * And convert to bit array
   */
  l1 = res[0]; r1 = res[1];
  for(i = 0; i < 32; i++) {
    *__block++ = (l1 & longmask[i]) != 0;
  }
  for(i = 0; i < 32; i++) {
    *__block++ = (r1 & longmask[i]) != 0;
  }
}

void __setkey_r	(	const char *	__key,
		struct crypt_data *	__data
	)

Definition at line 837 of file crypt_util.cpp.

References _ufc_mk_keytab_r(), and _ufc_setup_salt_r().

Referenced by setkey().

{
  int i,j;
  unsigned char c;
  unsigned char ktab[8];

  _ufc_setup_salt_r("..", __data); /* be sure we're initialized */

  for(i = 0; i < 8; i++) {
    for(j = 0, c = 0; j < 8; j++)
      c = c << 1 | *__key++;
    ktab[i] = c >> 1;
  }
  _ufc_mk_keytab_r((char *)ktab, __data);
}

char* crypt	(	const char *	__key,
		const char *	__salt
	)

Definition at line 118 of file crypt-entry.cpp.

{
#ifdef _LIBC
  /* Try to find out whether we have to use MD5 encryption replacement.  */
  if (strncmp (md5_salt_prefix, salt, sizeof (md5_salt_prefix) - 1) == 0)
    return __md5_crypt (key, salt);
#endif

  return crypt_r (key, salt, &_ufc_foobar);
}

char* crypt_r	(	const char *	__key,
		const char *	__salt,
		struct crypt_data *	__data
	)

Definition at line 74 of file crypt-entry.cpp.

References __md5_crypt_r(), _ufc_dofinalperm_r(), _ufc_doit_r(), _ufc_mk_keytab_r(), _ufc_output_conversion_r(), _ufc_setup_salt_r(), and md5_salt_prefix.

Referenced by crypt().

{
  ufc_long res[4];
  char ktab[9];
  ufc_long xx = 25; /* to cope with GCC long long compiler bugs */

#ifdef _LIBC
  /* Try to find out whether we have to use MD5 encryption replacement.  */
  if (strncmp (md5_salt_prefix, salt, sizeof (md5_salt_prefix) - 1) == 0)
    return __md5_crypt_r (key, salt, (char *) data,
              sizeof (struct crypt_data));
#endif

  /*
   * Hack DES tables according to salt
   */
  _ufc_setup_salt_r (salt, data);

  /*
   * Setup key schedule
   */
  memset(ktab, 0, sizeof(ktab));
  strncpy (ktab, key, 8);
  _ufc_mk_keytab_r (ktab, data);

  /*
   * Go for the 25 DES encryptions
   */
  memset(res, 0, sizeof (res));
  _ufc_doit_r (xx,  data, &res[0]);

  /*
   * Do final permutations
   */
  _ufc_dofinalperm_r (res, data);

  /*
   * And convert back to 6 bit ASCII
   */
  _ufc_output_conversion_r (res[0], res[1], salt, data);
  return data->crypt_3_buf;
}

void encrypt	(	char *	__block,
		int	__edflag
	)

Definition at line 825 of file crypt_util.cpp.

References __encrypt_r(), and _ufc_foobar.

{
  __encrypt_r(__block, __edflag, &_ufc_foobar);
}

void encrypt_r	(	char *	__block,
		int	__edflag,
		struct crypt_data *	__data
	)

void setkey

(

const char *

__key

)

Definition at line 853 of file crypt_util.cpp.

References __setkey_r(), and _ufc_foobar.

{
  __setkey_r(__key, &_ufc_foobar);
}

void setkey_r	(	const char *	__key,
		struct crypt_data *	__data
	)

---