PostgreSQL Source Code: contrib/pgcrypto/crypt-des.c File Reference (original) (raw)

#include "[postgres.h](postgres%5F8h%5Fsource.html)"
#include "[miscadmin.h](miscadmin%5F8h%5Fsource.html)"
#include "[port/pg_bswap.h](pg%5F%5Fbswap%5F8h%5Fsource.html)"
#include "[px-crypt.h](px-crypt%5F8h%5Fsource.html)"

Go to the source code of this file.

◆ _PASSWORD_EFMT1

#define _PASSWORD_EFMT1 '_'

◆ ascii_to_bin()

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

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

618{

621 r_out,

622 rawl,

623 rawr;

624 int retval;

625

628

630

631

632 memcpy(buffer, in, sizeof(buffer));

633

636

637 retval = do_des(rawl, rawr, &l_out, &r_out, count);

638 if (retval)

639 return retval;

640

643

644

645 memcpy(out, buffer, sizeof(buffer));

646

647 return retval;

648}

static void des_init(void)

static void setup_salt(long salt)

static int des_initialised

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

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

Referenced by px_crypt_des().

◆ des_init()

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

222{

223 int i,

224 j,

225 b,

226 k,

227 inbit,

228 obit;

230 *il,

231 *ir,

232 *fl,

233 *fr;

234

239

240

241

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);

248 }

249

250

251

252

253

254 for (b = 0; b < 4; b++)

255 for (i = 0; i < 64; i++)

256 for (j = 0; j < 64; j++)

260

261

262

263

264

265 for (i = 0; i < 64; i++)

266 {

269 }

270

271

272

273

274

275 for (i = 0; i < 56; i++)

276 {

280 }

281

282

283

284

285 for (i = 0; i < 48; i++)

287

288

289

290

291

292 for (k = 0; k < 8; k++)

293 {

294 for (i = 0; i < 256; i++)

295 {

300 for (j = 0; j < 8; j++)

301 {

302 inbit = 8 * k + j;

304 {

305 if ((obit = init_perm[inbit]) < 32)

307 else

311 else

313 }

314 }

315 }

316 for (i = 0; i < 128; i++)

317 {

320 for (j = 0; j < 7; j++)

321 {

322 inbit = 8 * k + j;

324 {

326 continue;

327 if (obit < 28)

329 else

330 *ir |= bits28[obit - 28];

331 }

332 }

335 for (j = 0; j < 7; j++)

336 {

337 inbit = 7 * k + j;

339 {

341 continue;

342 if (obit < 24)

344 else

345 *ir |= bits24[obit - 24];

346 }

347 }

348 }

349 }

350

351

352

353

354

355 for (i = 0; i < 32; 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 {

366 }

367 }

368

370}

static uint8 inv_key_perm[64]

static uint32 key_perm_maskl[8][128]

static uint32 ip_maskl[8][256]

static uint32 comp_maskl[8][128]

static uint8 key_perm[56]

static uint32 psbox[4][256]

static uint32 fp_maskr[8][256]

static uint8 u_key_perm[56]

static uint32 _crypt_bits32[32]

static uint8 init_perm[64]

static uint32 old_rawkey0

static uint8 final_perm[64]

static uint32 comp_maskr[8][128]

static uint32 key_perm_maskr[8][128]

static uint8 comp_perm[48]

static uint8 m_sbox[4][4096]

static uint8 u_sbox[8][64]

static uint32 fp_maskl[8][256]

static uint32 old_rawkey1

static uint8 _crypt_bits8[8]

static uint8 inv_comp_perm[56]

static uint32 ip_maskr[8][256]

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

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

