PostgreSQL Source Code  git master
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
crypt-des.c File Reference
#include "postgres.h"
#include "miscadmin.h"
#include "px-crypt.h"
#include <netinet/in.h>
#include <arpa/inet.h>
Include dependency graph for crypt-des.c:

Go to the source code of this file.

Macros

#define _PASSWORD_EFMT1   '_'
 

Functions

static int ascii_to_bin (char ch)
 
static void des_init (void)
 
static void setup_salt (long salt)
 
static int des_setkey (const char *key)
 
static int do_des (uint32 l_in, uint32 r_in, uint32 *l_out, uint32 *r_out, int count)
 
static int des_cipher (const char *in, char *out, long salt, int count)
 
char * px_crypt_des (const char *key, const char *setting)
 

Variables

static const char _crypt_a64 []
 
static uint8 IP [64]
 
static uint8 inv_key_perm [64]
 
static uint8 u_key_perm [56]
 
static uint8 key_perm [56]
 
static uint8 key_shifts [16]
 
static uint8 inv_comp_perm [56]
 
static uint8 comp_perm [48]
 
static uint8 u_sbox [8][64]
 
static uint8 sbox [8][64]
 
static uint8 un_pbox [32]
 
static uint8 pbox [32]
 
static uint32 _crypt_bits32 [32]
 
static uint8 _crypt_bits8 [8] = {0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01}
 
static uint32 saltbits
 
static long old_salt
 
static uint32bits28
 
static uint32bits24
 
static uint8 init_perm [64]
 
static uint8 final_perm [64]
 
static uint32 en_keysl [16]
 
static uint32 en_keysr [16]
 
static uint32 de_keysl [16]
 
static uint32 de_keysr [16]
 
static int des_initialised = 0
 
static uint8 m_sbox [4][4096]
 
static uint32 psbox [4][256]
 
static uint32 ip_maskl [8][256]
 
static uint32 ip_maskr [8][256]
 
static uint32 fp_maskl [8][256]
 
static uint32 fp_maskr [8][256]
 
static uint32 key_perm_maskl [8][128]
 
static uint32 key_perm_maskr [8][128]
 
static uint32 comp_maskl [8][128]
 
static uint32 comp_maskr [8][128]
 
static uint32 old_rawkey0
 
static uint32 old_rawkey1
 

Macro Definition Documentation

#define _PASSWORD_EFMT1   '_'

Definition at line 72 of file crypt-des.c.

Referenced by px_crypt_des().

Function Documentation

static int ascii_to_bin ( char  ch)
inlinestatic

Definition at line 206 of file crypt-des.c.

Referenced by px_crypt_des().

207 {
208  if (ch > 'z')
209  return (0);
210  if (ch >= 'a')
211  return (ch - 'a' + 38);
212  if (ch > 'Z')
213  return (0);
214  if (ch >= 'A')
215  return (ch - 'A' + 12);
216  if (ch > '9')
217  return (0);
218  if (ch >= '.')
219  return (ch - '.');
220  return (0);
221 }
static int des_cipher ( const char *  in,
char *  out,
long  salt,
int  count 
)
static

Definition at line 620 of file crypt-des.c.

References buffer, des_init(), des_initialised, do_des(), and setup_salt().

Referenced by px_crypt_des().

621 {
622  uint32 buffer[2];
623  uint32 l_out,
624  r_out,
625  rawl,
626  rawr;
627  int retval;
628 
629  if (!des_initialised)
630  des_init();
631 
632  setup_salt(salt);
633 
634  /* copy data to avoid assuming input is word-aligned */
635  memcpy(buffer, in, sizeof(buffer));
636 
637  rawl = ntohl(buffer[0]);
638  rawr = ntohl(buffer[1]);
639 
640  retval = do_des(rawl, rawr, &l_out, &r_out, count);
641  if (retval)
642  return (retval);
643 
644  buffer[0] = htonl(l_out);
645  buffer[1] = htonl(r_out);
646 
647  /* copy data to avoid assuming output is word-aligned */
648  memcpy(out, buffer, sizeof(buffer));
649 
650  return (retval);
651 }
static int des_initialised
Definition: crypt-des.c:191
static void des_init(void)
Definition: crypt-des.c:224
static int do_des(uint32 l_in, uint32 r_in, uint32 *l_out, uint32 *r_out, int count)
Definition: crypt-des.c:486
unsigned int uint32
Definition: c.h:268
static void setup_salt(long salt)
Definition: crypt-des.c:376
WalTimeSample buffer[LAG_TRACKER_BUFFER_SIZE]
Definition: walsender.c:214
static void des_init ( void  )
static

