minizip-ng/ioapi_crypt.c

/* ioapi_crypt.c -- IO base function header for compress/uncompress .zip
   files using zlib + zip or unzip API

   This version of ioapi is designed to access memory rather than files.
   We do use a region of memory to put data in to and take it out of. We do
   not have auto-extending buffers and do not inform anyone else that the
   data has been written. It is really intended for accessing a zip archive
   embedded in an application such that I can write an installer with no
   external files. Creation of archives has not been attempted, although
   parts of the framework are present.

   Based on Unzip ioapi.c version 0.22, May 19th, 2003

   Copyright (C) 2012-2017 Nathan Moinvaziri
     https://github.com/nmoinvaz/minizip
   Copyright (C) 2003 Justin Fletcher
   Copyright (C) 1998-2003 Gilles Vollant
     http://www.winimage.com/zLibDll/minizip.html

   This file is under the same license as the Unzip tool it is distributed
   with.
*/


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "zlib.h"
#include "ioapi.h"

#include "ioapi_crypt.h"

#define RAND_HEAD_LEN  12

typedef struct mz_stream_crypt_s {
    mz_stream        stream;
    uint32_t        keys[3];          /* keys defining the pseudo-random sequence */
    const z_crc_t   *crc_32_tab;
    int16_t         initialized;
    int16_t         error;
    uint8_t         verify1;
    uint8_t         verify2;
    char            *password;
    uint64_t        total_in;
    uint64_t        total_out;
} mz_stream_crypt;

#define zdecode(keys,crc_32_tab,c) \
    (mz_stream_crypt_update_keys(keys,crc_32_tab, c ^= mz_stream_crypt_decrypt_byte(keys)))

#define zencode(keys,crc_32_tab,c,t) \
    (t = mz_stream_crypt_decrypt_byte(keys), mz_stream_crypt_update_keys(keys,crc_32_tab,c), t^(c))

uint8_t mz_stream_crypt_decrypt_byte(uint32_t *keys)
{
    unsigned temp;  /* POTENTIAL BUG:  temp*(temp^1) may overflow in an
                     * unpredictable manner on 16-bit systems; not a problem
                     * with any known compiler so far, though */

    temp = ((uint32_t)(*(keys+2)) & 0xffff) | 2;
    return (uint8_t)(((temp * (temp ^ 1)) >> 8) & 0xff);
}

uint8_t mz_stream_crypt_update_keys(uint32_t *keys, const z_crc_t *crc_32_tab, int32_t c)
{
    #define CRC32(c, b) ((*(crc_32_tab+(((uint32_t)(c) ^ (b)) & 0xff))) ^ ((c) >> 8))

    (*(keys+0)) = (uint32_t)CRC32((*(keys+0)), c);
    (*(keys+1)) += (*(keys+0)) & 0xff;
    (*(keys+1)) = (*(keys+1)) * 134775813L + 1;
    {
        register int32_t keyshift = (int32_t)((*(keys + 1)) >> 24);
        (*(keys+2)) = (uint32_t)CRC32((*(keys+2)), keyshift);
    }
    return c;
}

void mz_stream_crypt_init_keys(const char *password, uint32_t *keys, const z_crc_t *crc_32_tab)
{
    *(keys+0) = 305419896L;
    *(keys+1) = 591751049L;
    *(keys+2) = 878082192L;
    while (*password != 0)
    {
        mz_stream_crypt_update_keys(keys, crc_32_tab, *password);
        password += 1;
    }
}

int32_t ZCALLBACK mz_stream_crypt_open(voidpf stream, const char *filename, int mode)
{
    mz_stream_crypt *crypt = (mz_stream_crypt *)stream;
    uint16_t t = 0;
    int16_t i = 0;
    uint8_t header[RAND_HEAD_LEN];
    uint8_t verify1 = 0;
    uint8_t verify2 = 0;

    crypt->total_in = 0;
    crypt->total_out = 0;
    crypt->initialized = 0;

    if (mz_stream_is_open(crypt->stream.base) == MZ_STREAM_ERR)
        return MZ_STREAM_ERR;
    if (crypt->password == NULL)
        return MZ_STREAM_ERR;

    crypt->crc_32_tab = get_crc_table();
    if (crypt->crc_32_tab == NULL)
        return MZ_STREAM_ERR;

    mz_stream_crypt_init_keys(crypt->password, crypt->keys, crypt->crc_32_tab);

    if (mode & MZ_STREAM_MODE_WRITE)
    {
        // First generate RAND_HEAD_LEN - 2 random bytes.
        mz_os_rand(header, RAND_HEAD_LEN - 2);
        
        // Encrypt random header (last two bytes is high word of crc)
        for (i = 0; i < RAND_HEAD_LEN - 2; i++)
            header[i] = (uint8_t)zencode(crypt->keys, crypt->crc_32_tab, header[i], t);
        
        header[i++] = (uint8_t)zencode(crypt->keys, crypt->crc_32_tab, crypt->verify1, t);
        header[i++] = (uint8_t)zencode(crypt->keys, crypt->crc_32_tab, crypt->verify2, t);

        if (mz_stream_write(crypt->stream.base, header, RAND_HEAD_LEN) != RAND_HEAD_LEN)
            return MZ_STREAM_ERR;

        crypt->total_out += RAND_HEAD_LEN;
    }
    else if (mode & MZ_STREAM_MODE_READ)
    {
        if (mz_stream_read(crypt->stream.base, header, RAND_HEAD_LEN) != RAND_HEAD_LEN)
            return MZ_STREAM_ERR;

        for (i = 0; i < RAND_HEAD_LEN - 2; i++)
            header[i] = (uint8_t)zdecode(crypt->keys, crypt->crc_32_tab, header[i]);

        crypt->verify1 = (uint8_t)zdecode(crypt->keys, crypt->crc_32_tab, header[i++]);
        crypt->verify2 = (uint8_t)zdecode(crypt->keys, crypt->crc_32_tab, header[i++]);

        crypt->total_in += RAND_HEAD_LEN;
    }

    crypt->initialized = 1;
    return MZ_STREAM_OK;
}