397{

399 k1,

400 rawkey0,

401 rawkey1;

402 int shifts,

403 round;

404

407

410

411 if ((rawkey0 | rawkey1)

414 {

415

416

417

418

419

420 return 0;

421 }

424

425

426

427

444

445

446

447

448 shifts = 0;

449 for (round = 0; round < 16; round++)

450 {

452 t1;

453

455

456 t0 = (k0 << shifts) | (k0 >> (28 - shifts));

457 t1 = (k1 << shifts) | (k1 >> (28 - shifts));

458

468

478 }

479 return 0;

480}

static uint32 en_keysr[16]

static uint32 de_keysr[16]

static uint8 key_shifts[16]

static uint32 en_keysl[16]

static uint32 de_keysl[16]

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

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

484{

485

486

487

489 r,

490 *kl,

491 *kr,

492 *kl1,

493 *kr1;

495 r48l,

496 r48r;

497 int round;

498

499 if (count == 0)

500 return 1;

501 else if (count > 0)

502 {

503

504

505

508 }

509 else

510 {

511

512

513

514 count = -count;

517 }

518

519

520

521

523 | ip_maskl[1][(l_in >> 16) & 0xff]

524 | ip_maskl[2][(l_in >> 8) & 0xff]

527 | ip_maskl[5][(r_in >> 16) & 0xff]

528 | ip_maskl[6][(r_in >> 8) & 0xff]

531 | ip_maskr[1][(l_in >> 16) & 0xff]

532 | ip_maskr[2][(l_in >> 8) & 0xff]

535 | ip_maskr[5][(r_in >> 16) & 0xff]

536 | ip_maskr[6][(r_in >> 8) & 0xff]

538

539 while (count--)

540 {

542

543

544

545

546 kl = kl1;

547 kr = kr1;

548 round = 16;

549 while (round--)

550 {

551

552

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

568

569

570 f = (r48l ^ r48r) & saltbits;

571 r48l ^= f ^ *kl++;

572 r48r ^= f ^ *kr++;

573

574

575

576

577

582

583

584

585

586 f ^= l;

587 l = r;

588 r = f;

589 }

590 r = l;

591 l = f;

592 }

593

594

595

596

597 *l_out = fp_maskl[0][l >> 24]

598 | fp_maskl[1][(l >> 16) & 0xff]

599 | fp_maskl[2][(l >> 8) & 0xff]

602 | fp_maskl[5][(r >> 16) & 0xff]

603 | fp_maskl[6][(r >> 8) & 0xff]

605 *r_out = fp_maskr[0][l >> 24]

606 | fp_maskr[1][(l >> 16) & 0xff]

607 | fp_maskr[2][(l >> 8) & 0xff]

610 | fp_maskr[5][(r >> 16) & 0xff]

611 | fp_maskr[6][(r >> 8) & 0xff]

613 return 0;

614}

#define CHECK_FOR_INTERRUPTS()

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

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

652{

653 int i;

655 salt,

656 l,

657 r0,

658 r1,

659 keybuf[2];

660 char *p;

662 static char output[21];

663

666

667

668

669

670

671

672 q = (uint8 *) keybuf;

673 while (q - (uint8 *) keybuf - 8)

674 {

675 *q++ = *key << 1;

676 if (*key != '\0')

678 }

680 return NULL;

681

682#ifndef DISABLE_XDES

684 {

685

686

687

688

689

690

691

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++)

701

702 for (i = 5, salt = 0L; i < 9; i++)

704

705 while (*key)

706 {

707

708

709

710 if (des_cipher((char *) keybuf, (char *) keybuf, 0L, 1))

711 return NULL;

712

713

714

715

716 q = (uint8 *) keybuf;

717 while (q - (uint8 *) keybuf - 8 && *key)

718 *q++ ^= *key++ << 1;

719

721 return NULL;

722 }

724

725

726

727

728

729

730

732 }

733 else

734#endif

735 {

736

737

738

739

740 count = 25;

741

742 if (strlen(setting) < 2)

744 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),

745 errmsg("invalid salt")));

746

749

750 output[0] = setting[0];

751

752

753

754

755

756

757 output[1] = setting[1] ? setting[1] : output[0];

758

760 }

762

763

764

765

766 if (do_des(0L, 0L, &r0, &r1, count))

767 return NULL;

768

769

770

771

772 l = (r0 >> 8);

777

778 l = (r0 << 16) | ((r1 >> 16) & 0xffff);

783

784 l = r1 << 2;

788 *p = 0;

789

791}

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

static int ascii_to_bin(char ch)

static int des_setkey(const char *key)

static const char _crypt_a64[]

int errcode(int sqlerrcode)

int errmsg(const char *fmt,...)

#define ereport(elevel,...)

size_t strlcpy(char *dst, const char *src, size_t siz)

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

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

374{

376 saltbit;

377 int i;

378

380 return;

382

384 saltbit = 1;

385 obit = 0x800000;

386 for (i = 0; i < 24; i++)

387 {

388 if (salt & saltbit)

390 saltbit <<= 1;

391 obit >>= 1;

392 }

393}

References i, old_salt, and saltbits.

Referenced by des_cipher(), and px_crypt_des().

◆ _crypt_a64

Initial value:

=

"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"

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

Referenced by px_crypt_des().

◆ _crypt_bits32

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

◆ bits24

◆ bits28

◆ comp_maskl

◆ comp_maskr

◆ comp_perm

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

◆ de_keysr

◆ des_initialised

◆ en_keysl

◆ en_keysr

◆ final_perm

◆ fp_maskl

◆ fp_maskr

◆ init_perm

◆ inv_comp_perm

◆ inv_key_perm

◆ IP

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

◆ ip_maskr

◆ key_perm

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

◆ key_perm_maskr

◆ key_shifts

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

◆ old_rawkey0

◆ old_rawkey1

◆ old_salt

◆ pbox

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

◆ saltbits

◆ sbox

◆ u_key_perm

◆ u_sbox

◆ un_pbox