Definition at line 224 of file crypt-des.c.

References _crypt_bits32, _crypt_bits8, bits24, bits28, comp_maskl, comp_maskr, comp_perm, des_initialised, final_perm, fp_maskl, fp_maskr, i, init_perm, inv_comp_perm, inv_key_perm, IP, ip_maskl, ip_maskr, key_perm, key_perm_maskl, key_perm_maskr, m_sbox, old_rawkey0, old_rawkey1, old_salt, pbox, psbox, saltbits, sbox, u_key_perm, u_sbox, and un_pbox.

Referenced by des_cipher(), des_setkey(), and px_crypt_des().

225 {
226  int i,
227  j,
228  b,
229  k,
230  inbit,
231  obit;
232  uint32 *p,
233  *il,
234  *ir,
235  *fl,
236  *fr;
237 
238  old_rawkey0 = old_rawkey1 = 0L;
239  saltbits = 0L;
240  old_salt = 0L;
241  bits24 = (bits28 = _crypt_bits32 + 4) + 4;
242 
243  /*
244  * Invert the S-boxes, reordering the input bits.
245  */
246  for (i = 0; i < 8; i++)
247  for (j = 0; j < 64; j++)
248  {
249  b = (j & 0x20) | ((j & 1) << 4) | ((j >> 1) & 0xf);
250  u_sbox[i][j] = sbox[i][b];
251  }
252 
253  /*
254  * Convert the inverted S-boxes into 4 arrays of 8 bits. Each will handle
255  * 12 bits of the S-box input.
256  */
257  for (b = 0; b < 4; b++)
258  for (i = 0; i < 64; i++)
259  for (j = 0; j < 64; j++)
260  m_sbox[b][(i << 6) | j] =
261  (u_sbox[(b << 1)][i] << 4) |
262  u_sbox[(b << 1) + 1][j];
263 
264  /*
265  * Set up the initial & final permutations into a useful form, and
266  * initialise the inverted key permutation.
267  */
268  for (i = 0; i < 64; i++)
269  {
270  init_perm[final_perm[i] = IP[i] - 1] = i;
271  inv_key_perm[i] = 255;
272  }
273 
274  /*
275  * Invert the key permutation and initialise the inverted key compression
276  * permutation.
277  */
278  for (i = 0; i < 56; i++)
279  {
280  u_key_perm[i] = key_perm[i] - 1;
281  inv_key_perm[key_perm[i] - 1] = i;
282  inv_comp_perm[i] = 255;
283  }
284 
285  /*
286  * Invert the key compression permutation.
287  */
288  for (i = 0; i < 48; i++)
289  inv_comp_perm[comp_perm[i] - 1] = i;
290 
291  /*
292  * Set up the OR-mask arrays for the initial and final permutations, and
293  * for the key initial and compression permutations.
294  */
295  for (k = 0; k < 8; k++)
296  {
297  for (i = 0; i < 256; i++)
298  {
299  *(il = &ip_maskl[k][i]) = 0L;
300  *(ir = &ip_maskr[k][i]) = 0L;
301  *(fl = &fp_maskl[k][i]) = 0L;
302  *(fr = &fp_maskr[k][i]) = 0L;
303  for (j = 0; j < 8; j++)
304  {
305  inbit = 8 * k + j;
306  if (i & _crypt_bits8[j])
307  {
308  if ((obit = init_perm[inbit]) < 32)
309  *il |= _crypt_bits32[obit];
310  else
311  *ir |= _crypt_bits32[obit - 32];
312  if ((obit = final_perm[inbit]) < 32)
313  *fl |= _crypt_bits32[obit];
314  else
315  *fr |= _crypt_bits32[obit - 32];
316  }
317  }
318  }
319  for (i = 0; i < 128; i++)
320  {
321  *(il = &key_perm_maskl[k][i]) = 0L;
322  *(ir = &key_perm_maskr[k][i]) = 0L;
323  for (j = 0; j < 7; j++)
324  {
325  inbit = 8 * k + j;
326  if (i & _crypt_bits8[j + 1])
327  {
328  if ((obit = inv_key_perm[inbit]) == 255)
329  continue;
330  if (obit < 28)
331  *il |= bits28[obit];
332  else
333  *ir |= bits28[obit - 28];
334  }
335  }
336  *(il = &comp_maskl[k][i]) = 0L;
337  *(ir = &comp_maskr[k][i]) = 0L;
338  for (j = 0; j < 7; j++)
339  {
340  inbit = 7 * k + j;
341  if (i & _crypt_bits8[j + 1])
342  {
343  if ((obit = inv_comp_perm[inbit]) == 255)
344  continue;
345  if (obit < 24)
346  *il |= bits24[obit];
347  else
348  *ir |= bits24[obit - 24];
349  }
350  }
351  }
352  }
353 
354  /*
355  * Invert the P-box permutation, and convert into OR-masks for handling
356  * the output of the S-box arrays setup above.
357  */
358  for (i = 0; i < 32; i++)
359  un_pbox[pbox[i] - 1] = i;
360 
361  for (b = 0; b < 4; b++)
362  for (i = 0; i < 256; i++)
363  {
364  *(p = &psbox[b][i]) = 0L;
365  for (j = 0; j < 8; j++)
366  {
367  if (i & _crypt_bits8[j])
368  *p |= _crypt_bits32[un_pbox[8 * b + j]];
369  }
370  }
371 
372  des_initialised = 1;
373 }
static uint8 IP[64]
Definition: crypt-des.c:77
static long old_salt
Definition: crypt-des.c:182
static uint32 comp_maskr[8][128]
Definition: crypt-des.c:200
static uint8 _crypt_bits8[8]
Definition: crypt-des.c:179
static uint8 u_sbox[8][64]
Definition: crypt-des.c:109
static uint8 inv_comp_perm[56]
Definition: crypt-des.c:97
static int des_initialised
Definition: crypt-des.c:191
static uint32 comp_maskl[8][128]
Definition: crypt-des.c:200
static uint32 _crypt_bits32[32]
Definition: crypt-des.c:167
static uint32 old_rawkey0
Definition: crypt-des.c:202
static uint8 key_perm[56]
Definition: crypt-des.c:86
static uint8 inv_key_perm[64]
Definition: crypt-des.c:84
static uint8 un_pbox[32]
Definition: crypt-des.c:161
static uint8 comp_perm[48]
Definition: crypt-des.c:98
static uint8 final_perm[64]
Definition: crypt-des.c:185
static uint32 ip_maskr[8][256]
Definition: crypt-des.c:194
unsigned int uint32
Definition: c.h:268
static uint32 * bits28
Definition: crypt-des.c:183
static uint32 key_perm_maskr[8][128]
Definition: crypt-des.c:198
static uint32 fp_maskl[8][256]
Definition: crypt-des.c:196
static uint32 ip_maskl[8][256]
Definition: crypt-des.c:194
static uint8 u_key_perm[56]
Definition: crypt-des.c:85
static uint8 m_sbox[4][4096]
Definition: crypt-des.c:192
static uint32 key_perm_maskl[8][128]
Definition: crypt-des.c:198
static uint8 init_perm[64]
Definition: crypt-des.c:185
static uint32 fp_maskr[8][256]
Definition: crypt-des.c:196
static uint8 pbox[32]
Definition: crypt-des.c:162
static uint32 old_rawkey1
Definition: crypt-des.c:202
static uint32 * bits24
Definition: crypt-des.c:183
static uint8 sbox[8][64]
Definition: crypt-des.c:110
static uint32 saltbits
Definition: crypt-des.c:181
int i
static uint32 psbox[4][256]
Definition: crypt-des.c:193
static int des_setkey ( const char *  key)
static

