gwj / at91sam9263 · Commits

Commit 6fd27407ec8f4934681be39d4fa557dda1254692

Authored by ths
1 parent f858dcae

Actually add d3des implementation files. 


git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@3141 c046a42c-6fe2-441c-8c8c-71466251a162
Inline Side-by-side
Showing 2 changed files with 485 additions and 0 deletions
d3des.c 0 → 100644
  View file @6fd2740
  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 + **********************************************************************/
d3des.h 0 → 100644
  View file @6fd2740
  1 +/*
  2 + * This is D3DES (V5.09) by Richard Outerbridge with the double and
  3 + * triple-length support removed for use in VNC.
  4 + *
  5 + * These changes are:
  6 + * Copyright (C) 1999 AT&T Laboratories Cambridge. All Rights Reserved.
  7 + *
  8 + * This software is distributed in the hope that it will be useful,
  9 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  11 + */
  12 +
  13 +/* d3des.h -
  14 + *
  15 + * Headers and defines for d3des.c
  16 + * Graven Imagery, 1992.
  17 + *
  18 + * Copyright (c) 1988,1989,1990,1991,1992 by Richard Outerbridge
  19 + * (GEnie : OUTER; CIS : [71755,204])
  20 + */
  21 +
  22 +#define EN0 0 /* MODE == encrypt */
  23 +#define DE1 1 /* MODE == decrypt */
  24 +
  25 +extern void deskey(unsigned char *, int);
  26 +/* hexkey[8] MODE
  27 + * Sets the internal key register according to the hexadecimal
  28 + * key contained in the 8 bytes of hexkey, according to the DES,
  29 + * for encryption or decryption according to MODE.
  30 + */
  31 +
  32 +extern void usekey(unsigned long *);
  33 +/* cookedkey[32]
  34 + * Loads the internal key register with the data in cookedkey.
  35 + */
  36 +
  37 +extern void cpkey(unsigned long *);
  38 +/* cookedkey[32]
  39 + * Copies the contents of the internal key register into the storage
  40 + * located at &cookedkey[0].
  41 + */
  42 +
  43 +extern void des(unsigned char *, unsigned char *);
  44 +/* from[8] to[8]
  45 + * Encrypts/Decrypts (according to the key currently loaded in the
  46 + * internal key register) one block of eight bytes at address 'from'
  47 + * into the block at address 'to'. They can be the same.
  48 + */
  49 +
  50 +/* d3des.h V5.09 rwo 9208.04 15:06 Graven Imagery
  51 + ********************************************************************/