Subversion Repositories autosfx

#include "stdafx.h"

#pragma hdrstop

/*

  Copyright (c) 1990-2007 Info-ZIP.  All rights reserved.

  See the accompanying file LICENSE, version 2007-Mar-4 or later

  (the contents of which are also included in zip.h) for terms of use.

  If, for some reason, all these files are missing, the Info-ZIP license

  also may be found at:  ftp://ftp.info-zip.org/pub/infozip/license.html

  parts Copyright (C) 1997 Mike White, Eric W. Engler

************************************************************************

 Copyright (C) 2009, 2010  by Russell J. Peters, Roger Aelbrecht

   This file is part of TZipMaster Version 1.9.

    TZipMaster is free software: you can redistribute it and/or modify

    it under the terms of the GNU Lesser General Public License as published by

    the Free Software Foundation, either version 3 of the License, or

    (at your option) any later version.

    TZipMaster is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License

    along with TZipMaster.  If not, see <http://www.gnu.org/licenses/>.

    contact: problems@delphizip.org (include ZipMaster in the subject).

    updates: http://www.delphizip.org

    DelphiZip maillist subscribe at http://www.freelists.org/list/delphizip

************************************************************************/

#include "ZipDflt.h"

#include "crypt.h"

#include <stdlib.h>

#include <process.h>                /* For prototype of getpid()      */

#include "dz_errs.h"

#undef _DZ_FILE_

#define _DZ_FILE_ DZ_ZCRYPT_CPP

#define ZCR_SEED2 getpid()          /* RCV Added; see note in Crypt.c */

#define zencode(c, t, k)  (t = decrypt_byte(k), update_keys(c, k), t^(c))

// Write encryption header to file zfile using the password passwd and the

//   cyclic redundancy check crc. passwd :: Password string. crc :: Crc of file

//   being encrypted. zfile :: Where to write header.

#define Putc(c, f)  (temp[tcnt++] = (c))

//void ZipDflt::crypthead(/*HANDLE zfile,*/ const char *passwd, ulg crc)

void ZipDflt::crypthead(const char* passwd, ulg crc)

{

    int           n;      // Index in random header.

    int           t;      // Temporary.

    int           c;      // Random byte.

    int           ztemp;  // Temporary for zencoded value.

    uch           header[RAND_HEAD_LEN - 2];  // Random header.

    uch           temp[RAND_HEAD_LEN + 2];

    int           tcnt = 0;

    unsigned long k;

    // First generate RAND_HEAD_LEN - 2 random bytes. We encrypt the output of

    //   rand() to get less predictability, since rand() is often poorly

    //   implemented.

    if (++fcalls == 1)

    {

        srand((unsigned)time(NULL) ^ ZCR_SEED2);

    }

    init_keys(passwd, fkeys);

    for (n = 0; n < RAND_HEAD_LEN - 2; n++)

    {

        c = (rand() >> 7) & 0xFF;

        header[n] = (uch) zencode(c, t, fkeys);

    }

    // Encrypt random header (last two bytes is high word of crc)

    init_keys(passwd, fkeys);

    for (n = 0; n < RAND_HEAD_LEN - 2; n++)

    {

        ztemp = zencode(header[n], t, fkeys);

        Putc((uch) ztemp, zfile);             // V1.5 Added (uch)

    }

    ztemp = zencode((int)(crc >> 16) & 0xFF, t, fkeys);

    Putc((uch) ztemp, zfile);               // V1.5 Added (uch)

    ztemp = zencode((int)(crc >> 24) & 0xFF, t, fkeys);

    Putc((uch) ztemp, zfile);               // V1.5 Added (uch)

    fZipOutfile->Write(temp, tcnt, &k);

    //  Assert(k < (RAND_HEAD_LEN + 2), "temp buffer overflow");

    fBytesWritten += k;

}

#define BUF_SIZE (1024 * 16)

// If requested, encrypt the data in buf, and in any case call fwrite() with

//   the arguments to zfwrite(). Return what fwrite() returns. buf :: Data

//   buffer. item_size :: Size of each item in bytes. nb :: Number of items. f

//   :: File to write to.

unsigned __fastcall ZipDflt::zfwrite(const uch *buf, ::extent nb)

{

    unsigned long k;

    int           t;            // temporary

    unsigned      r;

    if (fkey)

    {

        // key is the global password pointer

        ulg   size;               // buffer size

        char  *p = (char *)buf; // steps through buffer

        DZStrA bf;

        char * bfr = bf.GetBuffer(BUF_SIZE);

        while (nb)

        {

            ulg tw = BUF_SIZE;// sizeof(fewetmp);

            char *d = bfr;//fewetmp;

            if (tw > nb)

                tw = nb;

            // Encrypt data in buffer

            for (size = tw; size != 0; p++, size--)

            {

                *d++ = (char)zencode(*p, t, fkeys);

            }

            r = fZipOutfile->Write(bfr, tw, &k);

//            r = fZipOutfile->Write(fewetmp, tw, &k);

            fBytesWritten += k;

            nb -= k;

            if (!r)

            {

                diag(_T("zfwrite failed"));

                return r;

            }

        }

        return 1;

    }

    // Write the buffer out

    r = fZipOutfile->Write(buf, nb, &k);

    if (!r)                            

        Notify(IDIAG, _T("zfwrite failed [%s]"), SysMsg().c_str());

//        diag(_T("zfwrite failed"));

    fBytesWritten += k;

    return r;

}

/* 30/1/07 */