Definition at line 399 of file crypt-des.c.

References comp_maskl, comp_maskr, de_keysl, de_keysr, des_init(), des_initialised, en_keysl, en_keysr, key_perm_maskl, key_perm_maskr, key_shifts, old_rawkey0, and old_rawkey1.

Referenced by px_crypt_des().

400 {
401  uint32 k0,
402  k1,
403  rawkey0,
404  rawkey1;
405  int shifts,
406  round;
407 
408  if (!des_initialised)
409  des_init();
410 
411  rawkey0 = ntohl(*(const uint32 *) key);
412  rawkey1 = ntohl(*(const uint32 *) (key + 4));
413 
414  if ((rawkey0 | rawkey1)
415  && rawkey0 == old_rawkey0
416  && rawkey1 == old_rawkey1)
417  {
418  /*
419  * Already setup for this key. This optimization fails on a zero key
420  * (which is weak and has bad parity anyway) in order to simplify the
421  * starting conditions.
422  */
423  return (0);
424  }
425  old_rawkey0 = rawkey0;
426  old_rawkey1 = rawkey1;
427 
428  /*
429  * Do key permutation and split into two 28-bit subkeys.
430  */
431  k0 = key_perm_maskl[0][rawkey0 >> 25]
432  | key_perm_maskl[1][(rawkey0 >> 17) & 0x7f]
433  | key_perm_maskl[2][(rawkey0 >> 9) & 0x7f]
434  | key_perm_maskl[3][(rawkey0 >> 1) & 0x7f]
435  | key_perm_maskl[4][rawkey1 >> 25]
436  | key_perm_maskl[5][(rawkey1 >> 17) & 0x7f]
437  | key_perm_maskl[6][(rawkey1 >> 9) & 0x7f]
438  | key_perm_maskl[7][(rawkey1 >> 1) & 0x7f];
439  k1 = key_perm_maskr[0][rawkey0 >> 25]
440  | key_perm_maskr[1][(rawkey0 >> 17) & 0x7f]
441  | key_perm_maskr[2][(rawkey0 >> 9) & 0x7f]
442  | key_perm_maskr[3][(rawkey0 >> 1) & 0x7f]
443  | key_perm_maskr[4][rawkey1 >> 25]
444  | key_perm_maskr[5][(rawkey1 >> 17) & 0x7f]
445  | key_perm_maskr[6][(rawkey1 >> 9) & 0x7f]
446  | key_perm_maskr[7][(rawkey1 >> 1) & 0x7f];
447 
448  /*
449  * Rotate subkeys and do compression permutation.
450  */
451  shifts = 0;
452  for (round = 0; round < 16; round++)
453  {
454  uint32 t0,
455  t1;
456 
457  shifts += key_shifts[round];
458 
459  t0 = (k0 << shifts) | (k0 >> (28 - shifts));
460  t1 = (k1 << shifts) | (k1 >> (28 - shifts));
461 
462  de_keysl[15 - round] =
463  en_keysl[round] = comp_maskl[0][(t0 >> 21) & 0x7f]
464  | comp_maskl[1][(t0 >> 14) & 0x7f]
465  | comp_maskl[2][(t0 >> 7) & 0x7f]
466  | comp_maskl[3][t0 & 0x7f]
467  | comp_maskl[4][(t1 >> 21) & 0x7f]
468  | comp_maskl[5][(t1 >> 14) & 0x7f]
469  | comp_maskl[6][(t1 >> 7) & 0x7f]
470  | comp_maskl[7][t1 & 0x7f];
471 
472  de_keysr[15 - round] =
473  en_keysr[round] = comp_maskr[0][(t0 >> 21) & 0x7f]
474  | comp_maskr[1][(t0 >> 14) & 0x7f]
475  | comp_maskr[2][(t0 >> 7) & 0x7f]
476  | comp_maskr[3][t0 & 0x7f]
477  | comp_maskr[4][(t1 >> 21) & 0x7f]
478  | comp_maskr[5][(t1 >> 14) & 0x7f]
479  | comp_maskr[6][(t1 >> 7) & 0x7f]
480  | comp_maskr[7][t1 & 0x7f];
481  }
482  return (0);
483 }
static uint32 comp_maskr[8][128]
Definition: crypt-des.c:200
static uint32 en_keysl[16]
Definition: crypt-des.c:187
static uint32 en_keysr[16]
Definition: crypt-des.c:187
static int des_initialised
Definition: crypt-des.c:191
static uint32 comp_maskl[8][128]
Definition: crypt-des.c:200
static void des_init(void)
Definition: crypt-des.c:224
static uint32 old_rawkey0
Definition: crypt-des.c:202
static uint32 de_keysr[16]
Definition: crypt-des.c:189
static uint8 key_shifts[16]
Definition: crypt-des.c:93
unsigned int uint32
Definition: c.h:268
static uint32 key_perm_maskr[8][128]
Definition: crypt-des.c:198
static uint32 key_perm_maskl[8][128]
Definition: crypt-des.c:198
static uint32 de_keysl[16]
Definition: crypt-des.c:189
static uint32 old_rawkey1
Definition: crypt-des.c:202
static int do_des ( uint32  l_in,
uint32  r_in,
uint32 l_out,
uint32 r_out,
int  count 
)
static

