PostgreSQL Source Code git master
Macros | Functions | Variables
crypt-des.c File Reference
#include "postgres.h"
#include "miscadmin.h"
#include "port/pg_bswap.h"
#include "px-crypt.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 uint32 *  bits28
 
static uint32 *  bits24
 
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

◆ _PASSWORD_EFMT1

#define _PASSWORD_EFMT1   '_'

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

Function Documentation

◆ ascii_to_bin()

static int ascii_to_bin ( char  ch )
inlinestatic

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

204{
205 if (ch > 'z')
206 return 0;
207 if (ch >= 'a')
208 return (ch - 'a' + 38);
209 if (ch > 'Z')
210 return 0;
211 if (ch >= 'A')
212 return (ch - 'A' + 12);
213 if (ch > '9')
214 return 0;
215 if (ch >= '.')
216 return (ch - '.');
217 return 0;
218}

Referenced by px_crypt_des().

◆ des_cipher()

static int des_cipher ( const char *  in,
char *  out,
long  salt,
int  count 
)
static

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

618{
619 uint32 buffer[2];
620 uint32 l_out,
621 r_out,
622 rawl,
623 rawr;
624 int retval;
625
626 if (!des_initialised)
627 des_init();
628
629 setup_salt(salt);
630
631 /* copy data to avoid assuming input is word-aligned */
632 memcpy(buffer, in, sizeof(buffer));
633
634 rawl = pg_ntoh32(buffer[0]);
635 rawr = pg_ntoh32(buffer[1]);
636
637 retval = do_des(rawl, rawr, &l_out, &r_out, count);
638 if (retval)
639 return retval;
640
641 buffer[0] = pg_hton32(l_out);
642 buffer[1] = pg_hton32(r_out);
643
644 /* copy data to avoid assuming output is word-aligned */
645 memcpy(out, buffer, sizeof(buffer));
646
647 return retval;
648}
uint32_t uint32
Definition: c.h:538
static void des_init(void)
Definition: crypt-des.c:221
static void setup_salt(long salt)
Definition: crypt-des.c:373
static int des_initialised
Definition: crypt-des.c:188
static int do_des(uint32 l_in, uint32 r_in, uint32 *l_out, uint32 *r_out, int count)
Definition: crypt-des.c:483
#define pg_ntoh32(x)
Definition: pg_bswap.h:125
#define pg_hton32(x)
Definition: pg_bswap.h:121

References des_init(), des_initialised, do_des(), pg_hton32, pg_ntoh32, and setup_salt().

Referenced by px_crypt_des().

◆ des_init()

static void des_init ( void  )
static

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

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

References _crypt_bits32, _crypt_bits8, b, 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, j, 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().

◆ des_setkey()

static int des_setkey ( const char *  key )
static

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

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

References comp_maskl, comp_maskr, de_keysl, de_keysr, des_init(), des_initialised, en_keysl, en_keysr, sort-test::key, key_perm_maskl, key_perm_maskr, key_shifts, old_rawkey0, old_rawkey1, and pg_ntoh32.

Referenced by px_crypt_des().

◆ do_des()

static int do_des ( uint32  l_in,
uint32  r_in,
uint32 *  l_out,
uint32 *  r_out,
int  count 
)
static

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

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

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().

◆ px_crypt_des()

char * px_crypt_des ( const char *  key,
const char *  setting 
)

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

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

References _crypt_a64, _PASSWORD_EFMT1, ascii_to_bin(), des_cipher(), des_init(), des_initialised, des_setkey(), do_des(), ereport, errcode(), errmsg(), ERROR, i, sort-test::key, output, setup_salt(), and strlcpy().

Referenced by run_crypt_des().

◆ setup_salt()

static void setup_salt ( long  salt )
static

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

374{
375 uint32 obit,
376 saltbit;
377 int i;
378
379 if (salt == old_salt)
380 return;
381 old_salt = salt;
382
383 saltbits = 0L;
384 saltbit = 1;
385 obit = 0x800000;
386 for (i = 0; i < 24; i++)
387 {
388 if (salt & saltbit)
389 saltbits |= obit;
390 saltbit <<= 1;
391 obit >>= 1;
392 }
393}

