Back to index

scribus-ng  1.3.4.dfsg+svn20071115
crypt.h
Go to the documentation of this file.
00001 /*
00002 For general Scribus (>=1.3.2) copyright and licensing information please refer
00003 to the COPYING file provided with the program. Following this notice may exist
00004 a copyright and/or license notice that predates the release of Scribus 1.3.2
00005 for which a new license (GPL+exception) is in place.
00006 */
00007 /* crypt.h -- base code for crypt/uncrypt ZIPfile
00008 
00009 
00010    Version 1.01, May 8th, 2004
00011 
00012    Copyright (C) 1998-2004 Gilles Vollant
00013 
00014    This code is a modified version of crypting code in Infozip distribution
00015 
00016    The encryption/decryption parts of this source code (as opposed to the
00017    non-echoing password parts) were originally written in Europe.  The
00018    whole source package can be freely distributed, including from the USA.
00019    (Prior to January 2000, re-export from the US was a violation of US law.)
00020 
00021    This encryption code is a direct transcription of the algorithm from
00022    Roger Schlafly, described by Phil Katz in the file appnote.txt.  This
00023    file (appnote.txt) is distributed with the PKZIP program (even in the
00024    version without encryption capabilities).
00025 
00026    If you don't need crypting in your application, just define symbols
00027    NOCRYPT and NOUNCRYPT.
00028 
00029    This code support the "Traditional PKWARE Encryption".
00030 
00031    The new AES encryption added on Zip format by Winzip (see the page
00032    http://www.winzip.com/aes_info.htm ) and PKWare PKZip 5.x Strong
00033    Encryption is not supported.
00034 */
00035 
00036 #include "scconfig.h"
00037 
00038 #define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8))
00039 
00040 /***********************************************************************
00041  * Return the next byte in the pseudo-random sequence
00042  */
00043 static int decrypt_byte(unsigned long* pkeys, const unsigned long* pcrc_32_tab)
00044 {
00045     unsigned temp;  /* POTENTIAL BUG:  temp*(temp^1) may overflow in an
00046                      * unpredictable manner on 16-bit systems; not a problem
00047                      * with any known compiler so far, though */
00048 
00049     temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2;
00050     return (int)(((temp * (temp ^ 1)) >> 8) & 0xff);
00051 }
00052 
00053 /***********************************************************************
00054  * Update the encryption keys with the next byte of plain text
00055  */
00056 static int update_keys(unsigned long* pkeys,const unsigned long* pcrc_32_tab,int c)
00057 {
00058     (*(pkeys+0)) = CRC32((*(pkeys+0)), c);
00059     (*(pkeys+1)) += (*(pkeys+0)) & 0xff;
00060     (*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1;
00061     {
00062       register int keyshift = (int)((*(pkeys+1)) >> 24);
00063       (*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift);
00064     }
00065     return c;
00066 }
00067 
00068 
00069 /***********************************************************************
00070  * Initialize the encryption keys and the random header according to
00071  * the given password.
00072  */
00073 static void init_keys(const char* passwd,unsigned long* pkeys,const unsigned long* pcrc_32_tab)
00074 {
00075     *(pkeys+0) = 305419896L;
00076     *(pkeys+1) = 591751049L;
00077     *(pkeys+2) = 878082192L;
00078     while (*passwd != '\0') {
00079         update_keys(pkeys,pcrc_32_tab,(int)*passwd);
00080         passwd++;
00081     }
00082 }
00083 
00084 #define zdecode(pkeys,pcrc_32_tab,c) \
00085     (update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab)))
00086 
00087 #define zencode(pkeys,pcrc_32_tab,c,t) \
00088     (t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), t^(c))
00089 
00090 #ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED
00091 
00092 #define RAND_HEAD_LEN  12
00093    /* "last resort" source for second part of crypt seed pattern */
00094 #  ifndef ZCR_SEED2
00095 #    define ZCR_SEED2 3141592654UL     /* use PI as default pattern */
00096 #  endif
00097 
00098 static int crypthead(passwd, buf, bufSize, pkeys, pcrc_32_tab, crcForCrypting)
00099     const char *passwd;         /* password string */
00100     unsigned char *buf;         /* where to write header */
00101     int bufSize;
00102     unsigned long* pkeys;
00103     const unsigned long* pcrc_32_tab;
00104     unsigned long crcForCrypting;
00105 {
00106     int n;                       /* index in random header */
00107     int t;                       /* temporary */
00108     int c;                       /* random byte */
00109     unsigned char header[RAND_HEAD_LEN-2]; /* random header */
00110     static unsigned calls = 0;   /* ensure different random header each time */
00111 
00112     if (bufSize<RAND_HEAD_LEN)
00113       return 0;
00114 
00115     /* First generate RAND_HEAD_LEN-2 random bytes. We encrypt the
00116      * output of rand() to get less predictability, since rand() is
00117      * often poorly implemented.
00118      */
00119     if (++calls == 1)
00120     {
00121         srand((unsigned)(time(NULL) ^ ZCR_SEED2));
00122     }
00123     init_keys(passwd, pkeys, pcrc_32_tab);
00124     for (n = 0; n < RAND_HEAD_LEN-2; n++)
00125     {
00126         c = (rand() >> 7) & 0xff;
00127         header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t);
00128     }
00129     /* Encrypt random header (last two bytes is high word of crc) */
00130     init_keys(passwd, pkeys, pcrc_32_tab);
00131     for (n = 0; n < RAND_HEAD_LEN-2; n++)
00132     {
00133         buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t);
00134     }
00135     buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t);
00136     buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t);
00137     return n;
00138 }
00139 
00140 #endif
00141