Definition at line 486 of file crypt-des.c.

References CHECK_FOR_INTERRUPTS, de_keysl, de_keysr, en_keysl, en_keysr, fp_maskl, fp_maskr, ip_maskl, ip_maskr, m_sbox, psbox, and saltbits.

Referenced by des_cipher(), and px_crypt_des().

487 {
488  /*
489  * l_in, r_in, l_out, and r_out are in pseudo-"big-endian" format.
490  */
491  uint32 l,
492  r,
493  *kl,
494  *kr,
495  *kl1,
496  *kr1;
497  uint32 f,
498  r48l,
499  r48r;
500  int round;
501 
502  if (count == 0)
503  return (1);
504  else if (count > 0)
505  {
506  /*
507  * Encrypting
508  */
509  kl1 = en_keysl;
510  kr1 = en_keysr;
511  }
512  else
513  {
514  /*
515  * Decrypting
516  */
517  count = -count;
518  kl1 = de_keysl;
519  kr1 = de_keysr;
520  }
521 
522  /*
523  * Do initial permutation (IP).
524  */
525  l = ip_maskl[0][l_in >> 24]
526  | ip_maskl[1][(l_in >> 16) & 0xff]
527  | ip_maskl[2][(l_in >> 8) & 0xff]
528  | ip_maskl[3][l_in & 0xff]
529  | ip_maskl[4][r_in >> 24]
530  | ip_maskl[5][(r_in >> 16) & 0xff]
531  | ip_maskl[6][(r_in >> 8) & 0xff]
532  | ip_maskl[7][r_in & 0xff];
533  r = ip_maskr[0][l_in >> 24]
534  | ip_maskr[1][(l_in >> 16) & 0xff]
535  | ip_maskr[2][(l_in >> 8) & 0xff]
536  | ip_maskr[3][l_in & 0xff]
537  | ip_maskr[4][r_in >> 24]
538  | ip_maskr[5][(r_in >> 16) & 0xff]
539  | ip_maskr[6][(r_in >> 8) & 0xff]
540  | ip_maskr[7][r_in & 0xff];
541 
542  while (count--)
543  {
545 
546  /*
547  * Do each round.
548  */
549  kl = kl1;
550  kr = kr1;
551  round = 16;
552  while (round--)
553  {
554  /*
555  * Expand R to 48 bits (simulate the E-box).
556  */
557  r48l = ((r & 0x00000001) << 23)
558  | ((r & 0xf8000000) >> 9)
559  | ((r & 0x1f800000) >> 11)
560  | ((r & 0x01f80000) >> 13)
561  | ((r & 0x001f8000) >> 15);
562 
563  r48r = ((r & 0x0001f800) << 7)
564  | ((r & 0x00001f80) << 5)
565  | ((r & 0x000001f8) << 3)
566  | ((r & 0x0000001f) << 1)
567  | ((r & 0x80000000) >> 31);
568 
569  /*
570  * Do salting for crypt() and friends, and XOR with the permuted
571  * key.
572  */
573  f = (r48l ^ r48r) & saltbits;
574  r48l ^= f ^ *kl++;
575  r48r ^= f ^ *kr++;
576 
577  /*
578  * Do sbox lookups (which shrink it back to 32 bits) and do the
579  * pbox permutation at the same time.
580  */
581  f = psbox[0][m_sbox[0][r48l >> 12]]
582  | psbox[1][m_sbox[1][r48l & 0xfff]]
583  | psbox[2][m_sbox[2][r48r >> 12]]
584  | psbox[3][m_sbox[3][r48r & 0xfff]];
585 
586  /*
587  * Now that we've permuted things, complete f().
588  */
589  f ^= l;
590  l = r;
591  r = f;
592  }
593  r = l;
594  l = f;
595  }
596 
597  /*
598  * Do final permutation (inverse of IP).
599  */
600  *l_out = fp_maskl[0][l >> 24]
601  | fp_maskl[1][(l >> 16) & 0xff]
602  | fp_maskl[2][(l >> 8) & 0xff]
603  | fp_maskl[3][l & 0xff]
604  | fp_maskl[4][r >> 24]
605  | fp_maskl[5][(r >> 16) & 0xff]
606  | fp_maskl[6][(r >> 8) & 0xff]
607  | fp_maskl[7][r & 0xff];
608  *r_out = fp_maskr[0][l >> 24]
609  | fp_maskr[1][(l >> 16) & 0xff]
610  | fp_maskr[2][(l >> 8) & 0xff]
611  | fp_maskr[3][l & 0xff]
612  | fp_maskr[4][r >> 24]
613  | fp_maskr[5][(r >> 16) & 0xff]
614  | fp_maskr[6][(r >> 8) & 0xff]
615  | fp_maskr[7][r & 0xff];
616  return (0);
617 }
static uint32 en_keysl[16]
Definition: crypt-des.c:187
static uint32 en_keysr[16]
Definition: crypt-des.c:187
static uint32 de_keysr[16]
Definition: crypt-des.c:189
static uint32 ip_maskr[8][256]
Definition: crypt-des.c:194
unsigned int uint32
Definition: c.h:268
static uint32 fp_maskl[8][256]
Definition: crypt-des.c:196
static uint32 ip_maskl[8][256]
Definition: crypt-des.c:194
static uint8 m_sbox[4][4096]
Definition: crypt-des.c:192
static uint32 fp_maskr[8][256]
Definition: crypt-des.c:196
static uint32 de_keysl[16]
Definition: crypt-des.c:189
static uint32 saltbits
Definition: crypt-des.c:181
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:98
static uint32 psbox[4][256]
Definition: crypt-des.c:193
char* px_crypt_des ( const char *  key,
const char *  setting 
)