References i, old_salt, and saltbits.

Referenced by des_cipher(), and px_crypt_des().

Variable Documentation

◆ _crypt_a64

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

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

Referenced by px_crypt_des().

◆ _crypt_bits32

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 164 of file crypt-des.c.

Referenced by des_init().

◆ _crypt_bits8

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

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

Referenced by des_init().

◆ bits24

uint32 * bits24
static

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

Referenced by des_init().

◆ bits28

uint32* bits28
static

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

Referenced by des_init().

◆ comp_maskl

uint32 comp_maskl[8][128]
static

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

Referenced by des_init(), and des_setkey().

◆ comp_maskr

uint32 comp_maskr[8][128]
static

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

Referenced by des_init(), and des_setkey().

◆ comp_perm

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 95 of file crypt-des.c.

Referenced by des_init().

◆ de_keysl

uint32 de_keysl[16]
static

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

Referenced by des_setkey(), and do_des().

◆ de_keysr

uint32 de_keysr[16]
static

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

Referenced by des_setkey(), and do_des().

◆ des_initialised

int des_initialised = 0
static

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

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

◆ en_keysl

uint32 en_keysl[16]
static

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

Referenced by des_setkey(), and do_des().

◆ en_keysr

uint32 en_keysr[16]
static

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

Referenced by des_setkey(), and do_des().

◆ final_perm

uint8 final_perm[64]
static

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

Referenced by des_init().

◆ fp_maskl

uint32 fp_maskl[8][256]
static

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

Referenced by des_init(), and do_des().

◆ fp_maskr

uint32 fp_maskr[8][256]
static

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

Referenced by des_init(), and do_des().

◆ init_perm

uint8 init_perm[64]
static

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

Referenced by des_init().

◆ inv_comp_perm

uint8 inv_comp_perm[56]
static

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

Referenced by des_init().

◆ inv_key_perm

uint8 inv_key_perm[64]
static

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

Referenced by des_init().

◆ IP

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 74 of file crypt-des.c.

Referenced by base_yylex_location(), and des_init().

◆ ip_maskl

uint32 ip_maskl[8][256]
static

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

Referenced by des_init(), and do_des().

◆ ip_maskr

uint32 ip_maskr[8][256]
static

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

Referenced by des_init(), and do_des().

◆ key_perm

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 83 of file crypt-des.c.

Referenced by des_init().

◆ key_perm_maskl

uint32 key_perm_maskl[8][128]
static

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

Referenced by des_init(), and des_setkey().

◆ key_perm_maskr

uint32 key_perm_maskr[8][128]
static

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

Referenced by des_init(), and des_setkey().

◆ key_shifts

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 90 of file crypt-des.c.

Referenced by des_setkey().

◆ m_sbox

uint8 m_sbox[4][4096]
static

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

Referenced by des_init(), and do_des().

◆ old_rawkey0

uint32 old_rawkey0
static

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

Referenced by des_init(), and des_setkey().

◆ old_rawkey1

uint32 old_rawkey1
static

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

Referenced by des_init(), and des_setkey().

◆ old_salt

long old_salt
static

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

Referenced by des_init(), and setup_salt().

◆ pbox

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 159 of file crypt-des.c.

Referenced by des_init().

◆ psbox

uint32 psbox[4][256]
static

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

Referenced by des_init(), and do_des().

◆ saltbits

uint32 saltbits
static

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

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

◆ sbox

uint8 sbox[8][64]
static

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

Referenced by des_init().

◆ u_key_perm

uint8 u_key_perm[56]
static

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

Referenced by des_init().

◆ u_sbox

uint8 u_sbox[8][64]
static

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

Referenced by des_init().

◆ un_pbox

uint8 un_pbox[32]
static

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

Referenced by des_init().

AltStyle によって変換されたページ (->オリジナル) /