int32_t ZCALLBACK mz_stream_crypt_is_open(voidpf stream)
{
    mz_stream_crypt *crypt = (mz_stream_crypt *)stream;
    if (crypt->initialized == 0)
        return MZ_STREAM_ERR;
    return MZ_STREAM_OK;
}

int32_t ZCALLBACK mz_stream_crypt_read(voidpf stream, void *buf, uint32_t size)
{
    mz_stream_crypt *crypt = (mz_stream_crypt *)stream;
    uint8_t *buf_ptr = (uint8_t *)buf;
    uint32_t read = 0;
    uint32_t i = 0;

    read = mz_stream_read(crypt->stream.base, buf, size);
    for (i = 0; i < read; i++)
        buf_ptr[i] = (uint8_t)zdecode(crypt->keys, crypt->crc_32_tab, buf_ptr[i]);
    crypt->total_in += read;
    return read;
}

int32_t ZCALLBACK mz_stream_crypt_write(voidpf stream, const void *buf, uint32_t size)
{
    mz_stream_crypt *crypt = (mz_stream_crypt *)stream;
    uint8_t *buf_ptr = (uint8_t *)buf;
    uint32_t written = 0;
    uint32_t i = 0;
    uint16_t t = 0;
    for (i = 0; i < size; i++)
        buf_ptr[i] = (uint8_t)zencode(crypt->keys, crypt->crc_32_tab, buf_ptr[i], t);
    written = mz_stream_write(crypt->stream.base, buf, size);
    if (written > 0)
        crypt->total_out += written;
    if (written != size)
        return MZ_STREAM_ERR;
    return written;
}

int64_t ZCALLBACK mz_stream_crypt_tell(voidpf stream)
{
    mz_stream_crypt *crypt = (mz_stream_crypt *)stream;
    return mz_stream_tell(crypt->stream.base);
}

int32_t ZCALLBACK mz_stream_crypt_seek(voidpf stream, uint64_t offset, int origin)
{
    mz_stream_crypt *crypt = (mz_stream_crypt *)stream;
    return mz_stream_seek(crypt->stream.base, offset, origin);
}

int32_t ZCALLBACK mz_stream_crypt_close(voidpf stream)
{
    mz_stream_crypt *crypt = (mz_stream_crypt *)stream;
    crypt->initialized = 0;
    return MZ_STREAM_OK;
}

int32_t ZCALLBACK mz_stream_crypt_error(voidpf stream)
{
    mz_stream_crypt *crypt = (mz_stream_crypt *)stream;
    return crypt->error;
}

void mz_stream_crypt_set_password(voidpf stream, char *password)
{
    mz_stream_crypt *crypt = (mz_stream_crypt *)stream;
    crypt->password = password;
}

void mz_stream_crypt_set_verify(voidpf stream, uint8_t verify1, uint8_t verify2)
{
    mz_stream_crypt *crypt = (mz_stream_crypt *)stream;
    crypt->verify1 = verify1;
    crypt->verify2 = verify2;
}

void mz_stream_crypt_get_verify(voidpf stream, uint8_t *verify1, uint8_t *verify2)
{
    mz_stream_crypt *crypt = (mz_stream_crypt *)stream;
    *verify1 = crypt->verify1;
    *verify2 = crypt->verify2;
}

voidpf mz_stream_crypt_create(voidpf *stream)
{
    mz_stream_crypt *crypt = NULL;

    crypt = (mz_stream_crypt *)malloc(sizeof(mz_stream_crypt));
    if (crypt != NULL)
    {
        memset(crypt, 0, sizeof(mz_stream_crypt));

        crypt->stream.open = mz_stream_crypt_open;
        crypt->stream.is_open = mz_stream_crypt_is_open;
        crypt->stream.read = mz_stream_crypt_read;
        crypt->stream.write = mz_stream_crypt_write;
        crypt->stream.tell = mz_stream_crypt_tell;
        crypt->stream.seek = mz_stream_crypt_seek;
        crypt->stream.close = mz_stream_crypt_close;
        crypt->stream.error = mz_stream_crypt_error;
        crypt->stream.create = mz_stream_crypt_create;
        crypt->stream.delete = mz_stream_crypt_delete;
    }

    if (stream != NULL)
        *stream = crypt;
    return (voidpf)crypt;
}

void mz_stream_crypt_delete(voidpf *stream)
{
    mz_stream_crypt *crypt = NULL;
    if (stream == NULL)
        return;
    crypt = (mz_stream_crypt *)*stream;
    if (crypt != NULL)
        free(crypt);
}