Definition at line 654 of file crypt-des.c.

References _crypt_a64, _PASSWORD_EFMT1, ascii_to_bin(), des_cipher(), des_init(), des_initialised, des_setkey(), do_des(), ereport, errcode(), errmsg(), ERROR, i, NULL, output(), setup_salt(), and StrNCpy.

Referenced by run_crypt_des().

655 {
656  int i;
657  uint32 count,
658  salt,
659  l,
660  r0,
661  r1,
662  keybuf[2];
663  char *p;
664  uint8 *q;
665  static char output[21];
666 
667  if (!des_initialised)
668  des_init();
669 
670 
671  /*
672  * Copy the key, shifting each character up by one bit and padding with
673  * zeros.
674  */
675  q = (uint8 *) keybuf;
676  while (q - (uint8 *) keybuf - 8)
677  {
678  *q++ = *key << 1;
679  if (*key != '\0')
680  key++;
681  }
682  if (des_setkey((char *) keybuf))
683  return (NULL);
684 
685 #ifndef DISABLE_XDES
686  if (*setting == _PASSWORD_EFMT1)
687  {
688  /*
689  * "new"-style: setting must be a 9-character (underscore, then 4
690  * bytes of count, then 4 bytes of salt) string. See CRYPT(3) under
691  * the "Extended crypt" heading for further details.
692  *
693  * Unlimited characters of the input key are used. This is known as
694  * the "Extended crypt" DES method.
695  *
696  */
697  if (strlen(setting) < 9)
698  ereport(ERROR,
699  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
700  errmsg("invalid salt")));
701 
702  for (i = 1, count = 0L; i < 5; i++)
703  count |= ascii_to_bin(setting[i]) << (i - 1) * 6;
704 
705  for (i = 5, salt = 0L; i < 9; i++)
706  salt |= ascii_to_bin(setting[i]) << (i - 5) * 6;
707 
708  while (*key)
709  {
710  /*
711  * Encrypt the key with itself.
712  */
713  if (des_cipher((char *) keybuf, (char *) keybuf, 0L, 1))
714  return (NULL);
715 
716  /*
717  * And XOR with the next 8 characters of the key.
718  */
719  q = (uint8 *) keybuf;
720  while (q - (uint8 *) keybuf - 8 && *key)
721  *q++ ^= *key++ << 1;
722 
723  if (des_setkey((char *) keybuf))
724  return (NULL);
725  }
726  StrNCpy(output, setting, 10);
727 
728  /*
729  * Double check that we weren't given a short setting. If we were, the
730  * above code will probably have created weird values for count and
731  * salt, but we don't really care. Just make sure the output string
732  * doesn't have an extra NUL in it.
733  */
734  p = output + strlen(output);
735  }
736  else
737 #endif /* !DISABLE_XDES */
738  {
739  /*
740  * "old"-style: setting - 2 bytes of salt key - only up to the first 8
741  * characters of the input key are used.
742  */
743  count = 25;
744 
745  if (strlen(setting) < 2)
746  ereport(ERROR,
747  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
748  errmsg("invalid salt")));
749 
750  salt = (ascii_to_bin(setting[1]) << 6)
751  | ascii_to_bin(setting[0]);
752 
753  output[0] = setting[0];
754 
755  /*
756  * If the encrypted password that the salt was extracted from is only
757  * 1 character long, the salt will be corrupted. We need to ensure
758  * that the output string doesn't have an extra NUL in it!
759  */
760  output[1] = setting[1] ? setting[1] : output[0];
761 
762  p = output + 2;
763  }
764  setup_salt(salt);
765 
766  /*
767  * Do it.
768  */
769  if (do_des(0L, 0L, &r0, &r1, count))
770  return (NULL);
771 
772  /*
773  * Now encode the result...
774  */
775  l = (r0 >> 8);
776  *p++ = _crypt_a64[(l >> 18) & 0x3f];
777  *p++ = _crypt_a64[(l >> 12) & 0x3f];
778  *p++ = _crypt_a64[(l >> 6) & 0x3f];
779  *p++ = _crypt_a64[l & 0x3f];
780 
781  l = (r0 << 16) | ((r1 >> 16) & 0xffff);
782  *p++ = _crypt_a64[(l >> 18) & 0x3f];
783  *p++ = _crypt_a64[(l >> 12) & 0x3f];
784  *p++ = _crypt_a64[(l >> 6) & 0x3f];
785  *p++ = _crypt_a64[l & 0x3f];
786 
787  l = r1 << 2;
788  *p++ = _crypt_a64[(l >> 12) & 0x3f];
789  *p++ = _crypt_a64[(l >> 6) & 0x3f];
790  *p++ = _crypt_a64[l & 0x3f];
791  *p = 0;
792 
793  return (output);
794 }
static const char _crypt_a64[]
Definition: crypt-des.c:74
static void output(uint64 loop_count)
unsigned char uint8
Definition: c.h:266
static int des_initialised
Definition: crypt-des.c:191
int errcode(int sqlerrcode)
Definition: elog.c:575
static int des_setkey(const char *key)
Definition: crypt-des.c:399
static void des_init(void)
Definition: crypt-des.c:224
static int do_des(uint32 l_in, uint32 r_in, uint32 *l_out, uint32 *r_out, int count)
Definition: crypt-des.c:486
static int des_cipher(const char *in, char *out, long salt, int count)
Definition: crypt-des.c:620
#define ERROR
Definition: elog.h:43
static int ascii_to_bin(char ch)
Definition: crypt-des.c:206
unsigned int uint32
Definition: c.h:268
#define ereport(elevel, rest)
Definition: elog.h:122
#define NULL
Definition: c.h:229
#define StrNCpy(dst, src, len)
Definition: c.h:830
static void setup_salt(long salt)
Definition: crypt-des.c:376
int errmsg(const char *fmt,...)
Definition: elog.c:797
int i
#define _PASSWORD_EFMT1
Definition: crypt-des.c:72
static void setup_salt ( long  salt)
static

