API tools faq
paste
Advertisement
FlyFar

d3des.c

FlyFar
Dec 23rd, 2023
463
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 15.44 KB | Cybersecurity | 0 0
raw download clone embed print report
  1. /*
  2.  * This is D3DES (V5.09) by Richard Outerbridge with the double and
  3.  * triple-length support removed for use in VNC.  Also the bytebit[] array
  4.  * has been reversed so that the most significant bit in each byte of the
  5.  * key is ignored, not the least significant.
  6.  *
  7.  * These changes are:
  8.  *  Copyright (C) 1999 AT&T Laboratories Cambridge.  All Rights Reserved.
  9.  *
  10.  * This software is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  13.  */
  14.  
  15. /* D3DES (V5.09) -
  16.  *
  17.  * A portable, public domain, version of the Data Encryption Standard.
  18.  *
  19.  * Written with Symantec's THINK (Lightspeed) C by Richard Outerbridge.
  20.  * Thanks to: Dan Hoey for his excellent Initial and Inverse permutation
  21.  * code;  Jim Gillogly & Phil Karn for the DES key schedule code; Dennis
  22.  * Ferguson, Eric Young and Dana How for comparing notes; and Ray Lau,
  23.  * for humouring me on.
  24.  *
  25.  * Copyright (c) 1988,1989,1990,1991,1992 by Richard Outerbridge.
  26.  * (GEnie : OUTER; CIS : [71755,204]) Graven Imagery, 1992.
  27.  */
  28.  
  29. #include "d3des.h"
  30.  
  31. static void scrunch(unsigned char *, unsigned long *);
  32. static void unscrun(unsigned long *, unsigned char *);
  33. static void desfunc(unsigned long *, unsigned long *);
  34. static void cookey(unsigned long *);
  35.  
  36. static unsigned long KnL[32] = { 0L };
  37.  
  38. static unsigned short bytebit[8]    = {
  39.     01, 02, 04, 010, 020, 040, 0100, 0200 };
  40.  
  41. static unsigned long bigbyte[24] = {
  42.     0x800000L,  0x400000L,  0x200000L,  0x100000L,
  43.     0x80000L,   0x40000L,   0x20000L,   0x10000L,
  44.     0x8000L,    0x4000L,    0x2000L,    0x1000L,
  45.     0x800L,     0x400L,     0x200L,     0x100L,
  46.     0x80L,      0x40L,      0x20L,      0x10L,
  47.     0x8L,       0x4L,       0x2L,       0x1L    };
  48.  
  49. /* Use the key schedule specified in the Standard (ANSI X3.92-1981). */
  50.  
  51. static unsigned char pc1[56] = {
  52.     56, 48, 40, 32, 24, 16,  8,  0, 57, 49, 41, 33, 25, 17,
  53.      9,  1, 58, 50, 42, 34, 26, 18, 10,  2, 59, 51, 43, 35,
  54.     62, 54, 46, 38, 30, 22, 14,  6, 61, 53, 45, 37, 29, 21,
  55.     13,  5, 60, 52, 44, 36, 28, 20, 12,  4, 27, 19, 11,  3 };
  56.  
  57. static unsigned char totrot[16] = {
  58.     1,2,4,6,8,10,12,14,15,17,19,21,23,25,27,28 };
  59.  
  60. static unsigned char pc2[48] = {
  61.     13, 16, 10, 23,  0,  4,  2, 27, 14,  5, 20,  9,
  62.     22, 18, 11,  3, 25,  7, 15,  6, 26, 19, 12,  1,
  63.     40, 51, 30, 36, 46, 54, 29, 39, 50, 44, 32, 47,
  64.     43, 48, 38, 55, 33, 52, 45, 41, 49, 35, 28, 31 };
  65.  
  66. void deskey(key, edf)   /* Thanks to James Gillogly & Phil Karn! */
  67. unsigned char *key;
  68. int edf;
  69. {
  70.     register int i, j, l, m, n;
  71.     unsigned char pc1m[56], pcr[56];
  72.     unsigned long kn[32];
  73.  
  74.     for ( j = 0; j < 56; j++ ) {
  75.         l = pc1[j];
  76.         m = l & 07;
  77.         pc1m[j] = (key[l >> 3] & bytebit[m]) ? 1 : 0;
  78.         }
  79.     for( i = 0; i < 16; i++ ) {
  80.         if( edf == DE1 ) m = (15 - i) << 1;
  81.         else m = i << 1;
  82.         n = m + 1;
  83.         kn[m] = kn[n] = 0L;
  84.         for( j = 0; j < 28; j++ ) {
  85.             l = j + totrot[i];
  86.             if( l < 28 ) pcr[j] = pc1m[l];
  87.             else pcr[j] = pc1m[l - 28];
  88.             }
  89.         for( j = 28; j < 56; j++ ) {
  90.             l = j + totrot[i];
  91.             if( l < 56 ) pcr[j] = pc1m[l];
  92.             else pcr[j] = pc1m[l - 28];
  93.             }
  94.         for( j = 0; j < 24; j++ ) {
  95.             if( pcr[pc2[j]] ) kn[m] |= bigbyte[j];
  96.             if( pcr[pc2[j+24]] ) kn[n] |= bigbyte[j];
  97.             }
  98.         }
  99.     cookey(kn);
  100.     return;
  101.     }
  102.  
  103. static void cookey(raw1)
  104. register unsigned long *raw1;
  105. {
  106.     register unsigned long *cook, *raw0;
  107.     unsigned long dough[32];
  108.     register int i;
  109.  
  110.     cook = dough;
  111.     for( i = 0; i < 16; i++, raw1++ ) {
  112.         raw0 = raw1++;
  113.         *cook    = (*raw0 & 0x00fc0000L) << 6;
  114.         *cook   |= (*raw0 & 0x00000fc0L) << 10;
  115.         *cook   |= (*raw1 & 0x00fc0000L) >> 10;
  116.         *cook++ |= (*raw1 & 0x00000fc0L) >> 6;
  117.         *cook    = (*raw0 & 0x0003f000L) << 12;
  118.         *cook   |= (*raw0 & 0x0000003fL) << 16;
  119.         *cook   |= (*raw1 & 0x0003f000L) >> 4;
  120.         *cook++ |= (*raw1 & 0x0000003fL);
  121.         }
  122.     usekey(dough);
  123.     return;
  124.     }
  125.  
  126. void cpkey(into)
  127. register unsigned long *into;
  128. {
  129.     register unsigned long *from, *endp;
  130.  
  131.     from = KnL, endp = &KnL[32];
  132.     while( from < endp ) *into++ = *from++;
  133.     return;
  134.     }
  135.  
  136. void usekey(from)
  137. register unsigned long *from;
  138. {
  139.     register unsigned long *to, *endp;
  140.  
  141.     to = KnL, endp = &KnL[32];
  142.     while( to < endp ) *to++ = *from++;
  143.     return;
  144.     }
  145.  
  146. void des(inblock, outblock)
  147. unsigned char *inblock, *outblock;
  148. {
  149.     unsigned long work[2];
  150.  
  151.     scrunch(inblock, work);
  152.     desfunc(work, KnL);
  153.     unscrun(work, outblock);
  154.     return;
  155.     }
  156.  
  157. static void scrunch(outof, into)
  158. register unsigned char *outof;
  159. register unsigned long *into;
  160. {
  161.     *into    = (*outof++ & 0xffL) << 24;
  162.     *into   |= (*outof++ & 0xffL) << 16;
  163.     *into   |= (*outof++ & 0xffL) << 8;
  164.     *into++ |= (*outof++ & 0xffL);
  165.     *into    = (*outof++ & 0xffL) << 24;
  166.     *into   |= (*outof++ & 0xffL) << 16;
  167.     *into   |= (*outof++ & 0xffL) << 8;
  168.     *into   |= (*outof   & 0xffL);
  169.     return;
  170.     }
  171.  
  172. static void unscrun(outof, into)
  173. register unsigned long *outof;
  174. register unsigned char *into;
  175. {
  176.     *into++ = (unsigned char)((*outof >> 24) & 0xffL);
  177.     *into++ = (unsigned char)((*outof >> 16) & 0xffL);
  178.     *into++ = (unsigned char)((*outof >>  8) & 0xffL);
  179.     *into++ = (unsigned char)(*outof++   & 0xffL);
  180.     *into++ = (unsigned char)((*outof >> 24) & 0xffL);
  181.     *into++ = (unsigned char)((*outof >> 16) & 0xffL);
  182.     *into++ = (unsigned char)((*outof >>  8) & 0xffL);
  183.     *into   =  (unsigned char)(*outof    & 0xffL);
  184.     return;
  185.     }
  186.  
  187. static unsigned long SP1[64] = {
  188.     0x01010400L, 0x00000000L, 0x00010000L, 0x01010404L,
  189.     0x01010004L, 0x00010404L, 0x00000004L, 0x00010000L,
  190.     0x00000400L, 0x01010400L, 0x01010404L, 0x00000400L,
  191.     0x01000404L, 0x01010004L, 0x01000000L, 0x00000004L,
  192.     0x00000404L, 0x01000400L, 0x01000400L, 0x00010400L,
  193.     0x00010400L, 0x01010000L, 0x01010000L, 0x01000404L,
  194.     0x00010004L, 0x01000004L, 0x01000004L, 0x00010004L,
  195.     0x00000000L, 0x00000404L, 0x00010404L, 0x01000000L,
  196.     0x00010000L, 0x01010404L, 0x00000004L, 0x01010000L,
  197.     0x01010400L, 0x01000000L, 0x01000000L, 0x00000400L,
  198.     0x01010004L, 0x00010000L, 0x00010400L, 0x01000004L,
  199.     0x00000400L, 0x00000004L, 0x01000404L, 0x00010404L,
  200.     0x01010404L, 0x00010004L, 0x01010000L, 0x01000404L,
  201.     0x01000004L, 0x00000404L, 0x00010404L, 0x01010400L,
  202.     0x00000404L, 0x01000400L, 0x01000400L, 0x00000000L,
  203.     0x00010004L, 0x00010400L, 0x00000000L, 0x01010004L };
  204.  
  205. static unsigned long SP2[64] = {
  206.     0x80108020L, 0x80008000L, 0x00008000L, 0x00108020L,
  207.     0x00100000L, 0x00000020L, 0x80100020L, 0x80008020L,
  208.     0x80000020L, 0x80108020L, 0x80108000L, 0x80000000L,
  209.     0x80008000L, 0x00100000L, 0x00000020L, 0x80100020L,
  210.     0x00108000L, 0x00100020L, 0x80008020L, 0x00000000L,
  211.     0x80000000L, 0x00008000L, 0x00108020L, 0x80100000L,
  212.     0x00100020L, 0x80000020L, 0x00000000L, 0x00108000L,
  213.     0x00008020L, 0x80108000L, 0x80100000L, 0x00008020L,
  214.     0x00000000L, 0x00108020L, 0x80100020L, 0x00100000L,
  215.     0x80008020L, 0x80100000L, 0x80108000L, 0x00008000L,
  216.     0x80100000L, 0x80008000L, 0x00000020L, 0x80108020L,
  217.     0x00108020L, 0x00000020L, 0x00008000L, 0x80000000L,
  218.     0x00008020L, 0x80108000L, 0x00100000L, 0x80000020L,
  219.     0x00100020L, 0x80008020L, 0x80000020L, 0x00100020L,
  220.     0x00108000L, 0x00000000L, 0x80008000L, 0x00008020L,
  221.     0x80000000L, 0x80100020L, 0x80108020L, 0x00108000L };
  222.  
  223. static unsigned long SP3[64] = {
  224.     0x00000208L, 0x08020200L, 0x00000000L, 0x08020008L,
  225.     0x08000200L, 0x00000000L, 0x00020208L, 0x08000200L,
  226.     0x00020008L, 0x08000008L, 0x08000008L, 0x00020000L,
  227.     0x08020208L, 0x00020008L, 0x08020000L, 0x00000208L,
  228.     0x08000000L, 0x00000008L, 0x08020200L, 0x00000200L,
  229.     0x00020200L, 0x08020000L, 0x08020008L, 0x00020208L,
  230.     0x08000208L, 0x00020200L, 0x00020000L, 0x08000208L,
  231.     0x00000008L, 0x08020208L, 0x00000200L, 0x08000000L,
  232.     0x08020200L, 0x08000000L, 0x00020008L, 0x00000208L,
  233.     0x00020000L, 0x08020200L, 0x08000200L, 0x00000000L,
  234.     0x00000200L, 0x00020008L, 0x08020208L, 0x08000200L,
  235.     0x08000008L, 0x00000200L, 0x00000000L, 0x08020008L,
  236.     0x08000208L, 0x00020000L, 0x08000000L, 0x08020208L,
  237.     0x00000008L, 0x00020208L, 0x00020200L, 0x08000008L,
  238.     0x08020000L, 0x08000208L, 0x00000208L, 0x08020000L,
  239.     0x00020208L, 0x00000008L, 0x08020008L, 0x00020200L };
  240.  
  241. static unsigned long SP4[64] = {
  242.     0x00802001L, 0x00002081L, 0x00002081L, 0x00000080L,
  243.     0x00802080L, 0x00800081L, 0x00800001L, 0x00002001L,
  244.     0x00000000L, 0x00802000L, 0x00802000L, 0x00802081L,
  245.     0x00000081L, 0x00000000L, 0x00800080L, 0x00800001L,
  246.     0x00000001L, 0x00002000L, 0x00800000L, 0x00802001L,
  247.     0x00000080L, 0x00800000L, 0x00002001L, 0x00002080L,
  248.     0x00800081L, 0x00000001L, 0x00002080L, 0x00800080L,
  249.     0x00002000L, 0x00802080L, 0x00802081L, 0x00000081L,
  250.     0x00800080L, 0x00800001L, 0x00802000L, 0x00802081L,
  251.     0x00000081L, 0x00000000L, 0x00000000L, 0x00802000L,
  252.     0x00002080L, 0x00800080L, 0x00800081L, 0x00000001L,
  253.     0x00802001L, 0x00002081L, 0x00002081L, 0x00000080L,
  254.     0x00802081L, 0x00000081L, 0x00000001L, 0x00002000L,
  255.     0x00800001L, 0x00002001L, 0x00802080L, 0x00800081L,
  256.     0x00002001L, 0x00002080L, 0x00800000L, 0x00802001L,
  257.     0x00000080L, 0x00800000L, 0x00002000L, 0x00802080L };
  258.  
  259. static unsigned long SP5[64] = {
  260.     0x00000100L, 0x02080100L, 0x02080000L, 0x42000100L,
  261.     0x00080000L, 0x00000100L, 0x40000000L, 0x02080000L,
  262.     0x40080100L, 0x00080000L, 0x02000100L, 0x40080100L,
  263.     0x42000100L, 0x42080000L, 0x00080100L, 0x40000000L,
  264.     0x02000000L, 0x40080000L, 0x40080000L, 0x00000000L,
  265.     0x40000100L, 0x42080100L, 0x42080100L, 0x02000100L,
  266.     0x42080000L, 0x40000100L, 0x00000000L, 0x42000000L,
  267.     0x02080100L, 0x02000000L, 0x42000000L, 0x00080100L,
  268.     0x00080000L, 0x42000100L, 0x00000100L, 0x02000000L,
  269.     0x40000000L, 0x02080000L, 0x42000100L, 0x40080100L,
  270.     0x02000100L, 0x40000000L, 0x42080000L, 0x02080100L,
  271.     0x40080100L, 0x00000100L, 0x02000000L, 0x42080000L,
  272.     0x42080100L, 0x00080100L, 0x42000000L, 0x42080100L,
  273.     0x02080000L, 0x00000000L, 0x40080000L, 0x42000000L,
  274.     0x00080100L, 0x02000100L, 0x40000100L, 0x00080000L,
  275.     0x00000000L, 0x40080000L, 0x02080100L, 0x40000100L };
  276.  
  277. static unsigned long SP6[64] = {
  278.     0x20000010L, 0x20400000L, 0x00004000L, 0x20404010L,
  279.     0x20400000L, 0x00000010L, 0x20404010L, 0x00400000L,
  280.     0x20004000L, 0x00404010L, 0x00400000L, 0x20000010L,
  281.     0x00400010L, 0x20004000L, 0x20000000L, 0x00004010L,
  282.     0x00000000L, 0x00400010L, 0x20004010L, 0x00004000L,
  283.     0x00404000L, 0x20004010L, 0x00000010L, 0x20400010L,
  284.     0x20400010L, 0x00000000L, 0x00404010L, 0x20404000L,
  285.     0x00004010L, 0x00404000L, 0x20404000L, 0x20000000L,
  286.     0x20004000L, 0x00000010L, 0x20400010L, 0x00404000L,
  287.     0x20404010L, 0x00400000L, 0x00004010L, 0x20000010L,
  288.     0x00400000L, 0x20004000L, 0x20000000L, 0x00004010L,
  289.     0x20000010L, 0x20404010L, 0x00404000L, 0x20400000L,
  290.     0x00404010L, 0x20404000L, 0x00000000L, 0x20400010L,
  291.     0x00000010L, 0x00004000L, 0x20400000L, 0x00404010L,
  292.     0x00004000L, 0x00400010L, 0x20004010L, 0x00000000L,
  293.     0x20404000L, 0x20000000L, 0x00400010L, 0x20004010L };
  294.  
  295. static unsigned long SP7[64] = {
  296.     0x00200000L, 0x04200002L, 0x04000802L, 0x00000000L,
  297.     0x00000800L, 0x04000802L, 0x00200802L, 0x04200800L,
  298.     0x04200802L, 0x00200000L, 0x00000000L, 0x04000002L,
  299.     0x00000002L, 0x04000000L, 0x04200002L, 0x00000802L,
  300.     0x04000800L, 0x00200802L, 0x00200002L, 0x04000800L,
  301.     0x04000002L, 0x04200000L, 0x04200800L, 0x00200002L,
  302.     0x04200000L, 0x00000800L, 0x00000802L, 0x04200802L,
  303.     0x00200800L, 0x00000002L, 0x04000000L, 0x00200800L,
  304.     0x04000000L, 0x00200800L, 0x00200000L, 0x04000802L,
  305.     0x04000802L, 0x04200002L, 0x04200002L, 0x00000002L,
  306.     0x00200002L, 0x04000000L, 0x04000800L, 0x00200000L,
  307.     0x04200800L, 0x00000802L, 0x00200802L, 0x04200800L,
  308.     0x00000802L, 0x04000002L, 0x04200802L, 0x04200000L,
  309.     0x00200800L, 0x00000000L, 0x00000002L, 0x04200802L,
  310.     0x00000000L, 0x00200802L, 0x04200000L, 0x00000800L,
  311.     0x04000002L, 0x04000800L, 0x00000800L, 0x00200002L };
  312.  
  313. static unsigned long SP8[64] = {
  314.     0x10001040L, 0x00001000L, 0x00040000L, 0x10041040L,
  315.     0x10000000L, 0x10001040L, 0x00000040L, 0x10000000L,
  316.     0x00040040L, 0x10040000L, 0x10041040L, 0x00041000L,
  317.     0x10041000L, 0x00041040L, 0x00001000L, 0x00000040L,
  318.     0x10040000L, 0x10000040L, 0x10001000L, 0x00001040L,
  319.     0x00041000L, 0x00040040L, 0x10040040L, 0x10041000L,
  320.     0x00001040L, 0x00000000L, 0x00000000L, 0x10040040L,
  321.     0x10000040L, 0x10001000L, 0x00041040L, 0x00040000L,
  322.     0x00041040L, 0x00040000L, 0x10041000L, 0x00001000L,
  323.     0x00000040L, 0x10040040L, 0x00001000L, 0x00041040L,
  324.     0x10001000L, 0x00000040L, 0x10000040L, 0x10040000L,
  325.     0x10040040L, 0x10000000L, 0x00040000L, 0x10001040L,
  326.     0x00000000L, 0x10041040L, 0x00040040L, 0x10000040L,
  327.     0x10040000L, 0x10001000L, 0x10001040L, 0x00000000L,
  328.     0x10041040L, 0x00041000L, 0x00041000L, 0x00001040L,
  329.     0x00001040L, 0x00040040L, 0x10000000L, 0x10041000L };
  330.  
  331. static void desfunc(block, keys)
  332. register unsigned long *block, *keys;
  333. {
  334.     register unsigned long fval, work, right, leftt;
  335.     register int round;
  336.  
  337.     leftt = block[0];
  338.     right = block[1];
  339.     work = ((leftt >> 4) ^ right) & 0x0f0f0f0fL;
  340.     right ^= work;
  341.     leftt ^= (work << 4);
  342.     work = ((leftt >> 16) ^ right) & 0x0000ffffL;
  343.     right ^= work;
  344.     leftt ^= (work << 16);
  345.     work = ((right >> 2) ^ leftt) & 0x33333333L;
  346.     leftt ^= work;
  347.     right ^= (work << 2);
  348.     work = ((right >> 8) ^ leftt) & 0x00ff00ffL;
  349.     leftt ^= work;
  350.     right ^= (work << 8);
  351.     right = ((right << 1) | ((right >> 31) & 1L)) & 0xffffffffL;
  352.     work = (leftt ^ right) & 0xaaaaaaaaL;
  353.     leftt ^= work;
  354.     right ^= work;
  355.     leftt = ((leftt << 1) | ((leftt >> 31) & 1L)) & 0xffffffffL;
  356.  
  357.     for( round = 0; round < 8; round++ ) {
  358.         work  = (right << 28) | (right >> 4);
  359.         work ^= *keys++;
  360.         fval  = SP7[ work        & 0x3fL];
  361.         fval |= SP5[(work >>  8) & 0x3fL];
  362.         fval |= SP3[(work >> 16) & 0x3fL];
  363.         fval |= SP1[(work >> 24) & 0x3fL];
  364.         work  = right ^ *keys++;
  365.         fval |= SP8[ work        & 0x3fL];
  366.         fval |= SP6[(work >>  8) & 0x3fL];
  367.         fval |= SP4[(work >> 16) & 0x3fL];
  368.         fval |= SP2[(work >> 24) & 0x3fL];
  369.         leftt ^= fval;
  370.         work  = (leftt << 28) | (leftt >> 4);
  371.         work ^= *keys++;
  372.         fval  = SP7[ work        & 0x3fL];
  373.         fval |= SP5[(work >>  8) & 0x3fL];
  374.         fval |= SP3[(work >> 16) & 0x3fL];
  375.         fval |= SP1[(work >> 24) & 0x3fL];
  376.         work  = leftt ^ *keys++;
  377.         fval |= SP8[ work        & 0x3fL];
  378.         fval |= SP6[(work >>  8) & 0x3fL];
  379.         fval |= SP4[(work >> 16) & 0x3fL];
  380.         fval |= SP2[(work >> 24) & 0x3fL];
  381.         right ^= fval;
  382.         }
  383.  
  384.     right = (right << 31) | (right >> 1);
  385.     work = (leftt ^ right) & 0xaaaaaaaaL;
  386.     leftt ^= work;
  387.     right ^= work;
  388.     leftt = (leftt << 31) | (leftt >> 1);
  389.     work = ((leftt >> 8) ^ right) & 0x00ff00ffL;
  390.     right ^= work;
  391.     leftt ^= (work << 8);
  392.     work = ((leftt >> 2) ^ right) & 0x33333333L;
  393.     right ^= work;
  394.     leftt ^= (work << 2);
  395.     work = ((right >> 16) ^ leftt) & 0x0000ffffL;
  396.     leftt ^= work;
  397.     right ^= (work << 16);
  398.     work = ((right >> 4) ^ leftt) & 0x0f0f0f0fL;
  399.     leftt ^= work;
  400.     right ^= (work << 4);
  401.     *block++ = right;
  402.     *block = leftt;
  403.     return;
  404.     }
  405.  
  406. /* Validation sets:
  407.  *
  408.  * Single-length key, single-length plaintext -
  409.  * Key    : 0123 4567 89ab cdef
  410.  * Plain  : 0123 4567 89ab cde7
  411.  * Cipher : c957 4425 6a5e d31d
  412.  *
  413.  * Double-length key, single-length plaintext -
  414.  * Key    : 0123 4567 89ab cdef fedc ba98 7654 3210
  415.  * Plain  : 0123 4567 89ab cde7
  416.  * Cipher : 7f1d 0a77 826b 8aff
  417.  *
  418.  * Double-length key, double-length plaintext -
  419.  * Key    : 0123 4567 89ab cdef fedc ba98 7654 3210
  420.  * Plain  : 0123 4567 89ab cdef 0123 4567 89ab cdff
  421.  * Cipher : 27a0 8440 406a df60 278f 47cf 42d6 15d7
  422.  *
  423.  * Triple-length key, single-length plaintext -
  424.  * Key    : 0123 4567 89ab cdef fedc ba98 7654 3210 89ab cdef 0123 4567
  425.  * Plain  : 0123 4567 89ab cde7
  426.  * Cipher : de0b 7c06 ae5e 0ed5
  427.  *
  428.  * Triple-length key, double-length plaintext -
  429.  * Key    : 0123 4567 89ab cdef fedc ba98 7654 3210 89ab cdef 0123 4567
  430.  * Plain  : 0123 4567 89ab cdef 0123 4567 89ab cdff
  431.  * Cipher : ad0d 1b30 ac17 cf07 0ed1 1c63 81e4 4de5
  432.  *
  433.  * d3des V5.0a rwo 9208.07 18:44 Graven Imagery
  434.  **********************************************************************/
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!