Definition at line 376 of file crypt-des.c.

References i, old_salt, and saltbits.

Referenced by des_cipher(), and px_crypt_des().

377 {
378  uint32 obit,
379  saltbit;
380  int i;
381 
382  if (salt == old_salt)
383  return;
384  old_salt = salt;
385 
386  saltbits = 0L;
387  saltbit = 1;
388  obit = 0x800000;
389  for (i = 0; i < 24; i++)
390  {
391  if (salt & saltbit)
392  saltbits |= obit;
393  saltbit <<= 1;
394  obit >>= 1;
395  }
396 }
static long old_salt
Definition: crypt-des.c:182
unsigned int uint32
Definition: c.h:268
static uint32 saltbits
Definition: crypt-des.c:181
int i

Variable Documentation

const char _crypt_a64[]
static
Initial value:
=
"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"

Definition at line 74 of file crypt-des.c.

Referenced by px_crypt_des().

uint32 _crypt_bits32[32]
static
Initial value:
=
{
0x80000000, 0x40000000, 0x20000000, 0x10000000,
0x08000000, 0x04000000, 0x02000000, 0x01000000,
0x00800000, 0x00400000, 0x00200000, 0x00100000,
0x00080000, 0x00040000, 0x00020000, 0x00010000,
0x00008000, 0x00004000, 0x00002000, 0x00001000,
0x00000800, 0x00000400, 0x00000200, 0x00000100,
0x00000080, 0x00000040, 0x00000020, 0x00000010,
0x00000008, 0x00000004, 0x00000002, 0x00000001
}

Definition at line 167 of file crypt-des.c.

Referenced by des_init().

uint8 _crypt_bits8[8] = {0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01}
static

Definition at line 179 of file crypt-des.c.

Referenced by des_init().

uint32 * bits24
static

Definition at line 183 of file crypt-des.c.

Referenced by des_init().

uint32* bits28
static

Definition at line 183 of file crypt-des.c.

Referenced by des_init().

uint32 comp_maskl[8][128]
static

Definition at line 200 of file crypt-des.c.

Referenced by des_init(), and des_setkey().

uint32 comp_maskr[8][128]
static

Definition at line 200 of file crypt-des.c.

Referenced by des_init(), and des_setkey().

uint8 comp_perm[48]
static
Initial value:
= {
14, 17, 11, 24, 1, 5, 3, 28, 15, 6, 21, 10,
23, 19, 12, 4, 26, 8, 16, 7, 27, 20, 13, 2,
41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48,
44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32
}

Definition at line 98 of file crypt-des.c.

Referenced by des_init().

uint32 de_keysl[16]
static

Definition at line 189 of file crypt-des.c.

Referenced by des_setkey(), and do_des().

uint32 de_keysr[16]
static

Definition at line 189 of file crypt-des.c.

Referenced by des_setkey(), and do_des().

int des_initialised = 0
static

Definition at line 191 of file crypt-des.c.

Referenced by des_cipher(), des_init(), des_setkey(), and px_crypt_des().

uint32 en_keysl[16]
static

Definition at line 187 of file crypt-des.c.

Referenced by des_setkey(), and do_des().

uint32 en_keysr[16]
static

Definition at line 187 of file crypt-des.c.

Referenced by des_setkey(), and do_des().

uint8 final_perm[64]
static

Definition at line 185 of file crypt-des.c.

Referenced by des_init().

uint32 fp_maskl[8][256]
static

Definition at line 196 of file crypt-des.c.

Referenced by des_init(), and do_des().

uint32 fp_maskr[8][256]
static

Definition at line 196 of file crypt-des.c.

Referenced by des_init(), and do_des().

uint8 init_perm[64]
static

Definition at line 185 of file crypt-des.c.

Referenced by des_init().

uint8 inv_comp_perm[56]
static

Definition at line 97 of file crypt-des.c.

Referenced by des_init().

uint8 inv_key_perm[64]
static

Definition at line 84 of file crypt-des.c.

Referenced by des_init().

uint8 IP[64]
static
Initial value:
= {
58, 50, 42, 34, 26, 18, 10, 2, 60, 52, 44, 36, 28, 20, 12, 4,
62, 54, 46, 38, 30, 22, 14, 6, 64, 56, 48, 40, 32, 24, 16, 8,
57, 49, 41, 33, 25, 17, 9, 1, 59, 51, 43, 35, 27, 19, 11, 3,
61, 53, 45, 37, 29, 21, 13, 5, 63, 55, 47, 39, 31, 23, 15, 7
}

Definition at line 77 of file crypt-des.c.

Referenced by des_init().

uint32 ip_maskl[8][256]
static

Definition at line 194 of file crypt-des.c.

Referenced by des_init(), and do_des().

uint32 ip_maskr[8][256]
static

Definition at line 194 of file crypt-des.c.

Referenced by des_init(), and do_des().

uint8 key_perm[56]
static
Initial value:
= {
57, 49, 41, 33, 25, 17, 9, 1, 58, 50, 42, 34, 26, 18,
10, 2, 59, 51, 43, 35, 27, 19, 11, 3, 60, 52, 44, 36,
63, 55, 47, 39, 31, 23, 15, 7, 62, 54, 46, 38, 30, 22,
14, 6, 61, 53, 45, 37, 29, 21, 13, 5, 28, 20, 12, 4
}

Definition at line 86 of file crypt-des.c.

Referenced by des_init().

uint32 key_perm_maskl[8][128]
static

Definition at line 198 of file crypt-des.c.

Referenced by des_init(), and des_setkey().

uint32 key_perm_maskr[8][128]
static

Definition at line 198 of file crypt-des.c.

Referenced by des_init(), and des_setkey().

uint8 key_shifts[16]
static
Initial value:
= {
1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1
}

Definition at line 93 of file crypt-des.c.

Referenced by des_setkey().

uint8 m_sbox[4][4096]
static

Definition at line 192 of file crypt-des.c.

Referenced by des_init(), and do_des().

uint32 old_rawkey0
static

Definition at line 202 of file crypt-des.c.

Referenced by des_init(), and des_setkey().

uint32 old_rawkey1
static

Definition at line 202 of file crypt-des.c.

Referenced by des_init(), and des_setkey().

long old_salt
static

Definition at line 182 of file crypt-des.c.

Referenced by des_init(), and setup_salt().

uint8 pbox[32]
static
Initial value:
= {
16, 7, 20, 21, 29, 12, 28, 17, 1, 15, 23, 26, 5, 18, 31, 10,
2, 8, 24, 14, 32, 27, 3, 9, 19, 13, 30, 6, 22, 11, 4, 25
}

Definition at line 162 of file crypt-des.c.

Referenced by des_init().

uint32 psbox[4][256]
static

Definition at line 193 of file crypt-des.c.

Referenced by des_init(), and do_des().

uint32 saltbits
static

Definition at line 181 of file crypt-des.c.

Referenced by des_init(), do_des(), and setup_salt().

uint8 sbox[8][64]
static

Definition at line 110 of file crypt-des.c.

Referenced by des_init().

uint8 u_key_perm[56]
static

Definition at line 85 of file crypt-des.c.

Referenced by des_init().

uint8 u_sbox[8][64]
static

Definition at line 109 of file crypt-des.c.

Referenced by des_init().

uint8 un_pbox[32]
static

Definition at line 161 of file crypt-des.c.

Referenced by des_init().