├── .gitattributes ├── CMakeLists.txt ├── LICENSE ├── README.md ├── data ├── jekyll_and_hyde.zip ├── orig.png └── output.png ├── ext ├── argparse │ └── argparse.hpp ├── stb │ ├── stb_image.c │ ├── stb_image.h │ ├── stb_image_write.c │ └── stb_image_write.h └── zlib │ ├── adler32.c │ ├── compress.c │ ├── crc32.c │ ├── crc32.h │ ├── deflate.c │ ├── deflate.h │ ├── gzclose.c │ ├── gzguts.h │ ├── gzlib.c │ ├── gzread.c │ ├── gzwrite.c │ ├── infback.c │ ├── inffast.c │ ├── inffast.h │ ├── inffixed.h │ ├── inflate.c │ ├── inflate.h │ ├── inftrees.c │ ├── inftrees.h │ ├── trees.c │ ├── trees.h │ ├── uncompr.c │ ├── zconf.h │ ├── zlib.h │ ├── zutil.c │ └── zutil.h └── src ├── aes.cpp ├── aes.hpp ├── crc32.cpp ├── crc32.hpp ├── image.cpp ├── image.hpp ├── main.cpp ├── random.hpp ├── sha256.cpp ├── sha256.hpp └── utils.hpp /.gitattributes: -------------------------------------------------------------------------------- 1 | ext/** linguist-vendored 2 | -------------------------------------------------------------------------------- /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.16) 2 | project(steganography) 3 | 4 | include_directories(ext) 5 | 6 | add_library( 7 | stb STATIC 8 | ext/stb/stb_image.c 9 | ext/stb/stb_image_write.c 10 | ) 11 | 12 | add_library( 13 | zlib STATIC 14 | ext/zlib/adler32.c 15 | ext/zlib/compress.c 16 | ext/zlib/crc32.c 17 | ext/zlib/crc32.h 18 | ext/zlib/deflate.c 19 | ext/zlib/gzclose.c 20 | ext/zlib/gzlib.c 21 | ext/zlib/gzread.c 22 | ext/zlib/gzwrite.c 23 | ext/zlib/infback.c 24 | ext/zlib/inffast.c 25 | ext/zlib/inflate.c 26 | ext/zlib/inftrees.c 27 | ext/zlib/trees.c 28 | ext/zlib/uncompr.c 29 | ext/zlib/zutil.c) 30 | 31 | SET(CMAKE_CXX_STANDARD 17) 32 | SET(CMAKE_CXX_STANDARD_REQUIRED On) 33 | 34 | add_executable( 35 | steganography 36 | src/aes.cpp 37 | src/crc32.cpp 38 | src/image.cpp 39 | src/main.cpp 40 | src/sha256.cpp 41 | ) 42 | 43 | target_link_libraries( 44 | steganography 45 | stb 46 | zlib 47 | ) 48 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2022 Zach Collins 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Image Steganography Tool 2 | 3 | Simple C++ **Encryption** and **Steganography** tool that uses Password-Protected-Encryption to secure a file's contents, and then proceeds to embed it 4 | insde an image's pixel-data using Least-Significant-Bit encoding. For Linux, MacOS, and Windows systems. 5 | 6 | ## Encoding 7 | 8 | ``` 9 | $ ./steganography encode -i data/orig.png -e data/jekyll_and_hyde.zip -o output.png 10 | Password: 1234 11 | * Image size: 640x426 pixels 12 | * Encoding level: Low (Default) 13 | * Max embed size: 132.38 KiB 14 | * Embed size: 61.77 KiB 15 | * Encrypted embed size: 61.78 KiB 16 | * Generated CRC32 checksum 17 | * Generated encryption key with PBKDF2-HMAC-SHA-256 (20000 rounds) 18 | * Encrypted embed with AES-256-CBC 19 | * Embedded jekyll_and_hyde.zip into image 20 | * Sucessfully wrote to output.png 21 | ``` 22 | 23 | Original image: 24 | 25 | ![Original image](data/orig.png) 26 | 27 | Image with embedded ZIP containg the entire contents of the book "Dr Jekyll and Mr Hyde": 28 | 29 | ![Image with embed](data/output.png) 30 | 31 | ## Decoding 32 | 33 | ``` 34 | $ ./steganography decode -i output.png -o "out - jekyll_and_hyde.zip" 35 | Password: 1234 36 | * Image size: 640x426 pixels 37 | * Generated decryption key with PBKDF2-HMAC-SHA-256 (20000 rounds) 38 | * Sucessfully decrypted header 39 | * File signatures match 40 | * Detected embed jekyll_and_hyde.zip 41 | * Encoding level: Low (Default) 42 | * Encrypted embed size: 61.78 KiB 43 | * Successfully decrypted the embed 44 | * Decrypted embed size: 61.77 KiB 45 | * CRC32 checksum matches 46 | * Successfully wrote to out - jekyll_and_hyde.zip 47 | ``` 48 | 49 | ## Building 50 | 51 | ``` 52 | $ mkdir build 53 | $ cd build 54 | $ cmake -DCMAKE_BUILD_TYPE=Release .. 55 | $ make -j 4 56 | ``` 57 | 58 | ## Usage 59 | 60 | ``` 61 | Usage: steganography [-h] {decode,encode} 62 | 63 | Optional arguments: 64 | -h, --help shows help message and exits 65 | -v, --version prints version information and exits 66 | 67 | Subcommands: 68 | decode Decodes and extracts an embed-file from an image 69 | encode Encodes an embed-file into an image 70 | ``` 71 | 72 | ### Encoding 73 | 74 | ``` 75 | Usage: encode [-h] --input VAR --output VAR --embed VAR [--passwd VAR] 76 | 77 | Encodes an embed-file into an image 78 | 79 | Optional arguments: 80 | -h, --help shows help message and exits 81 | -v, --version prints version information and exits 82 | -i, --input specify the input image. [required] 83 | -o, --output specify the output image. [required] 84 | -e, --embed specify the file to embed. [required] 85 | -p, --passwd specify the encryption password. 86 | ``` 87 | 88 | ### Decoding 89 | 90 | ``` 91 | Usage: decode [-h] --input VAR [--output VAR] [--passwd VAR] 92 | 93 | Decodes and extracts an embed-file from an image 94 | 95 | Optional arguments: 96 | -h, --help shows help message and exits 97 | -v, --version prints version information and exits 98 | -i, --input specify the input image. [required] 99 | -o, --output specify the output file. [default: ""] 100 | -p, --passwd specify the encryption password. 101 | ``` 102 | 103 | ## Theory Of Operation 104 | 105 | ### Encoding 106 | 107 | The program operates by first randomly generating a *128-bit Password Salt* and a *128-bit AES Initialization Vector* by reading binary data from **/dev/urandom**. 108 | It then uses that *Password Salt* as a parameter in generating an encryption key, by using **PBKDF2-HMAC-SHA-256** on a user inputted string. 109 | A **CRC32** hash of the file to embed is then calculated, and stored in the header to act as a checksum for the validity of the data. 110 | It then pads the binary data of the file to embed using the **PKCS #7** algorithm, followed by actually encrypting both the header and 111 | the padded data, with **AES-256** in **CBC Mode**, using the previously generated *Initialization Vector*. 112 | Now the data is actually encoded inside the image by first picking a random offset, and then going through each bit of data and storing it 113 | inside the actual image pixel data, which it accomplishes by setting the *Least-Significant-Bit* of each channel byte of each pixel. 114 | 115 | ### Decoding 116 | 117 | The decoding process works exactly the same as the encoding process previously described above, just in reverse. 118 | The only difference is that for decoding, after the program attempts to extract and decrypt the data, it compares some of the information in the header section 119 | in an attempt to validate the extraction process. The header fields which are compared are: The 4 byte file signature custom to this program, and the 120 | **CRC32** hash of the decrypted data. 121 | If any of these fields do not match to their correct values, the decryption process will fail. This should only happen if the file which you were attempting to 122 | decrypt does not actually contain an embed, if the password you entered is wrong, or if the image file was somehow corrupted. 123 | 124 | ### Detection 125 | 126 | While the detection of data being embedded in an image is a trivial task, theoretically there is no way of knowing that it was this program that did it, and theoretically 127 | there should be no known way to decrypt the data without knowing the password, that is without spending millions of years in the process of doing so. 128 | 129 | ## Disclaimer 130 | 131 | Do not use this program to encrypt and hide important data which you wish to keep away from prying eyes. This is just a simple proof-of-concept program that I made for fun. 132 | I'm no cryptographer. I'm just a hobbyist, use at your own risk. 133 | 134 | ## Copyright 135 | 136 | This software is licensed under MIT. Copyright © 2022 Zach Collins 137 | -------------------------------------------------------------------------------- /data/jekyll_and_hyde.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/7thSamurai/steganography/89d82da6831f81d54cdc61627af072e5ed347e41/data/jekyll_and_hyde.zip -------------------------------------------------------------------------------- /data/orig.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/7thSamurai/steganography/89d82da6831f81d54cdc61627af072e5ed347e41/data/orig.png -------------------------------------------------------------------------------- /data/output.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/7thSamurai/steganography/89d82da6831f81d54cdc61627af072e5ed347e41/data/output.png -------------------------------------------------------------------------------- /ext/stb/stb_image.c: -------------------------------------------------------------------------------- 1 | #define STB_IMAGE_IMPLEMENTATION 2 | #include "stb_image.h" 3 | -------------------------------------------------------------------------------- /ext/stb/stb_image_write.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "zlib/zlib.h" 3 | 4 | static unsigned char *compress_for_stbiw(unsigned char *data, int data_len, int *out_len, int quality) { 5 | uLongf size = compressBound(data_len); 6 | unsigned char *buffer = (unsigned char*)malloc(size); 7 | 8 | if (!buffer) 9 | return NULL; 10 | 11 | if (compress2(buffer, &size, data, data_len, quality) != Z_OK) { 12 | free(buffer); 13 | return NULL; 14 | } 15 | 16 | *out_len = size; 17 | 18 | return buffer; 19 | } 20 | 21 | #define STBIW_ZLIB_COMPRESS compress_for_stbiw 22 | #define STB_IMAGE_WRITE_IMPLEMENTATION 23 | #include "stb_image_write.h" 24 | -------------------------------------------------------------------------------- /ext/zlib/adler32.c: -------------------------------------------------------------------------------- 1 | /* adler32.c -- compute the Adler-32 checksum of a data stream 2 | * Copyright (C) 1995-2011, 2016 Mark Adler 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | */ 5 | 6 | /* @(#) $Id$ */ 7 | 8 | #include "zutil.h" 9 | 10 | local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2)); 11 | 12 | #define BASE 65521U /* largest prime smaller than 65536 */ 13 | #define NMAX 5552 14 | /* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */ 15 | 16 | #define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} 17 | #define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); 18 | #define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); 19 | #define DO8(buf,i) DO4(buf,i); DO4(buf,i+4); 20 | #define DO16(buf) DO8(buf,0); DO8(buf,8); 21 | 22 | /* use NO_DIVIDE if your processor does not do division in hardware -- 23 | try it both ways to see which is faster */ 24 | #ifdef NO_DIVIDE 25 | /* note that this assumes BASE is 65521, where 65536 % 65521 == 15 26 | (thank you to John Reiser for pointing this out) */ 27 | # define CHOP(a) \ 28 | do { \ 29 | unsigned long tmp = a >> 16; \ 30 | a &= 0xffffUL; \ 31 | a += (tmp << 4) - tmp; \ 32 | } while (0) 33 | # define MOD28(a) \ 34 | do { \ 35 | CHOP(a); \ 36 | if (a >= BASE) a -= BASE; \ 37 | } while (0) 38 | # define MOD(a) \ 39 | do { \ 40 | CHOP(a); \ 41 | MOD28(a); \ 42 | } while (0) 43 | # define MOD63(a) \ 44 | do { /* this assumes a is not negative */ \ 45 | z_off64_t tmp = a >> 32; \ 46 | a &= 0xffffffffL; \ 47 | a += (tmp << 8) - (tmp << 5) + tmp; \ 48 | tmp = a >> 16; \ 49 | a &= 0xffffL; \ 50 | a += (tmp << 4) - tmp; \ 51 | tmp = a >> 16; \ 52 | a &= 0xffffL; \ 53 | a += (tmp << 4) - tmp; \ 54 | if (a >= BASE) a -= BASE; \ 55 | } while (0) 56 | #else 57 | # define MOD(a) a %= BASE 58 | # define MOD28(a) a %= BASE 59 | # define MOD63(a) a %= BASE 60 | #endif 61 | 62 | /* ========================================================================= */ 63 | uLong ZEXPORT adler32_z(adler, buf, len) 64 | uLong adler; 65 | const Bytef *buf; 66 | z_size_t len; 67 | { 68 | unsigned long sum2; 69 | unsigned n; 70 | 71 | /* split Adler-32 into component sums */ 72 | sum2 = (adler >> 16) & 0xffff; 73 | adler &= 0xffff; 74 | 75 | /* in case user likes doing a byte at a time, keep it fast */ 76 | if (len == 1) { 77 | adler += buf[0]; 78 | if (adler >= BASE) 79 | adler -= BASE; 80 | sum2 += adler; 81 | if (sum2 >= BASE) 82 | sum2 -= BASE; 83 | return adler | (sum2 << 16); 84 | } 85 | 86 | /* initial Adler-32 value (deferred check for len == 1 speed) */ 87 | if (buf == Z_NULL) 88 | return 1L; 89 | 90 | /* in case short lengths are provided, keep it somewhat fast */ 91 | if (len < 16) { 92 | while (len--) { 93 | adler += *buf++; 94 | sum2 += adler; 95 | } 96 | if (adler >= BASE) 97 | adler -= BASE; 98 | MOD28(sum2); /* only added so many BASE's */ 99 | return adler | (sum2 << 16); 100 | } 101 | 102 | /* do length NMAX blocks -- requires just one modulo operation */ 103 | while (len >= NMAX) { 104 | len -= NMAX; 105 | n = NMAX / 16; /* NMAX is divisible by 16 */ 106 | do { 107 | DO16(buf); /* 16 sums unrolled */ 108 | buf += 16; 109 | } while (--n); 110 | MOD(adler); 111 | MOD(sum2); 112 | } 113 | 114 | /* do remaining bytes (less than NMAX, still just one modulo) */ 115 | if (len) { /* avoid modulos if none remaining */ 116 | while (len >= 16) { 117 | len -= 16; 118 | DO16(buf); 119 | buf += 16; 120 | } 121 | while (len--) { 122 | adler += *buf++; 123 | sum2 += adler; 124 | } 125 | MOD(adler); 126 | MOD(sum2); 127 | } 128 | 129 | /* return recombined sums */ 130 | return adler | (sum2 << 16); 131 | } 132 | 133 | /* ========================================================================= */ 134 | uLong ZEXPORT adler32(adler, buf, len) 135 | uLong adler; 136 | const Bytef *buf; 137 | uInt len; 138 | { 139 | return adler32_z(adler, buf, len); 140 | } 141 | 142 | /* ========================================================================= */ 143 | local uLong adler32_combine_(adler1, adler2, len2) 144 | uLong adler1; 145 | uLong adler2; 146 | z_off64_t len2; 147 | { 148 | unsigned long sum1; 149 | unsigned long sum2; 150 | unsigned rem; 151 | 152 | /* for negative len, return invalid adler32 as a clue for debugging */ 153 | if (len2 < 0) 154 | return 0xffffffffUL; 155 | 156 | /* the derivation of this formula is left as an exercise for the reader */ 157 | MOD63(len2); /* assumes len2 >= 0 */ 158 | rem = (unsigned)len2; 159 | sum1 = adler1 & 0xffff; 160 | sum2 = rem * sum1; 161 | MOD(sum2); 162 | sum1 += (adler2 & 0xffff) + BASE - 1; 163 | sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem; 164 | if (sum1 >= BASE) sum1 -= BASE; 165 | if (sum1 >= BASE) sum1 -= BASE; 166 | if (sum2 >= ((unsigned long)BASE << 1)) sum2 -= ((unsigned long)BASE << 1); 167 | if (sum2 >= BASE) sum2 -= BASE; 168 | return sum1 | (sum2 << 16); 169 | } 170 | 171 | /* ========================================================================= */ 172 | uLong ZEXPORT adler32_combine(adler1, adler2, len2) 173 | uLong adler1; 174 | uLong adler2; 175 | z_off_t len2; 176 | { 177 | return adler32_combine_(adler1, adler2, len2); 178 | } 179 | 180 | uLong ZEXPORT adler32_combine64(adler1, adler2, len2) 181 | uLong adler1; 182 | uLong adler2; 183 | z_off64_t len2; 184 | { 185 | return adler32_combine_(adler1, adler2, len2); 186 | } 187 | -------------------------------------------------------------------------------- /ext/zlib/compress.c: -------------------------------------------------------------------------------- 1 | /* compress.c -- compress a memory buffer 2 | * Copyright (C) 1995-2005, 2014, 2016 Jean-loup Gailly, Mark Adler 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | */ 5 | 6 | /* @(#) $Id$ */ 7 | 8 | #define ZLIB_INTERNAL 9 | #include "zlib.h" 10 | 11 | /* =========================================================================== 12 | Compresses the source buffer into the destination buffer. The level 13 | parameter has the same meaning as in deflateInit. sourceLen is the byte 14 | length of the source buffer. Upon entry, destLen is the total size of the 15 | destination buffer, which must be at least 0.1% larger than sourceLen plus 16 | 12 bytes. Upon exit, destLen is the actual size of the compressed buffer. 17 | 18 | compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough 19 | memory, Z_BUF_ERROR if there was not enough room in the output buffer, 20 | Z_STREAM_ERROR if the level parameter is invalid. 21 | */ 22 | int ZEXPORT compress2 (dest, destLen, source, sourceLen, level) 23 | Bytef *dest; 24 | uLongf *destLen; 25 | const Bytef *source; 26 | uLong sourceLen; 27 | int level; 28 | { 29 | z_stream stream; 30 | int err; 31 | const uInt max = (uInt)-1; 32 | uLong left; 33 | 34 | left = *destLen; 35 | *destLen = 0; 36 | 37 | stream.zalloc = (alloc_func)0; 38 | stream.zfree = (free_func)0; 39 | stream.opaque = (voidpf)0; 40 | 41 | err = deflateInit(&stream, level); 42 | if (err != Z_OK) return err; 43 | 44 | stream.next_out = dest; 45 | stream.avail_out = 0; 46 | stream.next_in = (z_const Bytef *)source; 47 | stream.avail_in = 0; 48 | 49 | do { 50 | if (stream.avail_out == 0) { 51 | stream.avail_out = left > (uLong)max ? max : (uInt)left; 52 | left -= stream.avail_out; 53 | } 54 | if (stream.avail_in == 0) { 55 | stream.avail_in = sourceLen > (uLong)max ? max : (uInt)sourceLen; 56 | sourceLen -= stream.avail_in; 57 | } 58 | err = deflate(&stream, sourceLen ? Z_NO_FLUSH : Z_FINISH); 59 | } while (err == Z_OK); 60 | 61 | *destLen = stream.total_out; 62 | deflateEnd(&stream); 63 | return err == Z_STREAM_END ? Z_OK : err; 64 | } 65 | 66 | /* =========================================================================== 67 | */ 68 | int ZEXPORT compress (dest, destLen, source, sourceLen) 69 | Bytef *dest; 70 | uLongf *destLen; 71 | const Bytef *source; 72 | uLong sourceLen; 73 | { 74 | return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION); 75 | } 76 | 77 | /* =========================================================================== 78 | If the default memLevel or windowBits for deflateInit() is changed, then 79 | this function needs to be updated. 80 | */ 81 | uLong ZEXPORT compressBound (sourceLen) 82 | uLong sourceLen; 83 | { 84 | return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + 85 | (sourceLen >> 25) + 13; 86 | } 87 | -------------------------------------------------------------------------------- /ext/zlib/crc32.c: -------------------------------------------------------------------------------- 1 | /* crc32.c -- compute the CRC-32 of a data stream 2 | * Copyright (C) 1995-2006, 2010, 2011, 2012, 2016 Mark Adler 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | * 5 | * Thanks to Rodney Brown for his contribution of faster 6 | * CRC methods: exclusive-oring 32 bits of data at a time, and pre-computing 7 | * tables for updating the shift register in one step with three exclusive-ors 8 | * instead of four steps with four exclusive-ors. This results in about a 9 | * factor of two increase in speed on a Power PC G4 (PPC7455) using gcc -O3. 10 | */ 11 | 12 | /* @(#) $Id$ */ 13 | 14 | /* 15 | Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore 16 | protection on the static variables used to control the first-use generation 17 | of the crc tables. Therefore, if you #define DYNAMIC_CRC_TABLE, you should 18 | first call get_crc_table() to initialize the tables before allowing more than 19 | one thread to use crc32(). 20 | 21 | DYNAMIC_CRC_TABLE and MAKECRCH can be #defined to write out crc32.h. 22 | */ 23 | 24 | #ifdef MAKECRCH 25 | # include 26 | # ifndef DYNAMIC_CRC_TABLE 27 | # define DYNAMIC_CRC_TABLE 28 | # endif /* !DYNAMIC_CRC_TABLE */ 29 | #endif /* MAKECRCH */ 30 | 31 | #include "zutil.h" /* for STDC and FAR definitions */ 32 | 33 | /* Definitions for doing the crc four data bytes at a time. */ 34 | #if !defined(NOBYFOUR) && defined(Z_U4) 35 | # define BYFOUR 36 | #endif 37 | #ifdef BYFOUR 38 | local unsigned long crc32_little OF((unsigned long, 39 | const unsigned char FAR *, z_size_t)); 40 | local unsigned long crc32_big OF((unsigned long, 41 | const unsigned char FAR *, z_size_t)); 42 | # define TBLS 8 43 | #else 44 | # define TBLS 1 45 | #endif /* BYFOUR */ 46 | 47 | /* Local functions for crc concatenation */ 48 | local unsigned long gf2_matrix_times OF((unsigned long *mat, 49 | unsigned long vec)); 50 | local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat)); 51 | local uLong crc32_combine_ OF((uLong crc1, uLong crc2, z_off64_t len2)); 52 | 53 | 54 | #ifdef DYNAMIC_CRC_TABLE 55 | 56 | local volatile int crc_table_empty = 1; 57 | local z_crc_t FAR crc_table[TBLS][256]; 58 | local void make_crc_table OF((void)); 59 | #ifdef MAKECRCH 60 | local void write_table OF((FILE *, const z_crc_t FAR *)); 61 | #endif /* MAKECRCH */ 62 | /* 63 | Generate tables for a byte-wise 32-bit CRC calculation on the polynomial: 64 | x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1. 65 | 66 | Polynomials over GF(2) are represented in binary, one bit per coefficient, 67 | with the lowest powers in the most significant bit. Then adding polynomials 68 | is just exclusive-or, and multiplying a polynomial by x is a right shift by 69 | one. If we call the above polynomial p, and represent a byte as the 70 | polynomial q, also with the lowest power in the most significant bit (so the 71 | byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p, 72 | where a mod b means the remainder after dividing a by b. 73 | 74 | This calculation is done using the shift-register method of multiplying and 75 | taking the remainder. The register is initialized to zero, and for each 76 | incoming bit, x^32 is added mod p to the register if the bit is a one (where 77 | x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by 78 | x (which is shifting right by one and adding x^32 mod p if the bit shifted 79 | out is a one). We start with the highest power (least significant bit) of 80 | q and repeat for all eight bits of q. 81 | 82 | The first table is simply the CRC of all possible eight bit values. This is 83 | all the information needed to generate CRCs on data a byte at a time for all 84 | combinations of CRC register values and incoming bytes. The remaining tables 85 | allow for word-at-a-time CRC calculation for both big-endian and little- 86 | endian machines, where a word is four bytes. 87 | */ 88 | local void make_crc_table() 89 | { 90 | z_crc_t c; 91 | int n, k; 92 | z_crc_t poly; /* polynomial exclusive-or pattern */ 93 | /* terms of polynomial defining this crc (except x^32): */ 94 | static volatile int first = 1; /* flag to limit concurrent making */ 95 | static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26}; 96 | 97 | /* See if another task is already doing this (not thread-safe, but better 98 | than nothing -- significantly reduces duration of vulnerability in 99 | case the advice about DYNAMIC_CRC_TABLE is ignored) */ 100 | if (first) { 101 | first = 0; 102 | 103 | /* make exclusive-or pattern from polynomial (0xedb88320UL) */ 104 | poly = 0; 105 | for (n = 0; n < (int)(sizeof(p)/sizeof(unsigned char)); n++) 106 | poly |= (z_crc_t)1 << (31 - p[n]); 107 | 108 | /* generate a crc for every 8-bit value */ 109 | for (n = 0; n < 256; n++) { 110 | c = (z_crc_t)n; 111 | for (k = 0; k < 8; k++) 112 | c = c & 1 ? poly ^ (c >> 1) : c >> 1; 113 | crc_table[0][n] = c; 114 | } 115 | 116 | #ifdef BYFOUR 117 | /* generate crc for each value followed by one, two, and three zeros, 118 | and then the byte reversal of those as well as the first table */ 119 | for (n = 0; n < 256; n++) { 120 | c = crc_table[0][n]; 121 | crc_table[4][n] = ZSWAP32(c); 122 | for (k = 1; k < 4; k++) { 123 | c = crc_table[0][c & 0xff] ^ (c >> 8); 124 | crc_table[k][n] = c; 125 | crc_table[k + 4][n] = ZSWAP32(c); 126 | } 127 | } 128 | #endif /* BYFOUR */ 129 | 130 | crc_table_empty = 0; 131 | } 132 | else { /* not first */ 133 | /* wait for the other guy to finish (not efficient, but rare) */ 134 | while (crc_table_empty) 135 | ; 136 | } 137 | 138 | #ifdef MAKECRCH 139 | /* write out CRC tables to crc32.h */ 140 | { 141 | FILE *out; 142 | 143 | out = fopen("crc32.h", "w"); 144 | if (out == NULL) return; 145 | fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n"); 146 | fprintf(out, " * Generated automatically by crc32.c\n */\n\n"); 147 | fprintf(out, "local const z_crc_t FAR "); 148 | fprintf(out, "crc_table[TBLS][256] =\n{\n {\n"); 149 | write_table(out, crc_table[0]); 150 | # ifdef BYFOUR 151 | fprintf(out, "#ifdef BYFOUR\n"); 152 | for (k = 1; k < 8; k++) { 153 | fprintf(out, " },\n {\n"); 154 | write_table(out, crc_table[k]); 155 | } 156 | fprintf(out, "#endif\n"); 157 | # endif /* BYFOUR */ 158 | fprintf(out, " }\n};\n"); 159 | fclose(out); 160 | } 161 | #endif /* MAKECRCH */ 162 | } 163 | 164 | #ifdef MAKECRCH 165 | local void write_table(out, table) 166 | FILE *out; 167 | const z_crc_t FAR *table; 168 | { 169 | int n; 170 | 171 | for (n = 0; n < 256; n++) 172 | fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : " ", 173 | (unsigned long)(table[n]), 174 | n == 255 ? "\n" : (n % 5 == 4 ? ",\n" : ", ")); 175 | } 176 | #endif /* MAKECRCH */ 177 | 178 | #else /* !DYNAMIC_CRC_TABLE */ 179 | /* ======================================================================== 180 | * Tables of CRC-32s of all single-byte values, made by make_crc_table(). 181 | */ 182 | #include "crc32.h" 183 | #endif /* DYNAMIC_CRC_TABLE */ 184 | 185 | /* ========================================================================= 186 | * This function can be used by asm versions of crc32() 187 | */ 188 | const z_crc_t FAR * ZEXPORT get_crc_table() 189 | { 190 | #ifdef DYNAMIC_CRC_TABLE 191 | if (crc_table_empty) 192 | make_crc_table(); 193 | #endif /* DYNAMIC_CRC_TABLE */ 194 | return (const z_crc_t FAR *)crc_table; 195 | } 196 | 197 | /* ========================================================================= */ 198 | #define DO1 crc = crc_table[0][((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8) 199 | #define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1 200 | 201 | /* ========================================================================= */ 202 | unsigned long ZEXPORT crc32_z(crc, buf, len) 203 | unsigned long crc; 204 | const unsigned char FAR *buf; 205 | z_size_t len; 206 | { 207 | if (buf == Z_NULL) return 0UL; 208 | 209 | #ifdef DYNAMIC_CRC_TABLE 210 | if (crc_table_empty) 211 | make_crc_table(); 212 | #endif /* DYNAMIC_CRC_TABLE */ 213 | 214 | #ifdef BYFOUR 215 | if (sizeof(void *) == sizeof(ptrdiff_t)) { 216 | z_crc_t endian; 217 | 218 | endian = 1; 219 | if (*((unsigned char *)(&endian))) 220 | return crc32_little(crc, buf, len); 221 | else 222 | return crc32_big(crc, buf, len); 223 | } 224 | #endif /* BYFOUR */ 225 | crc = crc ^ 0xffffffffUL; 226 | while (len >= 8) { 227 | DO8; 228 | len -= 8; 229 | } 230 | if (len) do { 231 | DO1; 232 | } while (--len); 233 | return crc ^ 0xffffffffUL; 234 | } 235 | 236 | /* ========================================================================= */ 237 | unsigned long ZEXPORT crc32(crc, buf, len) 238 | unsigned long crc; 239 | const unsigned char FAR *buf; 240 | uInt len; 241 | { 242 | return crc32_z(crc, buf, len); 243 | } 244 | 245 | #ifdef BYFOUR 246 | 247 | /* 248 | This BYFOUR code accesses the passed unsigned char * buffer with a 32-bit 249 | integer pointer type. This violates the strict aliasing rule, where a 250 | compiler can assume, for optimization purposes, that two pointers to 251 | fundamentally different types won't ever point to the same memory. This can 252 | manifest as a problem only if one of the pointers is written to. This code 253 | only reads from those pointers. So long as this code remains isolated in 254 | this compilation unit, there won't be a problem. For this reason, this code 255 | should not be copied and pasted into a compilation unit in which other code 256 | writes to the buffer that is passed to these routines. 257 | */ 258 | 259 | /* ========================================================================= */ 260 | #define DOLIT4 c ^= *buf4++; \ 261 | c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \ 262 | crc_table[1][(c >> 16) & 0xff] ^ crc_table[0][c >> 24] 263 | #define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4 264 | 265 | /* ========================================================================= */ 266 | local unsigned long crc32_little(crc, buf, len) 267 | unsigned long crc; 268 | const unsigned char FAR *buf; 269 | z_size_t len; 270 | { 271 | register z_crc_t c; 272 | register const z_crc_t FAR *buf4; 273 | 274 | c = (z_crc_t)crc; 275 | c = ~c; 276 | while (len && ((ptrdiff_t)buf & 3)) { 277 | c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8); 278 | len--; 279 | } 280 | 281 | buf4 = (const z_crc_t FAR *)(const void FAR *)buf; 282 | while (len >= 32) { 283 | DOLIT32; 284 | len -= 32; 285 | } 286 | while (len >= 4) { 287 | DOLIT4; 288 | len -= 4; 289 | } 290 | buf = (const unsigned char FAR *)buf4; 291 | 292 | if (len) do { 293 | c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8); 294 | } while (--len); 295 | c = ~c; 296 | return (unsigned long)c; 297 | } 298 | 299 | /* ========================================================================= */ 300 | #define DOBIG4 c ^= *buf4++; \ 301 | c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \ 302 | crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24] 303 | #define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4 304 | 305 | /* ========================================================================= */ 306 | local unsigned long crc32_big(crc, buf, len) 307 | unsigned long crc; 308 | const unsigned char FAR *buf; 309 | z_size_t len; 310 | { 311 | register z_crc_t c; 312 | register const z_crc_t FAR *buf4; 313 | 314 | c = ZSWAP32((z_crc_t)crc); 315 | c = ~c; 316 | while (len && ((ptrdiff_t)buf & 3)) { 317 | c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8); 318 | len--; 319 | } 320 | 321 | buf4 = (const z_crc_t FAR *)(const void FAR *)buf; 322 | while (len >= 32) { 323 | DOBIG32; 324 | len -= 32; 325 | } 326 | while (len >= 4) { 327 | DOBIG4; 328 | len -= 4; 329 | } 330 | buf = (const unsigned char FAR *)buf4; 331 | 332 | if (len) do { 333 | c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8); 334 | } while (--len); 335 | c = ~c; 336 | return (unsigned long)(ZSWAP32(c)); 337 | } 338 | 339 | #endif /* BYFOUR */ 340 | 341 | #define GF2_DIM 32 /* dimension of GF(2) vectors (length of CRC) */ 342 | 343 | /* ========================================================================= */ 344 | local unsigned long gf2_matrix_times(mat, vec) 345 | unsigned long *mat; 346 | unsigned long vec; 347 | { 348 | unsigned long sum; 349 | 350 | sum = 0; 351 | while (vec) { 352 | if (vec & 1) 353 | sum ^= *mat; 354 | vec >>= 1; 355 | mat++; 356 | } 357 | return sum; 358 | } 359 | 360 | /* ========================================================================= */ 361 | local void gf2_matrix_square(square, mat) 362 | unsigned long *square; 363 | unsigned long *mat; 364 | { 365 | int n; 366 | 367 | for (n = 0; n < GF2_DIM; n++) 368 | square[n] = gf2_matrix_times(mat, mat[n]); 369 | } 370 | 371 | /* ========================================================================= */ 372 | local uLong crc32_combine_(crc1, crc2, len2) 373 | uLong crc1; 374 | uLong crc2; 375 | z_off64_t len2; 376 | { 377 | int n; 378 | unsigned long row; 379 | unsigned long even[GF2_DIM]; /* even-power-of-two zeros operator */ 380 | unsigned long odd[GF2_DIM]; /* odd-power-of-two zeros operator */ 381 | 382 | /* degenerate case (also disallow negative lengths) */ 383 | if (len2 <= 0) 384 | return crc1; 385 | 386 | /* put operator for one zero bit in odd */ 387 | odd[0] = 0xedb88320UL; /* CRC-32 polynomial */ 388 | row = 1; 389 | for (n = 1; n < GF2_DIM; n++) { 390 | odd[n] = row; 391 | row <<= 1; 392 | } 393 | 394 | /* put operator for two zero bits in even */ 395 | gf2_matrix_square(even, odd); 396 | 397 | /* put operator for four zero bits in odd */ 398 | gf2_matrix_square(odd, even); 399 | 400 | /* apply len2 zeros to crc1 (first square will put the operator for one 401 | zero byte, eight zero bits, in even) */ 402 | do { 403 | /* apply zeros operator for this bit of len2 */ 404 | gf2_matrix_square(even, odd); 405 | if (len2 & 1) 406 | crc1 = gf2_matrix_times(even, crc1); 407 | len2 >>= 1; 408 | 409 | /* if no more bits set, then done */ 410 | if (len2 == 0) 411 | break; 412 | 413 | /* another iteration of the loop with odd and even swapped */ 414 | gf2_matrix_square(odd, even); 415 | if (len2 & 1) 416 | crc1 = gf2_matrix_times(odd, crc1); 417 | len2 >>= 1; 418 | 419 | /* if no more bits set, then done */ 420 | } while (len2 != 0); 421 | 422 | /* return combined crc */ 423 | crc1 ^= crc2; 424 | return crc1; 425 | } 426 | 427 | /* ========================================================================= */ 428 | uLong ZEXPORT crc32_combine(crc1, crc2, len2) 429 | uLong crc1; 430 | uLong crc2; 431 | z_off_t len2; 432 | { 433 | return crc32_combine_(crc1, crc2, len2); 434 | } 435 | 436 | uLong ZEXPORT crc32_combine64(crc1, crc2, len2) 437 | uLong crc1; 438 | uLong crc2; 439 | z_off64_t len2; 440 | { 441 | return crc32_combine_(crc1, crc2, len2); 442 | } 443 | -------------------------------------------------------------------------------- /ext/zlib/deflate.h: -------------------------------------------------------------------------------- 1 | /* deflate.h -- internal compression state 2 | * Copyright (C) 1995-2016 Jean-loup Gailly 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | */ 5 | 6 | /* WARNING: this file should *not* be used by applications. It is 7 | part of the implementation of the compression library and is 8 | subject to change. Applications should only use zlib.h. 9 | */ 10 | 11 | /* @(#) $Id$ */ 12 | 13 | #ifndef DEFLATE_H 14 | #define DEFLATE_H 15 | 16 | #include "zutil.h" 17 | 18 | /* define NO_GZIP when compiling if you want to disable gzip header and 19 | trailer creation by deflate(). NO_GZIP would be used to avoid linking in 20 | the crc code when it is not needed. For shared libraries, gzip encoding 21 | should be left enabled. */ 22 | #ifndef NO_GZIP 23 | # define GZIP 24 | #endif 25 | 26 | /* =========================================================================== 27 | * Internal compression state. 28 | */ 29 | 30 | #define LENGTH_CODES 29 31 | /* number of length codes, not counting the special END_BLOCK code */ 32 | 33 | #define LITERALS 256 34 | /* number of literal bytes 0..255 */ 35 | 36 | #define L_CODES (LITERALS+1+LENGTH_CODES) 37 | /* number of Literal or Length codes, including the END_BLOCK code */ 38 | 39 | #define D_CODES 30 40 | /* number of distance codes */ 41 | 42 | #define BL_CODES 19 43 | /* number of codes used to transfer the bit lengths */ 44 | 45 | #define HEAP_SIZE (2*L_CODES+1) 46 | /* maximum heap size */ 47 | 48 | #define MAX_BITS 15 49 | /* All codes must not exceed MAX_BITS bits */ 50 | 51 | #define Buf_size 16 52 | /* size of bit buffer in bi_buf */ 53 | 54 | #define INIT_STATE 42 /* zlib header -> BUSY_STATE */ 55 | #ifdef GZIP 56 | # define GZIP_STATE 57 /* gzip header -> BUSY_STATE | EXTRA_STATE */ 57 | #endif 58 | #define EXTRA_STATE 69 /* gzip extra block -> NAME_STATE */ 59 | #define NAME_STATE 73 /* gzip file name -> COMMENT_STATE */ 60 | #define COMMENT_STATE 91 /* gzip comment -> HCRC_STATE */ 61 | #define HCRC_STATE 103 /* gzip header CRC -> BUSY_STATE */ 62 | #define BUSY_STATE 113 /* deflate -> FINISH_STATE */ 63 | #define FINISH_STATE 666 /* stream complete */ 64 | /* Stream status */ 65 | 66 | 67 | /* Data structure describing a single value and its code string. */ 68 | typedef struct ct_data_s { 69 | union { 70 | ush freq; /* frequency count */ 71 | ush code; /* bit string */ 72 | } fc; 73 | union { 74 | ush dad; /* father node in Huffman tree */ 75 | ush len; /* length of bit string */ 76 | } dl; 77 | } FAR ct_data; 78 | 79 | #define Freq fc.freq 80 | #define Code fc.code 81 | #define Dad dl.dad 82 | #define Len dl.len 83 | 84 | typedef struct static_tree_desc_s static_tree_desc; 85 | 86 | typedef struct tree_desc_s { 87 | ct_data *dyn_tree; /* the dynamic tree */ 88 | int max_code; /* largest code with non zero frequency */ 89 | const static_tree_desc *stat_desc; /* the corresponding static tree */ 90 | } FAR tree_desc; 91 | 92 | typedef ush Pos; 93 | typedef Pos FAR Posf; 94 | typedef unsigned IPos; 95 | 96 | /* A Pos is an index in the character window. We use short instead of int to 97 | * save space in the various tables. IPos is used only for parameter passing. 98 | */ 99 | 100 | typedef struct internal_state { 101 | z_streamp strm; /* pointer back to this zlib stream */ 102 | int status; /* as the name implies */ 103 | Bytef *pending_buf; /* output still pending */ 104 | ulg pending_buf_size; /* size of pending_buf */ 105 | Bytef *pending_out; /* next pending byte to output to the stream */ 106 | ulg pending; /* nb of bytes in the pending buffer */ 107 | int wrap; /* bit 0 true for zlib, bit 1 true for gzip */ 108 | gz_headerp gzhead; /* gzip header information to write */ 109 | ulg gzindex; /* where in extra, name, or comment */ 110 | Byte method; /* can only be DEFLATED */ 111 | int last_flush; /* value of flush param for previous deflate call */ 112 | 113 | /* used by deflate.c: */ 114 | 115 | uInt w_size; /* LZ77 window size (32K by default) */ 116 | uInt w_bits; /* log2(w_size) (8..16) */ 117 | uInt w_mask; /* w_size - 1 */ 118 | 119 | Bytef *window; 120 | /* Sliding window. Input bytes are read into the second half of the window, 121 | * and move to the first half later to keep a dictionary of at least wSize 122 | * bytes. With this organization, matches are limited to a distance of 123 | * wSize-MAX_MATCH bytes, but this ensures that IO is always 124 | * performed with a length multiple of the block size. Also, it limits 125 | * the window size to 64K, which is quite useful on MSDOS. 126 | * To do: use the user input buffer as sliding window. 127 | */ 128 | 129 | ulg window_size; 130 | /* Actual size of window: 2*wSize, except when the user input buffer 131 | * is directly used as sliding window. 132 | */ 133 | 134 | Posf *prev; 135 | /* Link to older string with same hash index. To limit the size of this 136 | * array to 64K, this link is maintained only for the last 32K strings. 137 | * An index in this array is thus a window index modulo 32K. 138 | */ 139 | 140 | Posf *head; /* Heads of the hash chains or NIL. */ 141 | 142 | uInt ins_h; /* hash index of string to be inserted */ 143 | uInt hash_size; /* number of elements in hash table */ 144 | uInt hash_bits; /* log2(hash_size) */ 145 | uInt hash_mask; /* hash_size-1 */ 146 | 147 | uInt hash_shift; 148 | /* Number of bits by which ins_h must be shifted at each input 149 | * step. It must be such that after MIN_MATCH steps, the oldest 150 | * byte no longer takes part in the hash key, that is: 151 | * hash_shift * MIN_MATCH >= hash_bits 152 | */ 153 | 154 | long block_start; 155 | /* Window position at the beginning of the current output block. Gets 156 | * negative when the window is moved backwards. 157 | */ 158 | 159 | uInt match_length; /* length of best match */ 160 | IPos prev_match; /* previous match */ 161 | int match_available; /* set if previous match exists */ 162 | uInt strstart; /* start of string to insert */ 163 | uInt match_start; /* start of matching string */ 164 | uInt lookahead; /* number of valid bytes ahead in window */ 165 | 166 | uInt prev_length; 167 | /* Length of the best match at previous step. Matches not greater than this 168 | * are discarded. This is used in the lazy match evaluation. 169 | */ 170 | 171 | uInt max_chain_length; 172 | /* To speed up deflation, hash chains are never searched beyond this 173 | * length. A higher limit improves compression ratio but degrades the 174 | * speed. 175 | */ 176 | 177 | uInt max_lazy_match; 178 | /* Attempt to find a better match only when the current match is strictly 179 | * smaller than this value. This mechanism is used only for compression 180 | * levels >= 4. 181 | */ 182 | # define max_insert_length max_lazy_match 183 | /* Insert new strings in the hash table only if the match length is not 184 | * greater than this length. This saves time but degrades compression. 185 | * max_insert_length is used only for compression levels <= 3. 186 | */ 187 | 188 | int level; /* compression level (1..9) */ 189 | int strategy; /* favor or force Huffman coding*/ 190 | 191 | uInt good_match; 192 | /* Use a faster search when the previous match is longer than this */ 193 | 194 | int nice_match; /* Stop searching when current match exceeds this */ 195 | 196 | /* used by trees.c: */ 197 | /* Didn't use ct_data typedef below to suppress compiler warning */ 198 | struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */ 199 | struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */ 200 | struct ct_data_s bl_tree[2*BL_CODES+1]; /* Huffman tree for bit lengths */ 201 | 202 | struct tree_desc_s l_desc; /* desc. for literal tree */ 203 | struct tree_desc_s d_desc; /* desc. for distance tree */ 204 | struct tree_desc_s bl_desc; /* desc. for bit length tree */ 205 | 206 | ush bl_count[MAX_BITS+1]; 207 | /* number of codes at each bit length for an optimal tree */ 208 | 209 | int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */ 210 | int heap_len; /* number of elements in the heap */ 211 | int heap_max; /* element of largest frequency */ 212 | /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used. 213 | * The same heap array is used to build all trees. 214 | */ 215 | 216 | uch depth[2*L_CODES+1]; 217 | /* Depth of each subtree used as tie breaker for trees of equal frequency 218 | */ 219 | 220 | uchf *l_buf; /* buffer for literals or lengths */ 221 | 222 | uInt lit_bufsize; 223 | /* Size of match buffer for literals/lengths. There are 4 reasons for 224 | * limiting lit_bufsize to 64K: 225 | * - frequencies can be kept in 16 bit counters 226 | * - if compression is not successful for the first block, all input 227 | * data is still in the window so we can still emit a stored block even 228 | * when input comes from standard input. (This can also be done for 229 | * all blocks if lit_bufsize is not greater than 32K.) 230 | * - if compression is not successful for a file smaller than 64K, we can 231 | * even emit a stored file instead of a stored block (saving 5 bytes). 232 | * This is applicable only for zip (not gzip or zlib). 233 | * - creating new Huffman trees less frequently may not provide fast 234 | * adaptation to changes in the input data statistics. (Take for 235 | * example a binary file with poorly compressible code followed by 236 | * a highly compressible string table.) Smaller buffer sizes give 237 | * fast adaptation but have of course the overhead of transmitting 238 | * trees more frequently. 239 | * - I can't count above 4 240 | */ 241 | 242 | uInt last_lit; /* running index in l_buf */ 243 | 244 | ushf *d_buf; 245 | /* Buffer for distances. To simplify the code, d_buf and l_buf have 246 | * the same number of elements. To use different lengths, an extra flag 247 | * array would be necessary. 248 | */ 249 | 250 | ulg opt_len; /* bit length of current block with optimal trees */ 251 | ulg static_len; /* bit length of current block with static trees */ 252 | uInt matches; /* number of string matches in current block */ 253 | uInt insert; /* bytes at end of window left to insert */ 254 | 255 | #ifdef ZLIB_DEBUG 256 | ulg compressed_len; /* total bit length of compressed file mod 2^32 */ 257 | ulg bits_sent; /* bit length of compressed data sent mod 2^32 */ 258 | #endif 259 | 260 | ush bi_buf; 261 | /* Output buffer. bits are inserted starting at the bottom (least 262 | * significant bits). 263 | */ 264 | int bi_valid; 265 | /* Number of valid bits in bi_buf. All bits above the last valid bit 266 | * are always zero. 267 | */ 268 | 269 | ulg high_water; 270 | /* High water mark offset in window for initialized bytes -- bytes above 271 | * this are set to zero in order to avoid memory check warnings when 272 | * longest match routines access bytes past the input. This is then 273 | * updated to the new high water mark. 274 | */ 275 | 276 | } FAR deflate_state; 277 | 278 | /* Output a byte on the stream. 279 | * IN assertion: there is enough room in pending_buf. 280 | */ 281 | #define put_byte(s, c) {s->pending_buf[s->pending++] = (Bytef)(c);} 282 | 283 | 284 | #define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1) 285 | /* Minimum amount of lookahead, except at the end of the input file. 286 | * See deflate.c for comments about the MIN_MATCH+1. 287 | */ 288 | 289 | #define MAX_DIST(s) ((s)->w_size-MIN_LOOKAHEAD) 290 | /* In order to simplify the code, particularly on 16 bit machines, match 291 | * distances are limited to MAX_DIST instead of WSIZE. 292 | */ 293 | 294 | #define WIN_INIT MAX_MATCH 295 | /* Number of bytes after end of data in window to initialize in order to avoid 296 | memory checker errors from longest match routines */ 297 | 298 | /* in trees.c */ 299 | void ZLIB_INTERNAL _tr_init OF((deflate_state *s)); 300 | int ZLIB_INTERNAL _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc)); 301 | void ZLIB_INTERNAL _tr_flush_block OF((deflate_state *s, charf *buf, 302 | ulg stored_len, int last)); 303 | void ZLIB_INTERNAL _tr_flush_bits OF((deflate_state *s)); 304 | void ZLIB_INTERNAL _tr_align OF((deflate_state *s)); 305 | void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf, 306 | ulg stored_len, int last)); 307 | 308 | #define d_code(dist) \ 309 | ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)]) 310 | /* Mapping from a distance to a distance code. dist is the distance - 1 and 311 | * must not have side effects. _dist_code[256] and _dist_code[257] are never 312 | * used. 313 | */ 314 | 315 | #ifndef ZLIB_DEBUG 316 | /* Inline versions of _tr_tally for speed: */ 317 | 318 | #if defined(GEN_TREES_H) || !defined(STDC) 319 | extern uch ZLIB_INTERNAL _length_code[]; 320 | extern uch ZLIB_INTERNAL _dist_code[]; 321 | #else 322 | extern const uch ZLIB_INTERNAL _length_code[]; 323 | extern const uch ZLIB_INTERNAL _dist_code[]; 324 | #endif 325 | 326 | # define _tr_tally_lit(s, c, flush) \ 327 | { uch cc = (c); \ 328 | s->d_buf[s->last_lit] = 0; \ 329 | s->l_buf[s->last_lit++] = cc; \ 330 | s->dyn_ltree[cc].Freq++; \ 331 | flush = (s->last_lit == s->lit_bufsize-1); \ 332 | } 333 | # define _tr_tally_dist(s, distance, length, flush) \ 334 | { uch len = (uch)(length); \ 335 | ush dist = (ush)(distance); \ 336 | s->d_buf[s->last_lit] = dist; \ 337 | s->l_buf[s->last_lit++] = len; \ 338 | dist--; \ 339 | s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \ 340 | s->dyn_dtree[d_code(dist)].Freq++; \ 341 | flush = (s->last_lit == s->lit_bufsize-1); \ 342 | } 343 | #else 344 | # define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c) 345 | # define _tr_tally_dist(s, distance, length, flush) \ 346 | flush = _tr_tally(s, distance, length) 347 | #endif 348 | 349 | #endif /* DEFLATE_H */ 350 | -------------------------------------------------------------------------------- /ext/zlib/gzclose.c: -------------------------------------------------------------------------------- 1 | /* gzclose.c -- zlib gzclose() function 2 | * Copyright (C) 2004, 2010 Mark Adler 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | */ 5 | 6 | #include "gzguts.h" 7 | 8 | /* gzclose() is in a separate file so that it is linked in only if it is used. 9 | That way the other gzclose functions can be used instead to avoid linking in 10 | unneeded compression or decompression routines. */ 11 | int ZEXPORT gzclose(file) 12 | gzFile file; 13 | { 14 | #ifndef NO_GZCOMPRESS 15 | gz_statep state; 16 | 17 | if (file == NULL) 18 | return Z_STREAM_ERROR; 19 | state = (gz_statep)file; 20 | 21 | return state->mode == GZ_READ ? gzclose_r(file) : gzclose_w(file); 22 | #else 23 | return gzclose_r(file); 24 | #endif 25 | } 26 | -------------------------------------------------------------------------------- /ext/zlib/gzguts.h: -------------------------------------------------------------------------------- 1 | /* gzguts.h -- zlib internal header definitions for gz* operations 2 | * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013, 2016 Mark Adler 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | */ 5 | 6 | #if defined(__APPLE__) 7 | #include 8 | #endif 9 | 10 | #ifdef _LARGEFILE64_SOURCE 11 | # ifndef _LARGEFILE_SOURCE 12 | # define _LARGEFILE_SOURCE 1 13 | # endif 14 | # ifdef _FILE_OFFSET_BITS 15 | # undef _FILE_OFFSET_BITS 16 | # endif 17 | #endif 18 | 19 | #ifdef HAVE_HIDDEN 20 | # define ZLIB_INTERNAL __attribute__((visibility ("hidden"))) 21 | #else 22 | # define ZLIB_INTERNAL 23 | #endif 24 | 25 | #include 26 | #include "zlib.h" 27 | #ifdef STDC 28 | # include 29 | # include 30 | # include 31 | #endif 32 | 33 | #ifndef _POSIX_SOURCE 34 | # define _POSIX_SOURCE 35 | #endif 36 | #include 37 | 38 | #ifdef _WIN32 39 | # include 40 | #endif 41 | 42 | #if defined(__TURBOC__) || defined(_MSC_VER) || defined(_WIN32) 43 | # include 44 | #endif 45 | 46 | #if defined(_WIN32) || defined(__CYGWIN__) 47 | # define WIDECHAR 48 | #endif 49 | 50 | #ifdef WINAPI_FAMILY 51 | # define open _open 52 | # define read _read 53 | # define write _write 54 | # define close _close 55 | #endif 56 | 57 | #ifdef NO_DEFLATE /* for compatibility with old definition */ 58 | # define NO_GZCOMPRESS 59 | #endif 60 | 61 | #if defined(STDC99) || (defined(__TURBOC__) && __TURBOC__ >= 0x550) 62 | # ifndef HAVE_VSNPRINTF 63 | # define HAVE_VSNPRINTF 64 | # endif 65 | #endif 66 | 67 | #if defined(__CYGWIN__) 68 | # ifndef HAVE_VSNPRINTF 69 | # define HAVE_VSNPRINTF 70 | # endif 71 | #endif 72 | 73 | #if defined(MSDOS) && defined(__BORLANDC__) && (BORLANDC > 0x410) 74 | # ifndef HAVE_VSNPRINTF 75 | # define HAVE_VSNPRINTF 76 | # endif 77 | #endif 78 | 79 | #ifndef HAVE_VSNPRINTF 80 | # ifdef MSDOS 81 | /* vsnprintf may exist on some MS-DOS compilers (DJGPP?), 82 | but for now we just assume it doesn't. */ 83 | # define NO_vsnprintf 84 | # endif 85 | # ifdef __TURBOC__ 86 | # define NO_vsnprintf 87 | # endif 88 | # ifdef WIN32 89 | /* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */ 90 | # if !defined(vsnprintf) && !defined(NO_vsnprintf) 91 | # if !defined(_MSC_VER) || ( defined(_MSC_VER) && _MSC_VER < 1500 ) 92 | # define vsnprintf _vsnprintf 93 | # endif 94 | # endif 95 | # endif 96 | # ifdef __SASC 97 | # define NO_vsnprintf 98 | # endif 99 | # ifdef VMS 100 | # define NO_vsnprintf 101 | # endif 102 | # ifdef __OS400__ 103 | # define NO_vsnprintf 104 | # endif 105 | # ifdef __MVS__ 106 | # define NO_vsnprintf 107 | # endif 108 | #endif 109 | 110 | /* unlike snprintf (which is required in C99), _snprintf does not guarantee 111 | null termination of the result -- however this is only used in gzlib.c where 112 | the result is assured to fit in the space provided */ 113 | #if defined(_MSC_VER) && _MSC_VER < 1900 114 | # define snprintf _snprintf 115 | #endif 116 | 117 | #ifndef local 118 | # define local static 119 | #endif 120 | /* since "static" is used to mean two completely different things in C, we 121 | define "local" for the non-static meaning of "static", for readability 122 | (compile with -Dlocal if your debugger can't find static symbols) */ 123 | 124 | /* gz* functions always use library allocation functions */ 125 | #ifndef STDC 126 | extern voidp malloc OF((uInt size)); 127 | extern void free OF((voidpf ptr)); 128 | #endif 129 | 130 | /* get errno and strerror definition */ 131 | #if defined UNDER_CE 132 | # include 133 | # define zstrerror() gz_strwinerror((DWORD)GetLastError()) 134 | #else 135 | # ifndef NO_STRERROR 136 | # include 137 | # define zstrerror() strerror(errno) 138 | # else 139 | # define zstrerror() "stdio error (consult errno)" 140 | # endif 141 | #endif 142 | 143 | /* provide prototypes for these when building zlib without LFS */ 144 | #if !defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0 145 | ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); 146 | ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int)); 147 | ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile)); 148 | ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile)); 149 | #endif 150 | 151 | /* default memLevel */ 152 | #if MAX_MEM_LEVEL >= 8 153 | # define DEF_MEM_LEVEL 8 154 | #else 155 | # define DEF_MEM_LEVEL MAX_MEM_LEVEL 156 | #endif 157 | 158 | /* default i/o buffer size -- double this for output when reading (this and 159 | twice this must be able to fit in an unsigned type) */ 160 | #define GZBUFSIZE 8192 161 | 162 | /* gzip modes, also provide a little integrity check on the passed structure */ 163 | #define GZ_NONE 0 164 | #define GZ_READ 7247 165 | #define GZ_WRITE 31153 166 | #define GZ_APPEND 1 /* mode set to GZ_WRITE after the file is opened */ 167 | 168 | /* values for gz_state how */ 169 | #define LOOK 0 /* look for a gzip header */ 170 | #define COPY 1 /* copy input directly */ 171 | #define GZIP 2 /* decompress a gzip stream */ 172 | 173 | /* internal gzip file state data structure */ 174 | typedef struct { 175 | /* exposed contents for gzgetc() macro */ 176 | struct gzFile_s x; /* "x" for exposed */ 177 | /* x.have: number of bytes available at x.next */ 178 | /* x.next: next output data to deliver or write */ 179 | /* x.pos: current position in uncompressed data */ 180 | /* used for both reading and writing */ 181 | int mode; /* see gzip modes above */ 182 | int fd; /* file descriptor */ 183 | char *path; /* path or fd for error messages */ 184 | unsigned size; /* buffer size, zero if not allocated yet */ 185 | unsigned want; /* requested buffer size, default is GZBUFSIZE */ 186 | unsigned char *in; /* input buffer (double-sized when writing) */ 187 | unsigned char *out; /* output buffer (double-sized when reading) */ 188 | int direct; /* 0 if processing gzip, 1 if transparent */ 189 | /* just for reading */ 190 | int how; /* 0: get header, 1: copy, 2: decompress */ 191 | z_off64_t start; /* where the gzip data started, for rewinding */ 192 | int eof; /* true if end of input file reached */ 193 | int past; /* true if read requested past end */ 194 | /* just for writing */ 195 | int level; /* compression level */ 196 | int strategy; /* compression strategy */ 197 | /* seek request */ 198 | z_off64_t skip; /* amount to skip (already rewound if backwards) */ 199 | int seek; /* true if seek request pending */ 200 | /* error information */ 201 | int err; /* error code */ 202 | char *msg; /* error message */ 203 | /* zlib inflate or deflate stream */ 204 | z_stream strm; /* stream structure in-place (not a pointer) */ 205 | } gz_state; 206 | typedef gz_state FAR *gz_statep; 207 | 208 | /* shared functions */ 209 | void ZLIB_INTERNAL gz_error OF((gz_statep, int, const char *)); 210 | #if defined UNDER_CE 211 | char ZLIB_INTERNAL *gz_strwinerror OF((DWORD error)); 212 | #endif 213 | 214 | /* GT_OFF(x), where x is an unsigned value, is true if x > maximum z_off64_t 215 | value -- needed when comparing unsigned to z_off64_t, which is signed 216 | (possible z_off64_t types off_t, off64_t, and long are all signed) */ 217 | #ifdef INT_MAX 218 | # define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > INT_MAX) 219 | #else 220 | unsigned ZLIB_INTERNAL gz_intmax OF((void)); 221 | # define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > gz_intmax()) 222 | #endif 223 | -------------------------------------------------------------------------------- /ext/zlib/gzlib.c: -------------------------------------------------------------------------------- 1 | /* gzlib.c -- zlib functions common to reading and writing gzip files 2 | * Copyright (C) 2004-2017 Mark Adler 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | */ 5 | 6 | #include "gzguts.h" 7 | 8 | #if defined(_WIN32) && !defined(__BORLANDC__) && !defined(__MINGW32__) 9 | # define LSEEK _lseeki64 10 | #else 11 | #if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0 12 | # define LSEEK lseek64 13 | #else 14 | # define LSEEK lseek 15 | #endif 16 | #endif 17 | 18 | /* Local functions */ 19 | local void gz_reset OF((gz_statep)); 20 | local gzFile gz_open OF((const void *, int, const char *)); 21 | 22 | #if defined UNDER_CE 23 | 24 | /* Map the Windows error number in ERROR to a locale-dependent error message 25 | string and return a pointer to it. Typically, the values for ERROR come 26 | from GetLastError. 27 | 28 | The string pointed to shall not be modified by the application, but may be 29 | overwritten by a subsequent call to gz_strwinerror 30 | 31 | The gz_strwinerror function does not change the current setting of 32 | GetLastError. */ 33 | char ZLIB_INTERNAL *gz_strwinerror (error) 34 | DWORD error; 35 | { 36 | static char buf[1024]; 37 | 38 | wchar_t *msgbuf; 39 | DWORD lasterr = GetLastError(); 40 | DWORD chars = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM 41 | | FORMAT_MESSAGE_ALLOCATE_BUFFER, 42 | NULL, 43 | error, 44 | 0, /* Default language */ 45 | (LPVOID)&msgbuf, 46 | 0, 47 | NULL); 48 | if (chars != 0) { 49 | /* If there is an \r\n appended, zap it. */ 50 | if (chars >= 2 51 | && msgbuf[chars - 2] == '\r' && msgbuf[chars - 1] == '\n') { 52 | chars -= 2; 53 | msgbuf[chars] = 0; 54 | } 55 | 56 | if (chars > sizeof (buf) - 1) { 57 | chars = sizeof (buf) - 1; 58 | msgbuf[chars] = 0; 59 | } 60 | 61 | wcstombs(buf, msgbuf, chars + 1); 62 | LocalFree(msgbuf); 63 | } 64 | else { 65 | sprintf(buf, "unknown win32 error (%ld)", error); 66 | } 67 | 68 | SetLastError(lasterr); 69 | return buf; 70 | } 71 | 72 | #endif /* UNDER_CE */ 73 | 74 | /* Reset gzip file state */ 75 | local void gz_reset(state) 76 | gz_statep state; 77 | { 78 | state->x.have = 0; /* no output data available */ 79 | if (state->mode == GZ_READ) { /* for reading ... */ 80 | state->eof = 0; /* not at end of file */ 81 | state->past = 0; /* have not read past end yet */ 82 | state->how = LOOK; /* look for gzip header */ 83 | } 84 | state->seek = 0; /* no seek request pending */ 85 | gz_error(state, Z_OK, NULL); /* clear error */ 86 | state->x.pos = 0; /* no uncompressed data yet */ 87 | state->strm.avail_in = 0; /* no input data yet */ 88 | } 89 | 90 | /* Open a gzip file either by name or file descriptor. */ 91 | local gzFile gz_open(path, fd, mode) 92 | const void *path; 93 | int fd; 94 | const char *mode; 95 | { 96 | gz_statep state; 97 | z_size_t len; 98 | int oflag; 99 | #ifdef O_CLOEXEC 100 | int cloexec = 0; 101 | #endif 102 | #ifdef O_EXCL 103 | int exclusive = 0; 104 | #endif 105 | 106 | /* check input */ 107 | if (path == NULL) 108 | return NULL; 109 | 110 | /* allocate gzFile structure to return */ 111 | state = (gz_statep)malloc(sizeof(gz_state)); 112 | if (state == NULL) 113 | return NULL; 114 | state->size = 0; /* no buffers allocated yet */ 115 | state->want = GZBUFSIZE; /* requested buffer size */ 116 | state->msg = NULL; /* no error message yet */ 117 | 118 | /* interpret mode */ 119 | state->mode = GZ_NONE; 120 | state->level = Z_DEFAULT_COMPRESSION; 121 | state->strategy = Z_DEFAULT_STRATEGY; 122 | state->direct = 0; 123 | while (*mode) { 124 | if (*mode >= '0' && *mode <= '9') 125 | state->level = *mode - '0'; 126 | else 127 | switch (*mode) { 128 | case 'r': 129 | state->mode = GZ_READ; 130 | break; 131 | #ifndef NO_GZCOMPRESS 132 | case 'w': 133 | state->mode = GZ_WRITE; 134 | break; 135 | case 'a': 136 | state->mode = GZ_APPEND; 137 | break; 138 | #endif 139 | case '+': /* can't read and write at the same time */ 140 | free(state); 141 | return NULL; 142 | case 'b': /* ignore -- will request binary anyway */ 143 | break; 144 | #ifdef O_CLOEXEC 145 | case 'e': 146 | cloexec = 1; 147 | break; 148 | #endif 149 | #ifdef O_EXCL 150 | case 'x': 151 | exclusive = 1; 152 | break; 153 | #endif 154 | case 'f': 155 | state->strategy = Z_FILTERED; 156 | break; 157 | case 'h': 158 | state->strategy = Z_HUFFMAN_ONLY; 159 | break; 160 | case 'R': 161 | state->strategy = Z_RLE; 162 | break; 163 | case 'F': 164 | state->strategy = Z_FIXED; 165 | break; 166 | case 'T': 167 | state->direct = 1; 168 | break; 169 | default: /* could consider as an error, but just ignore */ 170 | ; 171 | } 172 | mode++; 173 | } 174 | 175 | /* must provide an "r", "w", or "a" */ 176 | if (state->mode == GZ_NONE) { 177 | free(state); 178 | return NULL; 179 | } 180 | 181 | /* can't force transparent read */ 182 | if (state->mode == GZ_READ) { 183 | if (state->direct) { 184 | free(state); 185 | return NULL; 186 | } 187 | state->direct = 1; /* for empty file */ 188 | } 189 | 190 | /* save the path name for error messages */ 191 | #ifdef WIDECHAR 192 | if (fd == -2) { 193 | len = wcstombs(NULL, path, 0); 194 | if (len == (z_size_t)-1) 195 | len = 0; 196 | } 197 | else 198 | #endif 199 | len = strlen((const char *)path); 200 | state->path = (char *)malloc(len + 1); 201 | if (state->path == NULL) { 202 | free(state); 203 | return NULL; 204 | } 205 | #ifdef WIDECHAR 206 | if (fd == -2) 207 | if (len) 208 | wcstombs(state->path, path, len + 1); 209 | else 210 | *(state->path) = 0; 211 | else 212 | #endif 213 | #if !defined(NO_snprintf) && !defined(NO_vsnprintf) 214 | (void)snprintf(state->path, len + 1, "%s", (const char *)path); 215 | #else 216 | strcpy(state->path, path); 217 | #endif 218 | 219 | /* compute the flags for open() */ 220 | oflag = 221 | #ifdef O_LARGEFILE 222 | O_LARGEFILE | 223 | #endif 224 | #ifdef O_BINARY 225 | O_BINARY | 226 | #endif 227 | #ifdef O_CLOEXEC 228 | (cloexec ? O_CLOEXEC : 0) | 229 | #endif 230 | (state->mode == GZ_READ ? 231 | O_RDONLY : 232 | (O_WRONLY | O_CREAT | 233 | #ifdef O_EXCL 234 | (exclusive ? O_EXCL : 0) | 235 | #endif 236 | (state->mode == GZ_WRITE ? 237 | O_TRUNC : 238 | O_APPEND))); 239 | 240 | /* open the file with the appropriate flags (or just use fd) */ 241 | state->fd = fd > -1 ? fd : ( 242 | #ifdef WIDECHAR 243 | fd == -2 ? _wopen(path, oflag, 0666) : 244 | #endif 245 | open((const char *)path, oflag, 0666)); 246 | if (state->fd == -1) { 247 | free(state->path); 248 | free(state); 249 | return NULL; 250 | } 251 | if (state->mode == GZ_APPEND) { 252 | LSEEK(state->fd, 0, SEEK_END); /* so gzoffset() is correct */ 253 | state->mode = GZ_WRITE; /* simplify later checks */ 254 | } 255 | 256 | /* save the current position for rewinding (only if reading) */ 257 | if (state->mode == GZ_READ) { 258 | state->start = LSEEK(state->fd, 0, SEEK_CUR); 259 | if (state->start == -1) state->start = 0; 260 | } 261 | 262 | /* initialize stream */ 263 | gz_reset(state); 264 | 265 | /* return stream */ 266 | return (gzFile)state; 267 | } 268 | 269 | /* -- see zlib.h -- */ 270 | gzFile ZEXPORT gzopen(path, mode) 271 | const char *path; 272 | const char *mode; 273 | { 274 | return gz_open(path, -1, mode); 275 | } 276 | 277 | /* -- see zlib.h -- */ 278 | gzFile ZEXPORT gzopen64(path, mode) 279 | const char *path; 280 | const char *mode; 281 | { 282 | return gz_open(path, -1, mode); 283 | } 284 | 285 | /* -- see zlib.h -- */ 286 | gzFile ZEXPORT gzdopen(fd, mode) 287 | int fd; 288 | const char *mode; 289 | { 290 | char *path; /* identifier for error messages */ 291 | gzFile gz; 292 | 293 | if (fd == -1 || (path = (char *)malloc(7 + 3 * sizeof(int))) == NULL) 294 | return NULL; 295 | #if !defined(NO_snprintf) && !defined(NO_vsnprintf) 296 | (void)snprintf(path, 7 + 3 * sizeof(int), "", fd); 297 | #else 298 | sprintf(path, "", fd); /* for debugging */ 299 | #endif 300 | gz = gz_open(path, fd, mode); 301 | free(path); 302 | return gz; 303 | } 304 | 305 | /* -- see zlib.h -- */ 306 | #ifdef WIDECHAR 307 | gzFile ZEXPORT gzopen_w(path, mode) 308 | const wchar_t *path; 309 | const char *mode; 310 | { 311 | return gz_open(path, -2, mode); 312 | } 313 | #endif 314 | 315 | /* -- see zlib.h -- */ 316 | int ZEXPORT gzbuffer(file, size) 317 | gzFile file; 318 | unsigned size; 319 | { 320 | gz_statep state; 321 | 322 | /* get internal structure and check integrity */ 323 | if (file == NULL) 324 | return -1; 325 | state = (gz_statep)file; 326 | if (state->mode != GZ_READ && state->mode != GZ_WRITE) 327 | return -1; 328 | 329 | /* make sure we haven't already allocated memory */ 330 | if (state->size != 0) 331 | return -1; 332 | 333 | /* check and set requested size */ 334 | if ((size << 1) < size) 335 | return -1; /* need to be able to double it */ 336 | if (size < 2) 337 | size = 2; /* need two bytes to check magic header */ 338 | state->want = size; 339 | return 0; 340 | } 341 | 342 | /* -- see zlib.h -- */ 343 | int ZEXPORT gzrewind(file) 344 | gzFile file; 345 | { 346 | gz_statep state; 347 | 348 | /* get internal structure */ 349 | if (file == NULL) 350 | return -1; 351 | state = (gz_statep)file; 352 | 353 | /* check that we're reading and that there's no error */ 354 | if (state->mode != GZ_READ || 355 | (state->err != Z_OK && state->err != Z_BUF_ERROR)) 356 | return -1; 357 | 358 | /* back up and start over */ 359 | if (LSEEK(state->fd, state->start, SEEK_SET) == -1) 360 | return -1; 361 | gz_reset(state); 362 | return 0; 363 | } 364 | 365 | /* -- see zlib.h -- */ 366 | z_off64_t ZEXPORT gzseek64(file, offset, whence) 367 | gzFile file; 368 | z_off64_t offset; 369 | int whence; 370 | { 371 | unsigned n; 372 | z_off64_t ret; 373 | gz_statep state; 374 | 375 | /* get internal structure and check integrity */ 376 | if (file == NULL) 377 | return -1; 378 | state = (gz_statep)file; 379 | if (state->mode != GZ_READ && state->mode != GZ_WRITE) 380 | return -1; 381 | 382 | /* check that there's no error */ 383 | if (state->err != Z_OK && state->err != Z_BUF_ERROR) 384 | return -1; 385 | 386 | /* can only seek from start or relative to current position */ 387 | if (whence != SEEK_SET && whence != SEEK_CUR) 388 | return -1; 389 | 390 | /* normalize offset to a SEEK_CUR specification */ 391 | if (whence == SEEK_SET) 392 | offset -= state->x.pos; 393 | else if (state->seek) 394 | offset += state->skip; 395 | state->seek = 0; 396 | 397 | /* if within raw area while reading, just go there */ 398 | if (state->mode == GZ_READ && state->how == COPY && 399 | state->x.pos + offset >= 0) { 400 | ret = LSEEK(state->fd, offset - state->x.have, SEEK_CUR); 401 | if (ret == -1) 402 | return -1; 403 | state->x.have = 0; 404 | state->eof = 0; 405 | state->past = 0; 406 | state->seek = 0; 407 | gz_error(state, Z_OK, NULL); 408 | state->strm.avail_in = 0; 409 | state->x.pos += offset; 410 | return state->x.pos; 411 | } 412 | 413 | /* calculate skip amount, rewinding if needed for back seek when reading */ 414 | if (offset < 0) { 415 | if (state->mode != GZ_READ) /* writing -- can't go backwards */ 416 | return -1; 417 | offset += state->x.pos; 418 | if (offset < 0) /* before start of file! */ 419 | return -1; 420 | if (gzrewind(file) == -1) /* rewind, then skip to offset */ 421 | return -1; 422 | } 423 | 424 | /* if reading, skip what's in output buffer (one less gzgetc() check) */ 425 | if (state->mode == GZ_READ) { 426 | n = GT_OFF(state->x.have) || (z_off64_t)state->x.have > offset ? 427 | (unsigned)offset : state->x.have; 428 | state->x.have -= n; 429 | state->x.next += n; 430 | state->x.pos += n; 431 | offset -= n; 432 | } 433 | 434 | /* request skip (if not zero) */ 435 | if (offset) { 436 | state->seek = 1; 437 | state->skip = offset; 438 | } 439 | return state->x.pos + offset; 440 | } 441 | 442 | /* -- see zlib.h -- */ 443 | z_off_t ZEXPORT gzseek(file, offset, whence) 444 | gzFile file; 445 | z_off_t offset; 446 | int whence; 447 | { 448 | z_off64_t ret; 449 | 450 | ret = gzseek64(file, (z_off64_t)offset, whence); 451 | return ret == (z_off_t)ret ? (z_off_t)ret : -1; 452 | } 453 | 454 | /* -- see zlib.h -- */ 455 | z_off64_t ZEXPORT gztell64(file) 456 | gzFile file; 457 | { 458 | gz_statep state; 459 | 460 | /* get internal structure and check integrity */ 461 | if (file == NULL) 462 | return -1; 463 | state = (gz_statep)file; 464 | if (state->mode != GZ_READ && state->mode != GZ_WRITE) 465 | return -1; 466 | 467 | /* return position */ 468 | return state->x.pos + (state->seek ? state->skip : 0); 469 | } 470 | 471 | /* -- see zlib.h -- */ 472 | z_off_t ZEXPORT gztell(file) 473 | gzFile file; 474 | { 475 | z_off64_t ret; 476 | 477 | ret = gztell64(file); 478 | return ret == (z_off_t)ret ? (z_off_t)ret : -1; 479 | } 480 | 481 | /* -- see zlib.h -- */ 482 | z_off64_t ZEXPORT gzoffset64(file) 483 | gzFile file; 484 | { 485 | z_off64_t offset; 486 | gz_statep state; 487 | 488 | /* get internal structure and check integrity */ 489 | if (file == NULL) 490 | return -1; 491 | state = (gz_statep)file; 492 | if (state->mode != GZ_READ && state->mode != GZ_WRITE) 493 | return -1; 494 | 495 | /* compute and return effective offset in file */ 496 | offset = LSEEK(state->fd, 0, SEEK_CUR); 497 | if (offset == -1) 498 | return -1; 499 | if (state->mode == GZ_READ) /* reading */ 500 | offset -= state->strm.avail_in; /* don't count buffered input */ 501 | return offset; 502 | } 503 | 504 | /* -- see zlib.h -- */ 505 | z_off_t ZEXPORT gzoffset(file) 506 | gzFile file; 507 | { 508 | z_off64_t ret; 509 | 510 | ret = gzoffset64(file); 511 | return ret == (z_off_t)ret ? (z_off_t)ret : -1; 512 | } 513 | 514 | /* -- see zlib.h -- */ 515 | int ZEXPORT gzeof(file) 516 | gzFile file; 517 | { 518 | gz_statep state; 519 | 520 | /* get internal structure and check integrity */ 521 | if (file == NULL) 522 | return 0; 523 | state = (gz_statep)file; 524 | if (state->mode != GZ_READ && state->mode != GZ_WRITE) 525 | return 0; 526 | 527 | /* return end-of-file state */ 528 | return state->mode == GZ_READ ? state->past : 0; 529 | } 530 | 531 | /* -- see zlib.h -- */ 532 | const char * ZEXPORT gzerror(file, errnum) 533 | gzFile file; 534 | int *errnum; 535 | { 536 | gz_statep state; 537 | 538 | /* get internal structure and check integrity */ 539 | if (file == NULL) 540 | return NULL; 541 | state = (gz_statep)file; 542 | if (state->mode != GZ_READ && state->mode != GZ_WRITE) 543 | return NULL; 544 | 545 | /* return error information */ 546 | if (errnum != NULL) 547 | *errnum = state->err; 548 | return state->err == Z_MEM_ERROR ? "out of memory" : 549 | (state->msg == NULL ? "" : state->msg); 550 | } 551 | 552 | /* -- see zlib.h -- */ 553 | void ZEXPORT gzclearerr(file) 554 | gzFile file; 555 | { 556 | gz_statep state; 557 | 558 | /* get internal structure and check integrity */ 559 | if (file == NULL) 560 | return; 561 | state = (gz_statep)file; 562 | if (state->mode != GZ_READ && state->mode != GZ_WRITE) 563 | return; 564 | 565 | /* clear error and end-of-file */ 566 | if (state->mode == GZ_READ) { 567 | state->eof = 0; 568 | state->past = 0; 569 | } 570 | gz_error(state, Z_OK, NULL); 571 | } 572 | 573 | /* Create an error message in allocated memory and set state->err and 574 | state->msg accordingly. Free any previous error message already there. Do 575 | not try to free or allocate space if the error is Z_MEM_ERROR (out of 576 | memory). Simply save the error message as a static string. If there is an 577 | allocation failure constructing the error message, then convert the error to 578 | out of memory. */ 579 | void ZLIB_INTERNAL gz_error(state, err, msg) 580 | gz_statep state; 581 | int err; 582 | const char *msg; 583 | { 584 | /* free previously allocated message and clear */ 585 | if (state->msg != NULL) { 586 | if (state->err != Z_MEM_ERROR) 587 | free(state->msg); 588 | state->msg = NULL; 589 | } 590 | 591 | /* if fatal, set state->x.have to 0 so that the gzgetc() macro fails */ 592 | if (err != Z_OK && err != Z_BUF_ERROR) 593 | state->x.have = 0; 594 | 595 | /* set error code, and if no message, then done */ 596 | state->err = err; 597 | if (msg == NULL) 598 | return; 599 | 600 | /* for an out of memory error, return literal string when requested */ 601 | if (err == Z_MEM_ERROR) 602 | return; 603 | 604 | /* construct error message with path */ 605 | if ((state->msg = (char *)malloc(strlen(state->path) + strlen(msg) + 3)) == 606 | NULL) { 607 | state->err = Z_MEM_ERROR; 608 | return; 609 | } 610 | #if !defined(NO_snprintf) && !defined(NO_vsnprintf) 611 | (void)snprintf(state->msg, strlen(state->path) + strlen(msg) + 3, 612 | "%s%s%s", state->path, ": ", msg); 613 | #else 614 | strcpy(state->msg, state->path); 615 | strcat(state->msg, ": "); 616 | strcat(state->msg, msg); 617 | #endif 618 | } 619 | 620 | #ifndef INT_MAX 621 | /* portably return maximum value for an int (when limits.h presumed not 622 | available) -- we need to do this to cover cases where 2's complement not 623 | used, since C standard permits 1's complement and sign-bit representations, 624 | otherwise we could just use ((unsigned)-1) >> 1 */ 625 | unsigned ZLIB_INTERNAL gz_intmax() 626 | { 627 | unsigned p, q; 628 | 629 | p = 1; 630 | do { 631 | q = p; 632 | p <<= 1; 633 | p++; 634 | } while (p > q); 635 | return q >> 1; 636 | } 637 | #endif 638 | -------------------------------------------------------------------------------- /ext/zlib/inffast.c: -------------------------------------------------------------------------------- 1 | /* inffast.c -- fast decoding 2 | * Copyright (C) 1995-2017 Mark Adler 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | */ 5 | 6 | #include "zutil.h" 7 | #include "inftrees.h" 8 | #include "inflate.h" 9 | #include "inffast.h" 10 | 11 | #ifdef ASMINF 12 | # pragma message("Assembler code may have bugs -- use at your own risk") 13 | #else 14 | 15 | /* 16 | Decode literal, length, and distance codes and write out the resulting 17 | literal and match bytes until either not enough input or output is 18 | available, an end-of-block is encountered, or a data error is encountered. 19 | When large enough input and output buffers are supplied to inflate(), for 20 | example, a 16K input buffer and a 64K output buffer, more than 95% of the 21 | inflate execution time is spent in this routine. 22 | 23 | Entry assumptions: 24 | 25 | state->mode == LEN 26 | strm->avail_in >= 6 27 | strm->avail_out >= 258 28 | start >= strm->avail_out 29 | state->bits < 8 30 | 31 | On return, state->mode is one of: 32 | 33 | LEN -- ran out of enough output space or enough available input 34 | TYPE -- reached end of block code, inflate() to interpret next block 35 | BAD -- error in block data 36 | 37 | Notes: 38 | 39 | - The maximum input bits used by a length/distance pair is 15 bits for the 40 | length code, 5 bits for the length extra, 15 bits for the distance code, 41 | and 13 bits for the distance extra. This totals 48 bits, or six bytes. 42 | Therefore if strm->avail_in >= 6, then there is enough input to avoid 43 | checking for available input while decoding. 44 | 45 | - The maximum bytes that a single length/distance pair can output is 258 46 | bytes, which is the maximum length that can be coded. inflate_fast() 47 | requires strm->avail_out >= 258 for each loop to avoid checking for 48 | output space. 49 | */ 50 | void ZLIB_INTERNAL inflate_fast(strm, start) 51 | z_streamp strm; 52 | unsigned start; /* inflate()'s starting value for strm->avail_out */ 53 | { 54 | struct inflate_state FAR *state; 55 | z_const unsigned char FAR *in; /* local strm->next_in */ 56 | z_const unsigned char FAR *last; /* have enough input while in < last */ 57 | unsigned char FAR *out; /* local strm->next_out */ 58 | unsigned char FAR *beg; /* inflate()'s initial strm->next_out */ 59 | unsigned char FAR *end; /* while out < end, enough space available */ 60 | #ifdef INFLATE_STRICT 61 | unsigned dmax; /* maximum distance from zlib header */ 62 | #endif 63 | unsigned wsize; /* window size or zero if not using window */ 64 | unsigned whave; /* valid bytes in the window */ 65 | unsigned wnext; /* window write index */ 66 | unsigned char FAR *window; /* allocated sliding window, if wsize != 0 */ 67 | unsigned long hold; /* local strm->hold */ 68 | unsigned bits; /* local strm->bits */ 69 | code const FAR *lcode; /* local strm->lencode */ 70 | code const FAR *dcode; /* local strm->distcode */ 71 | unsigned lmask; /* mask for first level of length codes */ 72 | unsigned dmask; /* mask for first level of distance codes */ 73 | code here; /* retrieved table entry */ 74 | unsigned op; /* code bits, operation, extra bits, or */ 75 | /* window position, window bytes to copy */ 76 | unsigned len; /* match length, unused bytes */ 77 | unsigned dist; /* match distance */ 78 | unsigned char FAR *from; /* where to copy match from */ 79 | 80 | /* copy state to local variables */ 81 | state = (struct inflate_state FAR *)strm->state; 82 | in = strm->next_in; 83 | last = in + (strm->avail_in - 5); 84 | out = strm->next_out; 85 | beg = out - (start - strm->avail_out); 86 | end = out + (strm->avail_out - 257); 87 | #ifdef INFLATE_STRICT 88 | dmax = state->dmax; 89 | #endif 90 | wsize = state->wsize; 91 | whave = state->whave; 92 | wnext = state->wnext; 93 | window = state->window; 94 | hold = state->hold; 95 | bits = state->bits; 96 | lcode = state->lencode; 97 | dcode = state->distcode; 98 | lmask = (1U << state->lenbits) - 1; 99 | dmask = (1U << state->distbits) - 1; 100 | 101 | /* decode literals and length/distances until end-of-block or not enough 102 | input data or output space */ 103 | do { 104 | if (bits < 15) { 105 | hold += (unsigned long)(*in++) << bits; 106 | bits += 8; 107 | hold += (unsigned long)(*in++) << bits; 108 | bits += 8; 109 | } 110 | here = lcode[hold & lmask]; 111 | dolen: 112 | op = (unsigned)(here.bits); 113 | hold >>= op; 114 | bits -= op; 115 | op = (unsigned)(here.op); 116 | if (op == 0) { /* literal */ 117 | Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? 118 | "inflate: literal '%c'\n" : 119 | "inflate: literal 0x%02x\n", here.val)); 120 | *out++ = (unsigned char)(here.val); 121 | } 122 | else if (op & 16) { /* length base */ 123 | len = (unsigned)(here.val); 124 | op &= 15; /* number of extra bits */ 125 | if (op) { 126 | if (bits < op) { 127 | hold += (unsigned long)(*in++) << bits; 128 | bits += 8; 129 | } 130 | len += (unsigned)hold & ((1U << op) - 1); 131 | hold >>= op; 132 | bits -= op; 133 | } 134 | Tracevv((stderr, "inflate: length %u\n", len)); 135 | if (bits < 15) { 136 | hold += (unsigned long)(*in++) << bits; 137 | bits += 8; 138 | hold += (unsigned long)(*in++) << bits; 139 | bits += 8; 140 | } 141 | here = dcode[hold & dmask]; 142 | dodist: 143 | op = (unsigned)(here.bits); 144 | hold >>= op; 145 | bits -= op; 146 | op = (unsigned)(here.op); 147 | if (op & 16) { /* distance base */ 148 | dist = (unsigned)(here.val); 149 | op &= 15; /* number of extra bits */ 150 | if (bits < op) { 151 | hold += (unsigned long)(*in++) << bits; 152 | bits += 8; 153 | if (bits < op) { 154 | hold += (unsigned long)(*in++) << bits; 155 | bits += 8; 156 | } 157 | } 158 | dist += (unsigned)hold & ((1U << op) - 1); 159 | #ifdef INFLATE_STRICT 160 | if (dist > dmax) { 161 | strm->msg = (char *)"invalid distance too far back"; 162 | state->mode = BAD; 163 | break; 164 | } 165 | #endif 166 | hold >>= op; 167 | bits -= op; 168 | Tracevv((stderr, "inflate: distance %u\n", dist)); 169 | op = (unsigned)(out - beg); /* max distance in output */ 170 | if (dist > op) { /* see if copy from window */ 171 | op = dist - op; /* distance back in window */ 172 | if (op > whave) { 173 | if (state->sane) { 174 | strm->msg = 175 | (char *)"invalid distance too far back"; 176 | state->mode = BAD; 177 | break; 178 | } 179 | #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR 180 | if (len <= op - whave) { 181 | do { 182 | *out++ = 0; 183 | } while (--len); 184 | continue; 185 | } 186 | len -= op - whave; 187 | do { 188 | *out++ = 0; 189 | } while (--op > whave); 190 | if (op == 0) { 191 | from = out - dist; 192 | do { 193 | *out++ = *from++; 194 | } while (--len); 195 | continue; 196 | } 197 | #endif 198 | } 199 | from = window; 200 | if (wnext == 0) { /* very common case */ 201 | from += wsize - op; 202 | if (op < len) { /* some from window */ 203 | len -= op; 204 | do { 205 | *out++ = *from++; 206 | } while (--op); 207 | from = out - dist; /* rest from output */ 208 | } 209 | } 210 | else if (wnext < op) { /* wrap around window */ 211 | from += wsize + wnext - op; 212 | op -= wnext; 213 | if (op < len) { /* some from end of window */ 214 | len -= op; 215 | do { 216 | *out++ = *from++; 217 | } while (--op); 218 | from = window; 219 | if (wnext < len) { /* some from start of window */ 220 | op = wnext; 221 | len -= op; 222 | do { 223 | *out++ = *from++; 224 | } while (--op); 225 | from = out - dist; /* rest from output */ 226 | } 227 | } 228 | } 229 | else { /* contiguous in window */ 230 | from += wnext - op; 231 | if (op < len) { /* some from window */ 232 | len -= op; 233 | do { 234 | *out++ = *from++; 235 | } while (--op); 236 | from = out - dist; /* rest from output */ 237 | } 238 | } 239 | while (len > 2) { 240 | *out++ = *from++; 241 | *out++ = *from++; 242 | *out++ = *from++; 243 | len -= 3; 244 | } 245 | if (len) { 246 | *out++ = *from++; 247 | if (len > 1) 248 | *out++ = *from++; 249 | } 250 | } 251 | else { 252 | from = out - dist; /* copy direct from output */ 253 | do { /* minimum length is three */ 254 | *out++ = *from++; 255 | *out++ = *from++; 256 | *out++ = *from++; 257 | len -= 3; 258 | } while (len > 2); 259 | if (len) { 260 | *out++ = *from++; 261 | if (len > 1) 262 | *out++ = *from++; 263 | } 264 | } 265 | } 266 | else if ((op & 64) == 0) { /* 2nd level distance code */ 267 | here = dcode[here.val + (hold & ((1U << op) - 1))]; 268 | goto dodist; 269 | } 270 | else { 271 | strm->msg = (char *)"invalid distance code"; 272 | state->mode = BAD; 273 | break; 274 | } 275 | } 276 | else if ((op & 64) == 0) { /* 2nd level length code */ 277 | here = lcode[here.val + (hold & ((1U << op) - 1))]; 278 | goto dolen; 279 | } 280 | else if (op & 32) { /* end-of-block */ 281 | Tracevv((stderr, "inflate: end of block\n")); 282 | state->mode = TYPE; 283 | break; 284 | } 285 | else { 286 | strm->msg = (char *)"invalid literal/length code"; 287 | state->mode = BAD; 288 | break; 289 | } 290 | } while (in < last && out < end); 291 | 292 | /* return unused bytes (on entry, bits < 8, so in won't go too far back) */ 293 | len = bits >> 3; 294 | in -= len; 295 | bits -= len << 3; 296 | hold &= (1U << bits) - 1; 297 | 298 | /* update state and return */ 299 | strm->next_in = in; 300 | strm->next_out = out; 301 | strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last)); 302 | strm->avail_out = (unsigned)(out < end ? 303 | 257 + (end - out) : 257 - (out - end)); 304 | state->hold = hold; 305 | state->bits = bits; 306 | return; 307 | } 308 | 309 | /* 310 | inflate_fast() speedups that turned out slower (on a PowerPC G3 750CXe): 311 | - Using bit fields for code structure 312 | - Different op definition to avoid & for extra bits (do & for table bits) 313 | - Three separate decoding do-loops for direct, window, and wnext == 0 314 | - Special case for distance > 1 copies to do overlapped load and store copy 315 | - Explicit branch predictions (based on measured branch probabilities) 316 | - Deferring match copy and interspersed it with decoding subsequent codes 317 | - Swapping literal/length else 318 | - Swapping window/direct else 319 | - Larger unrolled copy loops (three is about right) 320 | - Moving len -= 3 statement into middle of loop 321 | */ 322 | 323 | #endif /* !ASMINF */ 324 | -------------------------------------------------------------------------------- /ext/zlib/inffast.h: -------------------------------------------------------------------------------- 1 | /* inffast.h -- header to use inffast.c 2 | * Copyright (C) 1995-2003, 2010 Mark Adler 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | */ 5 | 6 | /* WARNING: this file should *not* be used by applications. It is 7 | part of the implementation of the compression library and is 8 | subject to change. Applications should only use zlib.h. 9 | */ 10 | 11 | void ZLIB_INTERNAL inflate_fast OF((z_streamp strm, unsigned start)); 12 | -------------------------------------------------------------------------------- /ext/zlib/inffixed.h: -------------------------------------------------------------------------------- 1 | /* inffixed.h -- table for decoding fixed codes 2 | * Generated automatically by makefixed(). 3 | */ 4 | 5 | /* WARNING: this file should *not* be used by applications. 6 | It is part of the implementation of this library and is 7 | subject to change. Applications should only use zlib.h. 8 | */ 9 | 10 | static const code lenfix[512] = { 11 | {96,7,0},{0,8,80},{0,8,16},{20,8,115},{18,7,31},{0,8,112},{0,8,48}, 12 | {0,9,192},{16,7,10},{0,8,96},{0,8,32},{0,9,160},{0,8,0},{0,8,128}, 13 | {0,8,64},{0,9,224},{16,7,6},{0,8,88},{0,8,24},{0,9,144},{19,7,59}, 14 | {0,8,120},{0,8,56},{0,9,208},{17,7,17},{0,8,104},{0,8,40},{0,9,176}, 15 | {0,8,8},{0,8,136},{0,8,72},{0,9,240},{16,7,4},{0,8,84},{0,8,20}, 16 | {21,8,227},{19,7,43},{0,8,116},{0,8,52},{0,9,200},{17,7,13},{0,8,100}, 17 | {0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},{16,7,8}, 18 | {0,8,92},{0,8,28},{0,9,152},{20,7,83},{0,8,124},{0,8,60},{0,9,216}, 19 | {18,7,23},{0,8,108},{0,8,44},{0,9,184},{0,8,12},{0,8,140},{0,8,76}, 20 | {0,9,248},{16,7,3},{0,8,82},{0,8,18},{21,8,163},{19,7,35},{0,8,114}, 21 | {0,8,50},{0,9,196},{17,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2}, 22 | {0,8,130},{0,8,66},{0,9,228},{16,7,7},{0,8,90},{0,8,26},{0,9,148}, 23 | {20,7,67},{0,8,122},{0,8,58},{0,9,212},{18,7,19},{0,8,106},{0,8,42}, 24 | {0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},{16,7,5},{0,8,86}, 25 | {0,8,22},{64,8,0},{19,7,51},{0,8,118},{0,8,54},{0,9,204},{17,7,15}, 26 | {0,8,102},{0,8,38},{0,9,172},{0,8,6},{0,8,134},{0,8,70},{0,9,236}, 27 | {16,7,9},{0,8,94},{0,8,30},{0,9,156},{20,7,99},{0,8,126},{0,8,62}, 28 | {0,9,220},{18,7,27},{0,8,110},{0,8,46},{0,9,188},{0,8,14},{0,8,142}, 29 | {0,8,78},{0,9,252},{96,7,0},{0,8,81},{0,8,17},{21,8,131},{18,7,31}, 30 | {0,8,113},{0,8,49},{0,9,194},{16,7,10},{0,8,97},{0,8,33},{0,9,162}, 31 | {0,8,1},{0,8,129},{0,8,65},{0,9,226},{16,7,6},{0,8,89},{0,8,25}, 32 | {0,9,146},{19,7,59},{0,8,121},{0,8,57},{0,9,210},{17,7,17},{0,8,105}, 33 | {0,8,41},{0,9,178},{0,8,9},{0,8,137},{0,8,73},{0,9,242},{16,7,4}, 34 | {0,8,85},{0,8,21},{16,8,258},{19,7,43},{0,8,117},{0,8,53},{0,9,202}, 35 | {17,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},{0,8,69}, 36 | {0,9,234},{16,7,8},{0,8,93},{0,8,29},{0,9,154},{20,7,83},{0,8,125}, 37 | {0,8,61},{0,9,218},{18,7,23},{0,8,109},{0,8,45},{0,9,186},{0,8,13}, 38 | {0,8,141},{0,8,77},{0,9,250},{16,7,3},{0,8,83},{0,8,19},{21,8,195}, 39 | {19,7,35},{0,8,115},{0,8,51},{0,9,198},{17,7,11},{0,8,99},{0,8,35}, 40 | {0,9,166},{0,8,3},{0,8,131},{0,8,67},{0,9,230},{16,7,7},{0,8,91}, 41 | {0,8,27},{0,9,150},{20,7,67},{0,8,123},{0,8,59},{0,9,214},{18,7,19}, 42 | {0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},{0,8,75},{0,9,246}, 43 | {16,7,5},{0,8,87},{0,8,23},{64,8,0},{19,7,51},{0,8,119},{0,8,55}, 44 | {0,9,206},{17,7,15},{0,8,103},{0,8,39},{0,9,174},{0,8,7},{0,8,135}, 45 | {0,8,71},{0,9,238},{16,7,9},{0,8,95},{0,8,31},{0,9,158},{20,7,99}, 46 | {0,8,127},{0,8,63},{0,9,222},{18,7,27},{0,8,111},{0,8,47},{0,9,190}, 47 | {0,8,15},{0,8,143},{0,8,79},{0,9,254},{96,7,0},{0,8,80},{0,8,16}, 48 | {20,8,115},{18,7,31},{0,8,112},{0,8,48},{0,9,193},{16,7,10},{0,8,96}, 49 | {0,8,32},{0,9,161},{0,8,0},{0,8,128},{0,8,64},{0,9,225},{16,7,6}, 50 | {0,8,88},{0,8,24},{0,9,145},{19,7,59},{0,8,120},{0,8,56},{0,9,209}, 51 | {17,7,17},{0,8,104},{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72}, 52 | {0,9,241},{16,7,4},{0,8,84},{0,8,20},{21,8,227},{19,7,43},{0,8,116}, 53 | {0,8,52},{0,9,201},{17,7,13},{0,8,100},{0,8,36},{0,9,169},{0,8,4}, 54 | {0,8,132},{0,8,68},{0,9,233},{16,7,8},{0,8,92},{0,8,28},{0,9,153}, 55 | {20,7,83},{0,8,124},{0,8,60},{0,9,217},{18,7,23},{0,8,108},{0,8,44}, 56 | {0,9,185},{0,8,12},{0,8,140},{0,8,76},{0,9,249},{16,7,3},{0,8,82}, 57 | {0,8,18},{21,8,163},{19,7,35},{0,8,114},{0,8,50},{0,9,197},{17,7,11}, 58 | {0,8,98},{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229}, 59 | {16,7,7},{0,8,90},{0,8,26},{0,9,149},{20,7,67},{0,8,122},{0,8,58}, 60 | {0,9,213},{18,7,19},{0,8,106},{0,8,42},{0,9,181},{0,8,10},{0,8,138}, 61 | {0,8,74},{0,9,245},{16,7,5},{0,8,86},{0,8,22},{64,8,0},{19,7,51}, 62 | {0,8,118},{0,8,54},{0,9,205},{17,7,15},{0,8,102},{0,8,38},{0,9,173}, 63 | {0,8,6},{0,8,134},{0,8,70},{0,9,237},{16,7,9},{0,8,94},{0,8,30}, 64 | {0,9,157},{20,7,99},{0,8,126},{0,8,62},{0,9,221},{18,7,27},{0,8,110}, 65 | {0,8,46},{0,9,189},{0,8,14},{0,8,142},{0,8,78},{0,9,253},{96,7,0}, 66 | {0,8,81},{0,8,17},{21,8,131},{18,7,31},{0,8,113},{0,8,49},{0,9,195}, 67 | {16,7,10},{0,8,97},{0,8,33},{0,9,163},{0,8,1},{0,8,129},{0,8,65}, 68 | {0,9,227},{16,7,6},{0,8,89},{0,8,25},{0,9,147},{19,7,59},{0,8,121}, 69 | {0,8,57},{0,9,211},{17,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9}, 70 | {0,8,137},{0,8,73},{0,9,243},{16,7,4},{0,8,85},{0,8,21},{16,8,258}, 71 | {19,7,43},{0,8,117},{0,8,53},{0,9,203},{17,7,13},{0,8,101},{0,8,37}, 72 | {0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},{16,7,8},{0,8,93}, 73 | {0,8,29},{0,9,155},{20,7,83},{0,8,125},{0,8,61},{0,9,219},{18,7,23}, 74 | {0,8,109},{0,8,45},{0,9,187},{0,8,13},{0,8,141},{0,8,77},{0,9,251}, 75 | {16,7,3},{0,8,83},{0,8,19},{21,8,195},{19,7,35},{0,8,115},{0,8,51}, 76 | {0,9,199},{17,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131}, 77 | {0,8,67},{0,9,231},{16,7,7},{0,8,91},{0,8,27},{0,9,151},{20,7,67}, 78 | {0,8,123},{0,8,59},{0,9,215},{18,7,19},{0,8,107},{0,8,43},{0,9,183}, 79 | {0,8,11},{0,8,139},{0,8,75},{0,9,247},{16,7,5},{0,8,87},{0,8,23}, 80 | {64,8,0},{19,7,51},{0,8,119},{0,8,55},{0,9,207},{17,7,15},{0,8,103}, 81 | {0,8,39},{0,9,175},{0,8,7},{0,8,135},{0,8,71},{0,9,239},{16,7,9}, 82 | {0,8,95},{0,8,31},{0,9,159},{20,7,99},{0,8,127},{0,8,63},{0,9,223}, 83 | {18,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},{0,8,79}, 84 | {0,9,255} 85 | }; 86 | 87 | static const code distfix[32] = { 88 | {16,5,1},{23,5,257},{19,5,17},{27,5,4097},{17,5,5},{25,5,1025}, 89 | {21,5,65},{29,5,16385},{16,5,3},{24,5,513},{20,5,33},{28,5,8193}, 90 | {18,5,9},{26,5,2049},{22,5,129},{64,5,0},{16,5,2},{23,5,385}, 91 | {19,5,25},{27,5,6145},{17,5,7},{25,5,1537},{21,5,97},{29,5,24577}, 92 | {16,5,4},{24,5,769},{20,5,49},{28,5,12289},{18,5,13},{26,5,3073}, 93 | {22,5,193},{64,5,0} 94 | }; 95 | -------------------------------------------------------------------------------- /ext/zlib/inflate.h: -------------------------------------------------------------------------------- 1 | /* inflate.h -- internal inflate state definition 2 | * Copyright (C) 1995-2016 Mark Adler 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | */ 5 | 6 | /* WARNING: this file should *not* be used by applications. It is 7 | part of the implementation of the compression library and is 8 | subject to change. Applications should only use zlib.h. 9 | */ 10 | 11 | /* define NO_GZIP when compiling if you want to disable gzip header and 12 | trailer decoding by inflate(). NO_GZIP would be used to avoid linking in 13 | the crc code when it is not needed. For shared libraries, gzip decoding 14 | should be left enabled. */ 15 | #ifndef NO_GZIP 16 | # define GUNZIP 17 | #endif 18 | 19 | /* Possible inflate modes between inflate() calls */ 20 | typedef enum { 21 | HEAD = 16180, /* i: waiting for magic header */ 22 | FLAGS, /* i: waiting for method and flags (gzip) */ 23 | TIME, /* i: waiting for modification time (gzip) */ 24 | OS, /* i: waiting for extra flags and operating system (gzip) */ 25 | EXLEN, /* i: waiting for extra length (gzip) */ 26 | EXTRA, /* i: waiting for extra bytes (gzip) */ 27 | NAME, /* i: waiting for end of file name (gzip) */ 28 | COMMENT, /* i: waiting for end of comment (gzip) */ 29 | HCRC, /* i: waiting for header crc (gzip) */ 30 | DICTID, /* i: waiting for dictionary check value */ 31 | DICT, /* waiting for inflateSetDictionary() call */ 32 | TYPE, /* i: waiting for type bits, including last-flag bit */ 33 | TYPEDO, /* i: same, but skip check to exit inflate on new block */ 34 | STORED, /* i: waiting for stored size (length and complement) */ 35 | COPY_, /* i/o: same as COPY below, but only first time in */ 36 | COPY, /* i/o: waiting for input or output to copy stored block */ 37 | TABLE, /* i: waiting for dynamic block table lengths */ 38 | LENLENS, /* i: waiting for code length code lengths */ 39 | CODELENS, /* i: waiting for length/lit and distance code lengths */ 40 | LEN_, /* i: same as LEN below, but only first time in */ 41 | LEN, /* i: waiting for length/lit/eob code */ 42 | LENEXT, /* i: waiting for length extra bits */ 43 | DIST, /* i: waiting for distance code */ 44 | DISTEXT, /* i: waiting for distance extra bits */ 45 | MATCH, /* o: waiting for output space to copy string */ 46 | LIT, /* o: waiting for output space to write literal */ 47 | CHECK, /* i: waiting for 32-bit check value */ 48 | LENGTH, /* i: waiting for 32-bit length (gzip) */ 49 | DONE, /* finished check, done -- remain here until reset */ 50 | BAD, /* got a data error -- remain here until reset */ 51 | MEM, /* got an inflate() memory error -- remain here until reset */ 52 | SYNC /* looking for synchronization bytes to restart inflate() */ 53 | } inflate_mode; 54 | 55 | /* 56 | State transitions between above modes - 57 | 58 | (most modes can go to BAD or MEM on error -- not shown for clarity) 59 | 60 | Process header: 61 | HEAD -> (gzip) or (zlib) or (raw) 62 | (gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME -> COMMENT -> 63 | HCRC -> TYPE 64 | (zlib) -> DICTID or TYPE 65 | DICTID -> DICT -> TYPE 66 | (raw) -> TYPEDO 67 | Read deflate blocks: 68 | TYPE -> TYPEDO -> STORED or TABLE or LEN_ or CHECK 69 | STORED -> COPY_ -> COPY -> TYPE 70 | TABLE -> LENLENS -> CODELENS -> LEN_ 71 | LEN_ -> LEN 72 | Read deflate codes in fixed or dynamic block: 73 | LEN -> LENEXT or LIT or TYPE 74 | LENEXT -> DIST -> DISTEXT -> MATCH -> LEN 75 | LIT -> LEN 76 | Process trailer: 77 | CHECK -> LENGTH -> DONE 78 | */ 79 | 80 | /* State maintained between inflate() calls -- approximately 7K bytes, not 81 | including the allocated sliding window, which is up to 32K bytes. */ 82 | struct inflate_state { 83 | z_streamp strm; /* pointer back to this zlib stream */ 84 | inflate_mode mode; /* current inflate mode */ 85 | int last; /* true if processing last block */ 86 | int wrap; /* bit 0 true for zlib, bit 1 true for gzip, 87 | bit 2 true to validate check value */ 88 | int havedict; /* true if dictionary provided */ 89 | int flags; /* gzip header method and flags (0 if zlib) */ 90 | unsigned dmax; /* zlib header max distance (INFLATE_STRICT) */ 91 | unsigned long check; /* protected copy of check value */ 92 | unsigned long total; /* protected copy of output count */ 93 | gz_headerp head; /* where to save gzip header information */ 94 | /* sliding window */ 95 | unsigned wbits; /* log base 2 of requested window size */ 96 | unsigned wsize; /* window size or zero if not using window */ 97 | unsigned whave; /* valid bytes in the window */ 98 | unsigned wnext; /* window write index */ 99 | unsigned char FAR *window; /* allocated sliding window, if needed */ 100 | /* bit accumulator */ 101 | unsigned long hold; /* input bit accumulator */ 102 | unsigned bits; /* number of bits in "in" */ 103 | /* for string and stored block copying */ 104 | unsigned length; /* literal or length of data to copy */ 105 | unsigned offset; /* distance back to copy string from */ 106 | /* for table and code decoding */ 107 | unsigned extra; /* extra bits needed */ 108 | /* fixed and dynamic code tables */ 109 | code const FAR *lencode; /* starting table for length/literal codes */ 110 | code const FAR *distcode; /* starting table for distance codes */ 111 | unsigned lenbits; /* index bits for lencode */ 112 | unsigned distbits; /* index bits for distcode */ 113 | /* dynamic table building */ 114 | unsigned ncode; /* number of code length code lengths */ 115 | unsigned nlen; /* number of length code lengths */ 116 | unsigned ndist; /* number of distance code lengths */ 117 | unsigned have; /* number of code lengths in lens[] */ 118 | code FAR *next; /* next available space in codes[] */ 119 | unsigned short lens[320]; /* temporary storage for code lengths */ 120 | unsigned short work[288]; /* work area for code table building */ 121 | code codes[ENOUGH]; /* space for code tables */ 122 | int sane; /* if false, allow invalid distance too far */ 123 | int back; /* bits back of last unprocessed length/lit */ 124 | unsigned was; /* initial length of match */ 125 | }; 126 | -------------------------------------------------------------------------------- /ext/zlib/inftrees.c: -------------------------------------------------------------------------------- 1 | /* inftrees.c -- generate Huffman trees for efficient decoding 2 | * Copyright (C) 1995-2017 Mark Adler 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | */ 5 | 6 | #include "zutil.h" 7 | #include "inftrees.h" 8 | 9 | #define MAXBITS 15 10 | 11 | const char inflate_copyright[] = 12 | " inflate 1.2.11 Copyright 1995-2017 Mark Adler "; 13 | /* 14 | If you use the zlib library in a product, an acknowledgment is welcome 15 | in the documentation of your product. If for some reason you cannot 16 | include such an acknowledgment, I would appreciate that you keep this 17 | copyright string in the executable of your product. 18 | */ 19 | 20 | /* 21 | Build a set of tables to decode the provided canonical Huffman code. 22 | The code lengths are lens[0..codes-1]. The result starts at *table, 23 | whose indices are 0..2^bits-1. work is a writable array of at least 24 | lens shorts, which is used as a work area. type is the type of code 25 | to be generated, CODES, LENS, or DISTS. On return, zero is success, 26 | -1 is an invalid code, and +1 means that ENOUGH isn't enough. table 27 | on return points to the next available entry's address. bits is the 28 | requested root table index bits, and on return it is the actual root 29 | table index bits. It will differ if the request is greater than the 30 | longest code or if it is less than the shortest code. 31 | */ 32 | int ZLIB_INTERNAL inflate_table(type, lens, codes, table, bits, work) 33 | codetype type; 34 | unsigned short FAR *lens; 35 | unsigned codes; 36 | code FAR * FAR *table; 37 | unsigned FAR *bits; 38 | unsigned short FAR *work; 39 | { 40 | unsigned len; /* a code's length in bits */ 41 | unsigned sym; /* index of code symbols */ 42 | unsigned min, max; /* minimum and maximum code lengths */ 43 | unsigned root; /* number of index bits for root table */ 44 | unsigned curr; /* number of index bits for current table */ 45 | unsigned drop; /* code bits to drop for sub-table */ 46 | int left; /* number of prefix codes available */ 47 | unsigned used; /* code entries in table used */ 48 | unsigned huff; /* Huffman code */ 49 | unsigned incr; /* for incrementing code, index */ 50 | unsigned fill; /* index for replicating entries */ 51 | unsigned low; /* low bits for current root entry */ 52 | unsigned mask; /* mask for low root bits */ 53 | code here; /* table entry for duplication */ 54 | code FAR *next; /* next available space in table */ 55 | const unsigned short FAR *base; /* base value table to use */ 56 | const unsigned short FAR *extra; /* extra bits table to use */ 57 | unsigned match; /* use base and extra for symbol >= match */ 58 | unsigned short count[MAXBITS+1]; /* number of codes of each length */ 59 | unsigned short offs[MAXBITS+1]; /* offsets in table for each length */ 60 | static const unsigned short lbase[31] = { /* Length codes 257..285 base */ 61 | 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 62 | 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0}; 63 | static const unsigned short lext[31] = { /* Length codes 257..285 extra */ 64 | 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, 65 | 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 77, 202}; 66 | static const unsigned short dbase[32] = { /* Distance codes 0..29 base */ 67 | 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 68 | 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 69 | 8193, 12289, 16385, 24577, 0, 0}; 70 | static const unsigned short dext[32] = { /* Distance codes 0..29 extra */ 71 | 16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 72 | 23, 23, 24, 24, 25, 25, 26, 26, 27, 27, 73 | 28, 28, 29, 29, 64, 64}; 74 | 75 | /* 76 | Process a set of code lengths to create a canonical Huffman code. The 77 | code lengths are lens[0..codes-1]. Each length corresponds to the 78 | symbols 0..codes-1. The Huffman code is generated by first sorting the 79 | symbols by length from short to long, and retaining the symbol order 80 | for codes with equal lengths. Then the code starts with all zero bits 81 | for the first code of the shortest length, and the codes are integer 82 | increments for the same length, and zeros are appended as the length 83 | increases. For the deflate format, these bits are stored backwards 84 | from their more natural integer increment ordering, and so when the 85 | decoding tables are built in the large loop below, the integer codes 86 | are incremented backwards. 87 | 88 | This routine assumes, but does not check, that all of the entries in 89 | lens[] are in the range 0..MAXBITS. The caller must assure this. 90 | 1..MAXBITS is interpreted as that code length. zero means that that 91 | symbol does not occur in this code. 92 | 93 | The codes are sorted by computing a count of codes for each length, 94 | creating from that a table of starting indices for each length in the 95 | sorted table, and then entering the symbols in order in the sorted 96 | table. The sorted table is work[], with that space being provided by 97 | the caller. 98 | 99 | The length counts are used for other purposes as well, i.e. finding 100 | the minimum and maximum length codes, determining if there are any 101 | codes at all, checking for a valid set of lengths, and looking ahead 102 | at length counts to determine sub-table sizes when building the 103 | decoding tables. 104 | */ 105 | 106 | /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */ 107 | for (len = 0; len <= MAXBITS; len++) 108 | count[len] = 0; 109 | for (sym = 0; sym < codes; sym++) 110 | count[lens[sym]]++; 111 | 112 | /* bound code lengths, force root to be within code lengths */ 113 | root = *bits; 114 | for (max = MAXBITS; max >= 1; max--) 115 | if (count[max] != 0) break; 116 | if (root > max) root = max; 117 | if (max == 0) { /* no symbols to code at all */ 118 | here.op = (unsigned char)64; /* invalid code marker */ 119 | here.bits = (unsigned char)1; 120 | here.val = (unsigned short)0; 121 | *(*table)++ = here; /* make a table to force an error */ 122 | *(*table)++ = here; 123 | *bits = 1; 124 | return 0; /* no symbols, but wait for decoding to report error */ 125 | } 126 | for (min = 1; min < max; min++) 127 | if (count[min] != 0) break; 128 | if (root < min) root = min; 129 | 130 | /* check for an over-subscribed or incomplete set of lengths */ 131 | left = 1; 132 | for (len = 1; len <= MAXBITS; len++) { 133 | left <<= 1; 134 | left -= count[len]; 135 | if (left < 0) return -1; /* over-subscribed */ 136 | } 137 | if (left > 0 && (type == CODES || max != 1)) 138 | return -1; /* incomplete set */ 139 | 140 | /* generate offsets into symbol table for each length for sorting */ 141 | offs[1] = 0; 142 | for (len = 1; len < MAXBITS; len++) 143 | offs[len + 1] = offs[len] + count[len]; 144 | 145 | /* sort symbols by length, by symbol order within each length */ 146 | for (sym = 0; sym < codes; sym++) 147 | if (lens[sym] != 0) work[offs[lens[sym]]++] = (unsigned short)sym; 148 | 149 | /* 150 | Create and fill in decoding tables. In this loop, the table being 151 | filled is at next and has curr index bits. The code being used is huff 152 | with length len. That code is converted to an index by dropping drop 153 | bits off of the bottom. For codes where len is less than drop + curr, 154 | those top drop + curr - len bits are incremented through all values to 155 | fill the table with replicated entries. 156 | 157 | root is the number of index bits for the root table. When len exceeds 158 | root, sub-tables are created pointed to by the root entry with an index 159 | of the low root bits of huff. This is saved in low to check for when a 160 | new sub-table should be started. drop is zero when the root table is 161 | being filled, and drop is root when sub-tables are being filled. 162 | 163 | When a new sub-table is needed, it is necessary to look ahead in the 164 | code lengths to determine what size sub-table is needed. The length 165 | counts are used for this, and so count[] is decremented as codes are 166 | entered in the tables. 167 | 168 | used keeps track of how many table entries have been allocated from the 169 | provided *table space. It is checked for LENS and DIST tables against 170 | the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in 171 | the initial root table size constants. See the comments in inftrees.h 172 | for more information. 173 | 174 | sym increments through all symbols, and the loop terminates when 175 | all codes of length max, i.e. all codes, have been processed. This 176 | routine permits incomplete codes, so another loop after this one fills 177 | in the rest of the decoding tables with invalid code markers. 178 | */ 179 | 180 | /* set up for code type */ 181 | switch (type) { 182 | case CODES: 183 | base = extra = work; /* dummy value--not used */ 184 | match = 20; 185 | break; 186 | case LENS: 187 | base = lbase; 188 | extra = lext; 189 | match = 257; 190 | break; 191 | default: /* DISTS */ 192 | base = dbase; 193 | extra = dext; 194 | match = 0; 195 | } 196 | 197 | /* initialize state for loop */ 198 | huff = 0; /* starting code */ 199 | sym = 0; /* starting code symbol */ 200 | len = min; /* starting code length */ 201 | next = *table; /* current table to fill in */ 202 | curr = root; /* current table index bits */ 203 | drop = 0; /* current bits to drop from code for index */ 204 | low = (unsigned)(-1); /* trigger new sub-table when len > root */ 205 | used = 1U << root; /* use root table entries */ 206 | mask = used - 1; /* mask for comparing low */ 207 | 208 | /* check available table space */ 209 | if ((type == LENS && used > ENOUGH_LENS) || 210 | (type == DISTS && used > ENOUGH_DISTS)) 211 | return 1; 212 | 213 | /* process all codes and make table entries */ 214 | for (;;) { 215 | /* create table entry */ 216 | here.bits = (unsigned char)(len - drop); 217 | if (work[sym] + 1U < match) { 218 | here.op = (unsigned char)0; 219 | here.val = work[sym]; 220 | } 221 | else if (work[sym] >= match) { 222 | here.op = (unsigned char)(extra[work[sym] - match]); 223 | here.val = base[work[sym] - match]; 224 | } 225 | else { 226 | here.op = (unsigned char)(32 + 64); /* end of block */ 227 | here.val = 0; 228 | } 229 | 230 | /* replicate for those indices with low len bits equal to huff */ 231 | incr = 1U << (len - drop); 232 | fill = 1U << curr; 233 | min = fill; /* save offset to next table */ 234 | do { 235 | fill -= incr; 236 | next[(huff >> drop) + fill] = here; 237 | } while (fill != 0); 238 | 239 | /* backwards increment the len-bit code huff */ 240 | incr = 1U << (len - 1); 241 | while (huff & incr) 242 | incr >>= 1; 243 | if (incr != 0) { 244 | huff &= incr - 1; 245 | huff += incr; 246 | } 247 | else 248 | huff = 0; 249 | 250 | /* go to next symbol, update count, len */ 251 | sym++; 252 | if (--(count[len]) == 0) { 253 | if (len == max) break; 254 | len = lens[work[sym]]; 255 | } 256 | 257 | /* create new sub-table if needed */ 258 | if (len > root && (huff & mask) != low) { 259 | /* if first time, transition to sub-tables */ 260 | if (drop == 0) 261 | drop = root; 262 | 263 | /* increment past last table */ 264 | next += min; /* here min is 1 << curr */ 265 | 266 | /* determine length of next table */ 267 | curr = len - drop; 268 | left = (int)(1 << curr); 269 | while (curr + drop < max) { 270 | left -= count[curr + drop]; 271 | if (left <= 0) break; 272 | curr++; 273 | left <<= 1; 274 | } 275 | 276 | /* check for enough space */ 277 | used += 1U << curr; 278 | if ((type == LENS && used > ENOUGH_LENS) || 279 | (type == DISTS && used > ENOUGH_DISTS)) 280 | return 1; 281 | 282 | /* point entry in root table to sub-table */ 283 | low = huff & mask; 284 | (*table)[low].op = (unsigned char)curr; 285 | (*table)[low].bits = (unsigned char)root; 286 | (*table)[low].val = (unsigned short)(next - *table); 287 | } 288 | } 289 | 290 | /* fill in remaining table entry if code is incomplete (guaranteed to have 291 | at most one remaining entry, since if the code is incomplete, the 292 | maximum code length that was allowed to get this far is one bit) */ 293 | if (huff != 0) { 294 | here.op = (unsigned char)64; /* invalid code marker */ 295 | here.bits = (unsigned char)(len - drop); 296 | here.val = (unsigned short)0; 297 | next[huff] = here; 298 | } 299 | 300 | /* set return parameters */ 301 | *table += used; 302 | *bits = root; 303 | return 0; 304 | } 305 | -------------------------------------------------------------------------------- /ext/zlib/inftrees.h: -------------------------------------------------------------------------------- 1 | /* inftrees.h -- header to use inftrees.c 2 | * Copyright (C) 1995-2005, 2010 Mark Adler 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | */ 5 | 6 | /* WARNING: this file should *not* be used by applications. It is 7 | part of the implementation of the compression library and is 8 | subject to change. Applications should only use zlib.h. 9 | */ 10 | 11 | /* Structure for decoding tables. Each entry provides either the 12 | information needed to do the operation requested by the code that 13 | indexed that table entry, or it provides a pointer to another 14 | table that indexes more bits of the code. op indicates whether 15 | the entry is a pointer to another table, a literal, a length or 16 | distance, an end-of-block, or an invalid code. For a table 17 | pointer, the low four bits of op is the number of index bits of 18 | that table. For a length or distance, the low four bits of op 19 | is the number of extra bits to get after the code. bits is 20 | the number of bits in this code or part of the code to drop off 21 | of the bit buffer. val is the actual byte to output in the case 22 | of a literal, the base length or distance, or the offset from 23 | the current table to the next table. Each entry is four bytes. */ 24 | typedef struct { 25 | unsigned char op; /* operation, extra bits, table bits */ 26 | unsigned char bits; /* bits in this part of the code */ 27 | unsigned short val; /* offset in table or code value */ 28 | } code; 29 | 30 | /* op values as set by inflate_table(): 31 | 00000000 - literal 32 | 0000tttt - table link, tttt != 0 is the number of table index bits 33 | 0001eeee - length or distance, eeee is the number of extra bits 34 | 01100000 - end of block 35 | 01000000 - invalid code 36 | */ 37 | 38 | /* Maximum size of the dynamic table. The maximum number of code structures is 39 | 1444, which is the sum of 852 for literal/length codes and 592 for distance 40 | codes. These values were found by exhaustive searches using the program 41 | examples/enough.c found in the zlib distribtution. The arguments to that 42 | program are the number of symbols, the initial root table size, and the 43 | maximum bit length of a code. "enough 286 9 15" for literal/length codes 44 | returns returns 852, and "enough 30 6 15" for distance codes returns 592. 45 | The initial root table size (9 or 6) is found in the fifth argument of the 46 | inflate_table() calls in inflate.c and infback.c. If the root table size is 47 | changed, then these maximum sizes would be need to be recalculated and 48 | updated. */ 49 | #define ENOUGH_LENS 852 50 | #define ENOUGH_DISTS 592 51 | #define ENOUGH (ENOUGH_LENS+ENOUGH_DISTS) 52 | 53 | /* Type of code to build for inflate_table() */ 54 | typedef enum { 55 | CODES, 56 | LENS, 57 | DISTS 58 | } codetype; 59 | 60 | int ZLIB_INTERNAL inflate_table OF((codetype type, unsigned short FAR *lens, 61 | unsigned codes, code FAR * FAR *table, 62 | unsigned FAR *bits, unsigned short FAR *work)); 63 | -------------------------------------------------------------------------------- /ext/zlib/trees.h: -------------------------------------------------------------------------------- 1 | /* header created automatically with -DGEN_TREES_H */ 2 | 3 | local const ct_data static_ltree[L_CODES+2] = { 4 | {{ 12},{ 8}}, {{140},{ 8}}, {{ 76},{ 8}}, {{204},{ 8}}, {{ 44},{ 8}}, 5 | {{172},{ 8}}, {{108},{ 8}}, {{236},{ 8}}, {{ 28},{ 8}}, {{156},{ 8}}, 6 | {{ 92},{ 8}}, {{220},{ 8}}, {{ 60},{ 8}}, {{188},{ 8}}, {{124},{ 8}}, 7 | {{252},{ 8}}, {{ 2},{ 8}}, {{130},{ 8}}, {{ 66},{ 8}}, {{194},{ 8}}, 8 | {{ 34},{ 8}}, {{162},{ 8}}, {{ 98},{ 8}}, {{226},{ 8}}, {{ 18},{ 8}}, 9 | {{146},{ 8}}, {{ 82},{ 8}}, {{210},{ 8}}, {{ 50},{ 8}}, {{178},{ 8}}, 10 | {{114},{ 8}}, {{242},{ 8}}, {{ 10},{ 8}}, {{138},{ 8}}, {{ 74},{ 8}}, 11 | {{202},{ 8}}, {{ 42},{ 8}}, {{170},{ 8}}, {{106},{ 8}}, {{234},{ 8}}, 12 | {{ 26},{ 8}}, {{154},{ 8}}, {{ 90},{ 8}}, {{218},{ 8}}, {{ 58},{ 8}}, 13 | {{186},{ 8}}, {{122},{ 8}}, {{250},{ 8}}, {{ 6},{ 8}}, {{134},{ 8}}, 14 | {{ 70},{ 8}}, {{198},{ 8}}, {{ 38},{ 8}}, {{166},{ 8}}, {{102},{ 8}}, 15 | {{230},{ 8}}, {{ 22},{ 8}}, {{150},{ 8}}, {{ 86},{ 8}}, {{214},{ 8}}, 16 | {{ 54},{ 8}}, {{182},{ 8}}, {{118},{ 8}}, {{246},{ 8}}, {{ 14},{ 8}}, 17 | {{142},{ 8}}, {{ 78},{ 8}}, {{206},{ 8}}, {{ 46},{ 8}}, {{174},{ 8}}, 18 | {{110},{ 8}}, {{238},{ 8}}, {{ 30},{ 8}}, {{158},{ 8}}, {{ 94},{ 8}}, 19 | {{222},{ 8}}, {{ 62},{ 8}}, {{190},{ 8}}, {{126},{ 8}}, {{254},{ 8}}, 20 | {{ 1},{ 8}}, {{129},{ 8}}, {{ 65},{ 8}}, {{193},{ 8}}, {{ 33},{ 8}}, 21 | {{161},{ 8}}, {{ 97},{ 8}}, {{225},{ 8}}, {{ 17},{ 8}}, {{145},{ 8}}, 22 | {{ 81},{ 8}}, {{209},{ 8}}, {{ 49},{ 8}}, {{177},{ 8}}, {{113},{ 8}}, 23 | {{241},{ 8}}, {{ 9},{ 8}}, {{137},{ 8}}, {{ 73},{ 8}}, {{201},{ 8}}, 24 | {{ 41},{ 8}}, {{169},{ 8}}, {{105},{ 8}}, {{233},{ 8}}, {{ 25},{ 8}}, 25 | {{153},{ 8}}, {{ 89},{ 8}}, {{217},{ 8}}, {{ 57},{ 8}}, {{185},{ 8}}, 26 | {{121},{ 8}}, {{249},{ 8}}, {{ 5},{ 8}}, {{133},{ 8}}, {{ 69},{ 8}}, 27 | {{197},{ 8}}, {{ 37},{ 8}}, {{165},{ 8}}, {{101},{ 8}}, {{229},{ 8}}, 28 | {{ 21},{ 8}}, {{149},{ 8}}, {{ 85},{ 8}}, {{213},{ 8}}, {{ 53},{ 8}}, 29 | {{181},{ 8}}, {{117},{ 8}}, {{245},{ 8}}, {{ 13},{ 8}}, {{141},{ 8}}, 30 | {{ 77},{ 8}}, {{205},{ 8}}, {{ 45},{ 8}}, {{173},{ 8}}, {{109},{ 8}}, 31 | {{237},{ 8}}, {{ 29},{ 8}}, {{157},{ 8}}, {{ 93},{ 8}}, {{221},{ 8}}, 32 | {{ 61},{ 8}}, {{189},{ 8}}, {{125},{ 8}}, {{253},{ 8}}, {{ 19},{ 9}}, 33 | {{275},{ 9}}, {{147},{ 9}}, {{403},{ 9}}, {{ 83},{ 9}}, {{339},{ 9}}, 34 | {{211},{ 9}}, {{467},{ 9}}, {{ 51},{ 9}}, {{307},{ 9}}, {{179},{ 9}}, 35 | {{435},{ 9}}, {{115},{ 9}}, {{371},{ 9}}, {{243},{ 9}}, {{499},{ 9}}, 36 | {{ 11},{ 9}}, {{267},{ 9}}, {{139},{ 9}}, {{395},{ 9}}, {{ 75},{ 9}}, 37 | {{331},{ 9}}, {{203},{ 9}}, {{459},{ 9}}, {{ 43},{ 9}}, {{299},{ 9}}, 38 | {{171},{ 9}}, {{427},{ 9}}, {{107},{ 9}}, {{363},{ 9}}, {{235},{ 9}}, 39 | {{491},{ 9}}, {{ 27},{ 9}}, {{283},{ 9}}, {{155},{ 9}}, {{411},{ 9}}, 40 | {{ 91},{ 9}}, {{347},{ 9}}, {{219},{ 9}}, {{475},{ 9}}, {{ 59},{ 9}}, 41 | {{315},{ 9}}, {{187},{ 9}}, {{443},{ 9}}, {{123},{ 9}}, {{379},{ 9}}, 42 | {{251},{ 9}}, {{507},{ 9}}, {{ 7},{ 9}}, {{263},{ 9}}, {{135},{ 9}}, 43 | {{391},{ 9}}, {{ 71},{ 9}}, {{327},{ 9}}, {{199},{ 9}}, {{455},{ 9}}, 44 | {{ 39},{ 9}}, {{295},{ 9}}, {{167},{ 9}}, {{423},{ 9}}, {{103},{ 9}}, 45 | {{359},{ 9}}, {{231},{ 9}}, {{487},{ 9}}, {{ 23},{ 9}}, {{279},{ 9}}, 46 | {{151},{ 9}}, {{407},{ 9}}, {{ 87},{ 9}}, {{343},{ 9}}, {{215},{ 9}}, 47 | {{471},{ 9}}, {{ 55},{ 9}}, {{311},{ 9}}, {{183},{ 9}}, {{439},{ 9}}, 48 | {{119},{ 9}}, {{375},{ 9}}, {{247},{ 9}}, {{503},{ 9}}, {{ 15},{ 9}}, 49 | {{271},{ 9}}, {{143},{ 9}}, {{399},{ 9}}, {{ 79},{ 9}}, {{335},{ 9}}, 50 | {{207},{ 9}}, {{463},{ 9}}, {{ 47},{ 9}}, {{303},{ 9}}, {{175},{ 9}}, 51 | {{431},{ 9}}, {{111},{ 9}}, {{367},{ 9}}, {{239},{ 9}}, {{495},{ 9}}, 52 | {{ 31},{ 9}}, {{287},{ 9}}, {{159},{ 9}}, {{415},{ 9}}, {{ 95},{ 9}}, 53 | {{351},{ 9}}, {{223},{ 9}}, {{479},{ 9}}, {{ 63},{ 9}}, {{319},{ 9}}, 54 | {{191},{ 9}}, {{447},{ 9}}, {{127},{ 9}}, {{383},{ 9}}, {{255},{ 9}}, 55 | {{511},{ 9}}, {{ 0},{ 7}}, {{ 64},{ 7}}, {{ 32},{ 7}}, {{ 96},{ 7}}, 56 | {{ 16},{ 7}}, {{ 80},{ 7}}, {{ 48},{ 7}}, {{112},{ 7}}, {{ 8},{ 7}}, 57 | {{ 72},{ 7}}, {{ 40},{ 7}}, {{104},{ 7}}, {{ 24},{ 7}}, {{ 88},{ 7}}, 58 | {{ 56},{ 7}}, {{120},{ 7}}, {{ 4},{ 7}}, {{ 68},{ 7}}, {{ 36},{ 7}}, 59 | {{100},{ 7}}, {{ 20},{ 7}}, {{ 84},{ 7}}, {{ 52},{ 7}}, {{116},{ 7}}, 60 | {{ 3},{ 8}}, {{131},{ 8}}, {{ 67},{ 8}}, {{195},{ 8}}, {{ 35},{ 8}}, 61 | {{163},{ 8}}, {{ 99},{ 8}}, {{227},{ 8}} 62 | }; 63 | 64 | local const ct_data static_dtree[D_CODES] = { 65 | {{ 0},{ 5}}, {{16},{ 5}}, {{ 8},{ 5}}, {{24},{ 5}}, {{ 4},{ 5}}, 66 | {{20},{ 5}}, {{12},{ 5}}, {{28},{ 5}}, {{ 2},{ 5}}, {{18},{ 5}}, 67 | {{10},{ 5}}, {{26},{ 5}}, {{ 6},{ 5}}, {{22},{ 5}}, {{14},{ 5}}, 68 | {{30},{ 5}}, {{ 1},{ 5}}, {{17},{ 5}}, {{ 9},{ 5}}, {{25},{ 5}}, 69 | {{ 5},{ 5}}, {{21},{ 5}}, {{13},{ 5}}, {{29},{ 5}}, {{ 3},{ 5}}, 70 | {{19},{ 5}}, {{11},{ 5}}, {{27},{ 5}}, {{ 7},{ 5}}, {{23},{ 5}} 71 | }; 72 | 73 | const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = { 74 | 0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 75 | 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, 76 | 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 77 | 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 78 | 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, 79 | 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 80 | 13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 81 | 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 82 | 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 83 | 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, 84 | 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 85 | 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 86 | 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 16, 17, 87 | 18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, 88 | 23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 89 | 24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 90 | 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 91 | 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 92 | 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 93 | 27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 94 | 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 95 | 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 96 | 28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 97 | 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 98 | 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 99 | 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29 100 | }; 101 | 102 | const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= { 103 | 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 12, 12, 104 | 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, 105 | 17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, 106 | 19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 107 | 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, 108 | 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, 109 | 23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 110 | 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 111 | 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 112 | 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, 113 | 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 114 | 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 115 | 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28 116 | }; 117 | 118 | local const int base_length[LENGTH_CODES] = { 119 | 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56, 120 | 64, 80, 96, 112, 128, 160, 192, 224, 0 121 | }; 122 | 123 | local const int base_dist[D_CODES] = { 124 | 0, 1, 2, 3, 4, 6, 8, 12, 16, 24, 125 | 32, 48, 64, 96, 128, 192, 256, 384, 512, 768, 126 | 1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576 127 | }; 128 | 129 | -------------------------------------------------------------------------------- /ext/zlib/uncompr.c: -------------------------------------------------------------------------------- 1 | /* uncompr.c -- decompress a memory buffer 2 | * Copyright (C) 1995-2003, 2010, 2014, 2016 Jean-loup Gailly, Mark Adler 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | */ 5 | 6 | /* @(#) $Id$ */ 7 | 8 | #define ZLIB_INTERNAL 9 | #include "zlib.h" 10 | 11 | /* =========================================================================== 12 | Decompresses the source buffer into the destination buffer. *sourceLen is 13 | the byte length of the source buffer. Upon entry, *destLen is the total size 14 | of the destination buffer, which must be large enough to hold the entire 15 | uncompressed data. (The size of the uncompressed data must have been saved 16 | previously by the compressor and transmitted to the decompressor by some 17 | mechanism outside the scope of this compression library.) Upon exit, 18 | *destLen is the size of the decompressed data and *sourceLen is the number 19 | of source bytes consumed. Upon return, source + *sourceLen points to the 20 | first unused input byte. 21 | 22 | uncompress returns Z_OK if success, Z_MEM_ERROR if there was not enough 23 | memory, Z_BUF_ERROR if there was not enough room in the output buffer, or 24 | Z_DATA_ERROR if the input data was corrupted, including if the input data is 25 | an incomplete zlib stream. 26 | */ 27 | int ZEXPORT uncompress2 (dest, destLen, source, sourceLen) 28 | Bytef *dest; 29 | uLongf *destLen; 30 | const Bytef *source; 31 | uLong *sourceLen; 32 | { 33 | z_stream stream; 34 | int err; 35 | const uInt max = (uInt)-1; 36 | uLong len, left; 37 | Byte buf[1]; /* for detection of incomplete stream when *destLen == 0 */ 38 | 39 | len = *sourceLen; 40 | if (*destLen) { 41 | left = *destLen; 42 | *destLen = 0; 43 | } 44 | else { 45 | left = 1; 46 | dest = buf; 47 | } 48 | 49 | stream.next_in = (z_const Bytef *)source; 50 | stream.avail_in = 0; 51 | stream.zalloc = (alloc_func)0; 52 | stream.zfree = (free_func)0; 53 | stream.opaque = (voidpf)0; 54 | 55 | err = inflateInit(&stream); 56 | if (err != Z_OK) return err; 57 | 58 | stream.next_out = dest; 59 | stream.avail_out = 0; 60 | 61 | do { 62 | if (stream.avail_out == 0) { 63 | stream.avail_out = left > (uLong)max ? max : (uInt)left; 64 | left -= stream.avail_out; 65 | } 66 | if (stream.avail_in == 0) { 67 | stream.avail_in = len > (uLong)max ? max : (uInt)len; 68 | len -= stream.avail_in; 69 | } 70 | err = inflate(&stream, Z_NO_FLUSH); 71 | } while (err == Z_OK); 72 | 73 | *sourceLen -= len + stream.avail_in; 74 | if (dest != buf) 75 | *destLen = stream.total_out; 76 | else if (stream.total_out && err == Z_BUF_ERROR) 77 | left = 1; 78 | 79 | inflateEnd(&stream); 80 | return err == Z_STREAM_END ? Z_OK : 81 | err == Z_NEED_DICT ? Z_DATA_ERROR : 82 | err == Z_BUF_ERROR && left + stream.avail_out ? Z_DATA_ERROR : 83 | err; 84 | } 85 | 86 | int ZEXPORT uncompress (dest, destLen, source, sourceLen) 87 | Bytef *dest; 88 | uLongf *destLen; 89 | const Bytef *source; 90 | uLong sourceLen; 91 | { 92 | return uncompress2(dest, destLen, source, &sourceLen); 93 | } 94 | -------------------------------------------------------------------------------- /ext/zlib/zconf.h: -------------------------------------------------------------------------------- 1 | /* zconf.h -- configuration of the zlib compression library 2 | * Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | */ 5 | 6 | /* @(#) $Id$ */ 7 | 8 | #ifndef ZCONF_H 9 | #define ZCONF_H 10 | 11 | /* 12 | * If you *really* need a unique prefix for all types and library functions, 13 | * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it. 14 | * Even better than compiling with -DZ_PREFIX would be to use configure to set 15 | * this permanently in zconf.h using "./configure --zprefix". 16 | */ 17 | #ifdef Z_PREFIX /* may be set to #if 1 by ./configure */ 18 | # define Z_PREFIX_SET 19 | 20 | /* all linked symbols and init macros */ 21 | # define _dist_code z__dist_code 22 | # define _length_code z__length_code 23 | # define _tr_align z__tr_align 24 | # define _tr_flush_bits z__tr_flush_bits 25 | # define _tr_flush_block z__tr_flush_block 26 | # define _tr_init z__tr_init 27 | # define _tr_stored_block z__tr_stored_block 28 | # define _tr_tally z__tr_tally 29 | # define adler32 z_adler32 30 | # define adler32_combine z_adler32_combine 31 | # define adler32_combine64 z_adler32_combine64 32 | # define adler32_z z_adler32_z 33 | # ifndef Z_SOLO 34 | # define compress z_compress 35 | # define compress2 z_compress2 36 | # define compressBound z_compressBound 37 | # endif 38 | # define crc32 z_crc32 39 | # define crc32_combine z_crc32_combine 40 | # define crc32_combine64 z_crc32_combine64 41 | # define crc32_z z_crc32_z 42 | # define deflate z_deflate 43 | # define deflateBound z_deflateBound 44 | # define deflateCopy z_deflateCopy 45 | # define deflateEnd z_deflateEnd 46 | # define deflateGetDictionary z_deflateGetDictionary 47 | # define deflateInit z_deflateInit 48 | # define deflateInit2 z_deflateInit2 49 | # define deflateInit2_ z_deflateInit2_ 50 | # define deflateInit_ z_deflateInit_ 51 | # define deflateParams z_deflateParams 52 | # define deflatePending z_deflatePending 53 | # define deflatePrime z_deflatePrime 54 | # define deflateReset z_deflateReset 55 | # define deflateResetKeep z_deflateResetKeep 56 | # define deflateSetDictionary z_deflateSetDictionary 57 | # define deflateSetHeader z_deflateSetHeader 58 | # define deflateTune z_deflateTune 59 | # define deflate_copyright z_deflate_copyright 60 | # define get_crc_table z_get_crc_table 61 | # ifndef Z_SOLO 62 | # define gz_error z_gz_error 63 | # define gz_intmax z_gz_intmax 64 | # define gz_strwinerror z_gz_strwinerror 65 | # define gzbuffer z_gzbuffer 66 | # define gzclearerr z_gzclearerr 67 | # define gzclose z_gzclose 68 | # define gzclose_r z_gzclose_r 69 | # define gzclose_w z_gzclose_w 70 | # define gzdirect z_gzdirect 71 | # define gzdopen z_gzdopen 72 | # define gzeof z_gzeof 73 | # define gzerror z_gzerror 74 | # define gzflush z_gzflush 75 | # define gzfread z_gzfread 76 | # define gzfwrite z_gzfwrite 77 | # define gzgetc z_gzgetc 78 | # define gzgetc_ z_gzgetc_ 79 | # define gzgets z_gzgets 80 | # define gzoffset z_gzoffset 81 | # define gzoffset64 z_gzoffset64 82 | # define gzopen z_gzopen 83 | # define gzopen64 z_gzopen64 84 | # ifdef _WIN32 85 | # define gzopen_w z_gzopen_w 86 | # endif 87 | # define gzprintf z_gzprintf 88 | # define gzputc z_gzputc 89 | # define gzputs z_gzputs 90 | # define gzread z_gzread 91 | # define gzrewind z_gzrewind 92 | # define gzseek z_gzseek 93 | # define gzseek64 z_gzseek64 94 | # define gzsetparams z_gzsetparams 95 | # define gztell z_gztell 96 | # define gztell64 z_gztell64 97 | # define gzungetc z_gzungetc 98 | # define gzvprintf z_gzvprintf 99 | # define gzwrite z_gzwrite 100 | # endif 101 | # define inflate z_inflate 102 | # define inflateBack z_inflateBack 103 | # define inflateBackEnd z_inflateBackEnd 104 | # define inflateBackInit z_inflateBackInit 105 | # define inflateBackInit_ z_inflateBackInit_ 106 | # define inflateCodesUsed z_inflateCodesUsed 107 | # define inflateCopy z_inflateCopy 108 | # define inflateEnd z_inflateEnd 109 | # define inflateGetDictionary z_inflateGetDictionary 110 | # define inflateGetHeader z_inflateGetHeader 111 | # define inflateInit z_inflateInit 112 | # define inflateInit2 z_inflateInit2 113 | # define inflateInit2_ z_inflateInit2_ 114 | # define inflateInit_ z_inflateInit_ 115 | # define inflateMark z_inflateMark 116 | # define inflatePrime z_inflatePrime 117 | # define inflateReset z_inflateReset 118 | # define inflateReset2 z_inflateReset2 119 | # define inflateResetKeep z_inflateResetKeep 120 | # define inflateSetDictionary z_inflateSetDictionary 121 | # define inflateSync z_inflateSync 122 | # define inflateSyncPoint z_inflateSyncPoint 123 | # define inflateUndermine z_inflateUndermine 124 | # define inflateValidate z_inflateValidate 125 | # define inflate_copyright z_inflate_copyright 126 | # define inflate_fast z_inflate_fast 127 | # define inflate_table z_inflate_table 128 | # ifndef Z_SOLO 129 | # define uncompress z_uncompress 130 | # define uncompress2 z_uncompress2 131 | # endif 132 | # define zError z_zError 133 | # ifndef Z_SOLO 134 | # define zcalloc z_zcalloc 135 | # define zcfree z_zcfree 136 | # endif 137 | # define zlibCompileFlags z_zlibCompileFlags 138 | # define zlibVersion z_zlibVersion 139 | 140 | /* all zlib typedefs in zlib.h and zconf.h */ 141 | # define Byte z_Byte 142 | # define Bytef z_Bytef 143 | # define alloc_func z_alloc_func 144 | # define charf z_charf 145 | # define free_func z_free_func 146 | # ifndef Z_SOLO 147 | # define gzFile z_gzFile 148 | # endif 149 | # define gz_header z_gz_header 150 | # define gz_headerp z_gz_headerp 151 | # define in_func z_in_func 152 | # define intf z_intf 153 | # define out_func z_out_func 154 | # define uInt z_uInt 155 | # define uIntf z_uIntf 156 | # define uLong z_uLong 157 | # define uLongf z_uLongf 158 | # define voidp z_voidp 159 | # define voidpc z_voidpc 160 | # define voidpf z_voidpf 161 | 162 | /* all zlib structs in zlib.h and zconf.h */ 163 | # define gz_header_s z_gz_header_s 164 | # define internal_state z_internal_state 165 | 166 | #endif 167 | 168 | #if defined(__MSDOS__) && !defined(MSDOS) 169 | # define MSDOS 170 | #endif 171 | #if (defined(OS_2) || defined(__OS2__)) && !defined(OS2) 172 | # define OS2 173 | #endif 174 | #if defined(_WINDOWS) && !defined(WINDOWS) 175 | # define WINDOWS 176 | #endif 177 | #if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__) 178 | # ifndef WIN32 179 | # define WIN32 180 | # endif 181 | #endif 182 | #if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32) 183 | # if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__) 184 | # ifndef SYS16BIT 185 | # define SYS16BIT 186 | # endif 187 | # endif 188 | #endif 189 | 190 | /* 191 | * Compile with -DMAXSEG_64K if the alloc function cannot allocate more 192 | * than 64k bytes at a time (needed on systems with 16-bit int). 193 | */ 194 | #ifdef SYS16BIT 195 | # define MAXSEG_64K 196 | #endif 197 | #ifdef MSDOS 198 | # define UNALIGNED_OK 199 | #endif 200 | 201 | #ifdef __STDC_VERSION__ 202 | # ifndef STDC 203 | # define STDC 204 | # endif 205 | # if __STDC_VERSION__ >= 199901L 206 | # ifndef STDC99 207 | # define STDC99 208 | # endif 209 | # endif 210 | #endif 211 | #if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus)) 212 | # define STDC 213 | #endif 214 | #if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__)) 215 | # define STDC 216 | #endif 217 | #if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32)) 218 | # define STDC 219 | #endif 220 | #if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__)) 221 | # define STDC 222 | #endif 223 | 224 | #if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */ 225 | # define STDC 226 | #endif 227 | 228 | #ifndef STDC 229 | # ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ 230 | # define const /* note: need a more gentle solution here */ 231 | # endif 232 | #endif 233 | 234 | #if defined(ZLIB_CONST) && !defined(z_const) 235 | # define z_const const 236 | #else 237 | # define z_const 238 | #endif 239 | 240 | #ifdef Z_SOLO 241 | typedef unsigned long z_size_t; 242 | #else 243 | # define z_longlong long long 244 | # if defined(NO_SIZE_T) 245 | typedef unsigned NO_SIZE_T z_size_t; 246 | # elif defined(STDC) 247 | # include 248 | typedef size_t z_size_t; 249 | # else 250 | typedef unsigned long z_size_t; 251 | # endif 252 | # undef z_longlong 253 | #endif 254 | 255 | /* Maximum value for memLevel in deflateInit2 */ 256 | #ifndef MAX_MEM_LEVEL 257 | # ifdef MAXSEG_64K 258 | # define MAX_MEM_LEVEL 8 259 | # else 260 | # define MAX_MEM_LEVEL 9 261 | # endif 262 | #endif 263 | 264 | /* Maximum value for windowBits in deflateInit2 and inflateInit2. 265 | * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files 266 | * created by gzip. (Files created by minigzip can still be extracted by 267 | * gzip.) 268 | */ 269 | #ifndef MAX_WBITS 270 | # define MAX_WBITS 15 /* 32K LZ77 window */ 271 | #endif 272 | 273 | /* The memory requirements for deflate are (in bytes): 274 | (1 << (windowBits+2)) + (1 << (memLevel+9)) 275 | that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values) 276 | plus a few kilobytes for small objects. For example, if you want to reduce 277 | the default memory requirements from 256K to 128K, compile with 278 | make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" 279 | Of course this will generally degrade compression (there's no free lunch). 280 | 281 | The memory requirements for inflate are (in bytes) 1 << windowBits 282 | that is, 32K for windowBits=15 (default value) plus about 7 kilobytes 283 | for small objects. 284 | */ 285 | 286 | /* Type declarations */ 287 | 288 | #ifndef OF /* function prototypes */ 289 | # ifdef STDC 290 | # define OF(args) args 291 | # else 292 | # define OF(args) () 293 | # endif 294 | #endif 295 | 296 | #ifndef Z_ARG /* function prototypes for stdarg */ 297 | # if defined(STDC) || defined(Z_HAVE_STDARG_H) 298 | # define Z_ARG(args) args 299 | # else 300 | # define Z_ARG(args) () 301 | # endif 302 | #endif 303 | 304 | /* The following definitions for FAR are needed only for MSDOS mixed 305 | * model programming (small or medium model with some far allocations). 306 | * This was tested only with MSC; for other MSDOS compilers you may have 307 | * to define NO_MEMCPY in zutil.h. If you don't need the mixed model, 308 | * just define FAR to be empty. 309 | */ 310 | #ifdef SYS16BIT 311 | # if defined(M_I86SM) || defined(M_I86MM) 312 | /* MSC small or medium model */ 313 | # define SMALL_MEDIUM 314 | # ifdef _MSC_VER 315 | # define FAR _far 316 | # else 317 | # define FAR far 318 | # endif 319 | # endif 320 | # if (defined(__SMALL__) || defined(__MEDIUM__)) 321 | /* Turbo C small or medium model */ 322 | # define SMALL_MEDIUM 323 | # ifdef __BORLANDC__ 324 | # define FAR _far 325 | # else 326 | # define FAR far 327 | # endif 328 | # endif 329 | #endif 330 | 331 | #if defined(WINDOWS) || defined(WIN32) 332 | /* If building or using zlib as a DLL, define ZLIB_DLL. 333 | * This is not mandatory, but it offers a little performance increase. 334 | */ 335 | # ifdef ZLIB_DLL 336 | # if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500)) 337 | # ifdef ZLIB_INTERNAL 338 | # define ZEXTERN extern __declspec(dllexport) 339 | # else 340 | # define ZEXTERN extern __declspec(dllimport) 341 | # endif 342 | # endif 343 | # endif /* ZLIB_DLL */ 344 | /* If building or using zlib with the WINAPI/WINAPIV calling convention, 345 | * define ZLIB_WINAPI. 346 | * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. 347 | */ 348 | # ifdef ZLIB_WINAPI 349 | # ifdef FAR 350 | # undef FAR 351 | # endif 352 | # include 353 | /* No need for _export, use ZLIB.DEF instead. */ 354 | /* For complete Windows compatibility, use WINAPI, not __stdcall. */ 355 | # define ZEXPORT WINAPI 356 | # ifdef WIN32 357 | # define ZEXPORTVA WINAPIV 358 | # else 359 | # define ZEXPORTVA FAR CDECL 360 | # endif 361 | # endif 362 | #endif 363 | 364 | #if defined (__BEOS__) 365 | # ifdef ZLIB_DLL 366 | # ifdef ZLIB_INTERNAL 367 | # define ZEXPORT __declspec(dllexport) 368 | # define ZEXPORTVA __declspec(dllexport) 369 | # else 370 | # define ZEXPORT __declspec(dllimport) 371 | # define ZEXPORTVA __declspec(dllimport) 372 | # endif 373 | # endif 374 | #endif 375 | 376 | #ifndef ZEXTERN 377 | # define ZEXTERN extern 378 | #endif 379 | #ifndef ZEXPORT 380 | # define ZEXPORT 381 | #endif 382 | #ifndef ZEXPORTVA 383 | # define ZEXPORTVA 384 | #endif 385 | 386 | #ifndef FAR 387 | # define FAR 388 | #endif 389 | 390 | #if !defined(__MACTYPES__) 391 | typedef unsigned char Byte; /* 8 bits */ 392 | #endif 393 | typedef unsigned int uInt; /* 16 bits or more */ 394 | typedef unsigned long uLong; /* 32 bits or more */ 395 | 396 | #ifdef SMALL_MEDIUM 397 | /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ 398 | # define Bytef Byte FAR 399 | #else 400 | typedef Byte FAR Bytef; 401 | #endif 402 | typedef char FAR charf; 403 | typedef int FAR intf; 404 | typedef uInt FAR uIntf; 405 | typedef uLong FAR uLongf; 406 | 407 | #ifdef STDC 408 | typedef void const *voidpc; 409 | typedef void FAR *voidpf; 410 | typedef void *voidp; 411 | #else 412 | typedef Byte const *voidpc; 413 | typedef Byte FAR *voidpf; 414 | typedef Byte *voidp; 415 | #endif 416 | 417 | #if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC) 418 | # include 419 | # if (UINT_MAX == 0xffffffffUL) 420 | # define Z_U4 unsigned 421 | # elif (ULONG_MAX == 0xffffffffUL) 422 | # define Z_U4 unsigned long 423 | # elif (USHRT_MAX == 0xffffffffUL) 424 | # define Z_U4 unsigned short 425 | # endif 426 | #endif 427 | 428 | #ifdef Z_U4 429 | typedef Z_U4 z_crc_t; 430 | #else 431 | typedef unsigned long z_crc_t; 432 | #endif 433 | 434 | #ifdef HAVE_UNISTD_H /* may be set to #if 1 by ./configure */ 435 | # define Z_HAVE_UNISTD_H 436 | #endif 437 | 438 | #ifdef HAVE_STDARG_H /* may be set to #if 1 by ./configure */ 439 | # define Z_HAVE_STDARG_H 440 | #endif 441 | 442 | #ifdef STDC 443 | # ifndef Z_SOLO 444 | # include /* for off_t */ 445 | # endif 446 | #endif 447 | 448 | #if defined(STDC) || defined(Z_HAVE_STDARG_H) 449 | # ifndef Z_SOLO 450 | # include /* for va_list */ 451 | # endif 452 | #endif 453 | 454 | #ifdef _WIN32 455 | # ifndef Z_SOLO 456 | # include /* for wchar_t */ 457 | # endif 458 | #endif 459 | 460 | /* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and 461 | * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even 462 | * though the former does not conform to the LFS document), but considering 463 | * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as 464 | * equivalently requesting no 64-bit operations 465 | */ 466 | #if defined(_LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1 467 | # undef _LARGEFILE64_SOURCE 468 | #endif 469 | 470 | #if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H) 471 | # define Z_HAVE_UNISTD_H 472 | #endif 473 | #ifndef Z_SOLO 474 | # if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE) 475 | # include /* for SEEK_*, off_t, and _LFS64_LARGEFILE */ 476 | # ifdef VMS 477 | # include /* for off_t */ 478 | # endif 479 | # ifndef z_off_t 480 | # define z_off_t off_t 481 | # endif 482 | # endif 483 | #endif 484 | 485 | #if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0 486 | # define Z_LFS64 487 | #endif 488 | 489 | #if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64) 490 | # define Z_LARGE64 491 | #endif 492 | 493 | #if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64) 494 | # define Z_WANT64 495 | #endif 496 | 497 | #if !defined(SEEK_SET) && !defined(Z_SOLO) 498 | # define SEEK_SET 0 /* Seek from beginning of file. */ 499 | # define SEEK_CUR 1 /* Seek from current position. */ 500 | # define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ 501 | #endif 502 | 503 | #ifndef z_off_t 504 | # define z_off_t long 505 | #endif 506 | 507 | #if !defined(_WIN32) && defined(Z_LARGE64) 508 | # define z_off64_t off64_t 509 | #else 510 | # if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO) 511 | # define z_off64_t __int64 512 | # else 513 | # define z_off64_t z_off_t 514 | # endif 515 | #endif 516 | 517 | /* MVS linker does not support external names larger than 8 bytes */ 518 | #if defined(__MVS__) 519 | #pragma map(deflateInit_,"DEIN") 520 | #pragma map(deflateInit2_,"DEIN2") 521 | #pragma map(deflateEnd,"DEEND") 522 | #pragma map(deflateBound,"DEBND") 523 | #pragma map(inflateInit_,"ININ") 524 | #pragma map(inflateInit2_,"ININ2") 525 | #pragma map(inflateEnd,"INEND") 526 | #pragma map(inflateSync,"INSY") 527 | #pragma map(inflateSetDictionary,"INSEDI") 528 | #pragma map(compressBound,"CMBND") 529 | #pragma map(inflate_table,"INTABL") 530 | #pragma map(inflate_fast,"INFA") 531 | #pragma map(inflate_copyright,"INCOPY") 532 | #endif 533 | 534 | #endif /* ZCONF_H */ 535 | -------------------------------------------------------------------------------- /ext/zlib/zutil.c: -------------------------------------------------------------------------------- 1 | /* zutil.c -- target dependent utility functions for the compression library 2 | * Copyright (C) 1995-2017 Jean-loup Gailly 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | */ 5 | 6 | /* @(#) $Id$ */ 7 | 8 | #include "zutil.h" 9 | #ifndef Z_SOLO 10 | # include "gzguts.h" 11 | #endif 12 | 13 | z_const char * const z_errmsg[10] = { 14 | (z_const char *)"need dictionary", /* Z_NEED_DICT 2 */ 15 | (z_const char *)"stream end", /* Z_STREAM_END 1 */ 16 | (z_const char *)"", /* Z_OK 0 */ 17 | (z_const char *)"file error", /* Z_ERRNO (-1) */ 18 | (z_const char *)"stream error", /* Z_STREAM_ERROR (-2) */ 19 | (z_const char *)"data error", /* Z_DATA_ERROR (-3) */ 20 | (z_const char *)"insufficient memory", /* Z_MEM_ERROR (-4) */ 21 | (z_const char *)"buffer error", /* Z_BUF_ERROR (-5) */ 22 | (z_const char *)"incompatible version",/* Z_VERSION_ERROR (-6) */ 23 | (z_const char *)"" 24 | }; 25 | 26 | 27 | const char * ZEXPORT zlibVersion() 28 | { 29 | return ZLIB_VERSION; 30 | } 31 | 32 | uLong ZEXPORT zlibCompileFlags() 33 | { 34 | uLong flags; 35 | 36 | flags = 0; 37 | switch ((int)(sizeof(uInt))) { 38 | case 2: break; 39 | case 4: flags += 1; break; 40 | case 8: flags += 2; break; 41 | default: flags += 3; 42 | } 43 | switch ((int)(sizeof(uLong))) { 44 | case 2: break; 45 | case 4: flags += 1 << 2; break; 46 | case 8: flags += 2 << 2; break; 47 | default: flags += 3 << 2; 48 | } 49 | switch ((int)(sizeof(voidpf))) { 50 | case 2: break; 51 | case 4: flags += 1 << 4; break; 52 | case 8: flags += 2 << 4; break; 53 | default: flags += 3 << 4; 54 | } 55 | switch ((int)(sizeof(z_off_t))) { 56 | case 2: break; 57 | case 4: flags += 1 << 6; break; 58 | case 8: flags += 2 << 6; break; 59 | default: flags += 3 << 6; 60 | } 61 | #ifdef ZLIB_DEBUG 62 | flags += 1 << 8; 63 | #endif 64 | #if defined(ASMV) || defined(ASMINF) 65 | flags += 1 << 9; 66 | #endif 67 | #ifdef ZLIB_WINAPI 68 | flags += 1 << 10; 69 | #endif 70 | #ifdef BUILDFIXED 71 | flags += 1 << 12; 72 | #endif 73 | #ifdef DYNAMIC_CRC_TABLE 74 | flags += 1 << 13; 75 | #endif 76 | #ifdef NO_GZCOMPRESS 77 | flags += 1L << 16; 78 | #endif 79 | #ifdef NO_GZIP 80 | flags += 1L << 17; 81 | #endif 82 | #ifdef PKZIP_BUG_WORKAROUND 83 | flags += 1L << 20; 84 | #endif 85 | #ifdef FASTEST 86 | flags += 1L << 21; 87 | #endif 88 | #if defined(STDC) || defined(Z_HAVE_STDARG_H) 89 | # ifdef NO_vsnprintf 90 | flags += 1L << 25; 91 | # ifdef HAS_vsprintf_void 92 | flags += 1L << 26; 93 | # endif 94 | # else 95 | # ifdef HAS_vsnprintf_void 96 | flags += 1L << 26; 97 | # endif 98 | # endif 99 | #else 100 | flags += 1L << 24; 101 | # ifdef NO_snprintf 102 | flags += 1L << 25; 103 | # ifdef HAS_sprintf_void 104 | flags += 1L << 26; 105 | # endif 106 | # else 107 | # ifdef HAS_snprintf_void 108 | flags += 1L << 26; 109 | # endif 110 | # endif 111 | #endif 112 | return flags; 113 | } 114 | 115 | #ifdef ZLIB_DEBUG 116 | #include 117 | # ifndef verbose 118 | # define verbose 0 119 | # endif 120 | int ZLIB_INTERNAL z_verbose = verbose; 121 | 122 | void ZLIB_INTERNAL z_error (m) 123 | char *m; 124 | { 125 | fprintf(stderr, "%s\n", m); 126 | exit(1); 127 | } 128 | #endif 129 | 130 | /* exported to allow conversion of error code to string for compress() and 131 | * uncompress() 132 | */ 133 | const char * ZEXPORT zError(err) 134 | int err; 135 | { 136 | return ERR_MSG(err); 137 | } 138 | 139 | #if defined(_WIN32_WCE) 140 | /* The Microsoft C Run-Time Library for Windows CE doesn't have 141 | * errno. We define it as a global variable to simplify porting. 142 | * Its value is always 0 and should not be used. 143 | */ 144 | int errno = 0; 145 | #endif 146 | 147 | #ifndef HAVE_MEMCPY 148 | 149 | void ZLIB_INTERNAL zmemcpy(dest, source, len) 150 | Bytef* dest; 151 | const Bytef* source; 152 | uInt len; 153 | { 154 | if (len == 0) return; 155 | do { 156 | *dest++ = *source++; /* ??? to be unrolled */ 157 | } while (--len != 0); 158 | } 159 | 160 | int ZLIB_INTERNAL zmemcmp(s1, s2, len) 161 | const Bytef* s1; 162 | const Bytef* s2; 163 | uInt len; 164 | { 165 | uInt j; 166 | 167 | for (j = 0; j < len; j++) { 168 | if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1; 169 | } 170 | return 0; 171 | } 172 | 173 | void ZLIB_INTERNAL zmemzero(dest, len) 174 | Bytef* dest; 175 | uInt len; 176 | { 177 | if (len == 0) return; 178 | do { 179 | *dest++ = 0; /* ??? to be unrolled */ 180 | } while (--len != 0); 181 | } 182 | #endif 183 | 184 | #ifndef Z_SOLO 185 | 186 | #ifdef SYS16BIT 187 | 188 | #ifdef __TURBOC__ 189 | /* Turbo C in 16-bit mode */ 190 | 191 | # define MY_ZCALLOC 192 | 193 | /* Turbo C malloc() does not allow dynamic allocation of 64K bytes 194 | * and farmalloc(64K) returns a pointer with an offset of 8, so we 195 | * must fix the pointer. Warning: the pointer must be put back to its 196 | * original form in order to free it, use zcfree(). 197 | */ 198 | 199 | #define MAX_PTR 10 200 | /* 10*64K = 640K */ 201 | 202 | local int next_ptr = 0; 203 | 204 | typedef struct ptr_table_s { 205 | voidpf org_ptr; 206 | voidpf new_ptr; 207 | } ptr_table; 208 | 209 | local ptr_table table[MAX_PTR]; 210 | /* This table is used to remember the original form of pointers 211 | * to large buffers (64K). Such pointers are normalized with a zero offset. 212 | * Since MSDOS is not a preemptive multitasking OS, this table is not 213 | * protected from concurrent access. This hack doesn't work anyway on 214 | * a protected system like OS/2. Use Microsoft C instead. 215 | */ 216 | 217 | voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size) 218 | { 219 | voidpf buf; 220 | ulg bsize = (ulg)items*size; 221 | 222 | (void)opaque; 223 | 224 | /* If we allocate less than 65520 bytes, we assume that farmalloc 225 | * will return a usable pointer which doesn't have to be normalized. 226 | */ 227 | if (bsize < 65520L) { 228 | buf = farmalloc(bsize); 229 | if (*(ush*)&buf != 0) return buf; 230 | } else { 231 | buf = farmalloc(bsize + 16L); 232 | } 233 | if (buf == NULL || next_ptr >= MAX_PTR) return NULL; 234 | table[next_ptr].org_ptr = buf; 235 | 236 | /* Normalize the pointer to seg:0 */ 237 | *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4; 238 | *(ush*)&buf = 0; 239 | table[next_ptr++].new_ptr = buf; 240 | return buf; 241 | } 242 | 243 | void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr) 244 | { 245 | int n; 246 | 247 | (void)opaque; 248 | 249 | if (*(ush*)&ptr != 0) { /* object < 64K */ 250 | farfree(ptr); 251 | return; 252 | } 253 | /* Find the original pointer */ 254 | for (n = 0; n < next_ptr; n++) { 255 | if (ptr != table[n].new_ptr) continue; 256 | 257 | farfree(table[n].org_ptr); 258 | while (++n < next_ptr) { 259 | table[n-1] = table[n]; 260 | } 261 | next_ptr--; 262 | return; 263 | } 264 | Assert(0, "zcfree: ptr not found"); 265 | } 266 | 267 | #endif /* __TURBOC__ */ 268 | 269 | 270 | #ifdef M_I86 271 | /* Microsoft C in 16-bit mode */ 272 | 273 | # define MY_ZCALLOC 274 | 275 | #if (!defined(_MSC_VER) || (_MSC_VER <= 600)) 276 | # define _halloc halloc 277 | # define _hfree hfree 278 | #endif 279 | 280 | voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, uInt items, uInt size) 281 | { 282 | (void)opaque; 283 | return _halloc((long)items, size); 284 | } 285 | 286 | void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr) 287 | { 288 | (void)opaque; 289 | _hfree(ptr); 290 | } 291 | 292 | #endif /* M_I86 */ 293 | 294 | #endif /* SYS16BIT */ 295 | 296 | 297 | #ifndef MY_ZCALLOC /* Any system without a special alloc function */ 298 | 299 | #ifndef STDC 300 | extern voidp malloc OF((uInt size)); 301 | extern voidp calloc OF((uInt items, uInt size)); 302 | extern void free OF((voidpf ptr)); 303 | #endif 304 | 305 | voidpf ZLIB_INTERNAL zcalloc (opaque, items, size) 306 | voidpf opaque; 307 | unsigned items; 308 | unsigned size; 309 | { 310 | (void)opaque; 311 | return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) : 312 | (voidpf)calloc(items, size); 313 | } 314 | 315 | void ZLIB_INTERNAL zcfree (opaque, ptr) 316 | voidpf opaque; 317 | voidpf ptr; 318 | { 319 | (void)opaque; 320 | free(ptr); 321 | } 322 | 323 | #endif /* MY_ZCALLOC */ 324 | 325 | #endif /* !Z_SOLO */ 326 | -------------------------------------------------------------------------------- /ext/zlib/zutil.h: -------------------------------------------------------------------------------- 1 | /* zutil.h -- internal interface and configuration of the compression library 2 | * Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler 3 | * For conditions of distribution and use, see copyright notice in zlib.h 4 | */ 5 | 6 | /* WARNING: this file should *not* be used by applications. It is 7 | part of the implementation of the compression library and is 8 | subject to change. Applications should only use zlib.h. 9 | */ 10 | 11 | /* @(#) $Id$ */ 12 | 13 | #ifndef ZUTIL_H 14 | #define ZUTIL_H 15 | 16 | #ifdef HAVE_HIDDEN 17 | # define ZLIB_INTERNAL __attribute__((visibility ("hidden"))) 18 | #else 19 | # define ZLIB_INTERNAL 20 | #endif 21 | 22 | #include "zlib.h" 23 | 24 | #if defined(STDC) && !defined(Z_SOLO) 25 | # if !(defined(_WIN32_WCE) && defined(_MSC_VER)) 26 | # include 27 | # endif 28 | # include 29 | # include 30 | #endif 31 | 32 | #ifdef Z_SOLO 33 | typedef long ptrdiff_t; /* guess -- will be caught if guess is wrong */ 34 | #endif 35 | 36 | #ifndef local 37 | # define local static 38 | #endif 39 | /* since "static" is used to mean two completely different things in C, we 40 | define "local" for the non-static meaning of "static", for readability 41 | (compile with -Dlocal if your debugger can't find static symbols) */ 42 | 43 | typedef unsigned char uch; 44 | typedef uch FAR uchf; 45 | typedef unsigned short ush; 46 | typedef ush FAR ushf; 47 | typedef unsigned long ulg; 48 | 49 | extern z_const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ 50 | /* (size given to avoid silly warnings with Visual C++) */ 51 | 52 | #define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)] 53 | 54 | #define ERR_RETURN(strm,err) \ 55 | return (strm->msg = ERR_MSG(err), (err)) 56 | /* To be used only when the state is known to be valid */ 57 | 58 | /* common constants */ 59 | 60 | #ifndef DEF_WBITS 61 | # define DEF_WBITS MAX_WBITS 62 | #endif 63 | /* default windowBits for decompression. MAX_WBITS is for compression only */ 64 | 65 | #if MAX_MEM_LEVEL >= 8 66 | # define DEF_MEM_LEVEL 8 67 | #else 68 | # define DEF_MEM_LEVEL MAX_MEM_LEVEL 69 | #endif 70 | /* default memLevel */ 71 | 72 | #define STORED_BLOCK 0 73 | #define STATIC_TREES 1 74 | #define DYN_TREES 2 75 | /* The three kinds of block type */ 76 | 77 | #define MIN_MATCH 3 78 | #define MAX_MATCH 258 79 | /* The minimum and maximum match lengths */ 80 | 81 | #define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */ 82 | 83 | /* target dependencies */ 84 | 85 | #if defined(MSDOS) || (defined(WINDOWS) && !defined(WIN32)) 86 | # define OS_CODE 0x00 87 | # ifndef Z_SOLO 88 | # if defined(__TURBOC__) || defined(__BORLANDC__) 89 | # if (__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__)) 90 | /* Allow compilation with ANSI keywords only enabled */ 91 | void _Cdecl farfree( void *block ); 92 | void *_Cdecl farmalloc( unsigned long nbytes ); 93 | # else 94 | # include 95 | # endif 96 | # else /* MSC or DJGPP */ 97 | # include 98 | # endif 99 | # endif 100 | #endif 101 | 102 | #ifdef AMIGA 103 | # define OS_CODE 1 104 | #endif 105 | 106 | #if defined(VAXC) || defined(VMS) 107 | # define OS_CODE 2 108 | # define F_OPEN(name, mode) \ 109 | fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512") 110 | #endif 111 | 112 | #ifdef __370__ 113 | # if __TARGET_LIB__ < 0x20000000 114 | # define OS_CODE 4 115 | # elif __TARGET_LIB__ < 0x40000000 116 | # define OS_CODE 11 117 | # else 118 | # define OS_CODE 8 119 | # endif 120 | #endif 121 | 122 | #if defined(ATARI) || defined(atarist) 123 | # define OS_CODE 5 124 | #endif 125 | 126 | #ifdef OS2 127 | # define OS_CODE 6 128 | # if defined(M_I86) && !defined(Z_SOLO) 129 | # include 130 | # endif 131 | #endif 132 | 133 | #if defined(MACOS) || defined(TARGET_OS_MAC) 134 | # define OS_CODE 7 135 | # ifndef Z_SOLO 136 | # if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os 137 | # include /* for fdopen */ 138 | # else 139 | # ifndef fdopen 140 | # define fdopen(fd,mode) NULL /* No fdopen() */ 141 | # endif 142 | # endif 143 | # endif 144 | #endif 145 | 146 | #ifdef __acorn 147 | # define OS_CODE 13 148 | #endif 149 | 150 | #if defined(WIN32) && !defined(__CYGWIN__) 151 | # define OS_CODE 10 152 | #endif 153 | 154 | #ifdef _BEOS_ 155 | # define OS_CODE 16 156 | #endif 157 | 158 | #ifdef __TOS_OS400__ 159 | # define OS_CODE 18 160 | #endif 161 | 162 | #ifdef __APPLE__ 163 | # define OS_CODE 19 164 | #endif 165 | 166 | #if defined(_BEOS_) || defined(RISCOS) 167 | # define fdopen(fd,mode) NULL /* No fdopen() */ 168 | #endif 169 | 170 | #if (defined(_MSC_VER) && (_MSC_VER > 600)) && !defined __INTERIX 171 | # if defined(_WIN32_WCE) 172 | # define fdopen(fd,mode) NULL /* No fdopen() */ 173 | # ifndef _PTRDIFF_T_DEFINED 174 | typedef int ptrdiff_t; 175 | # define _PTRDIFF_T_DEFINED 176 | # endif 177 | # else 178 | # define fdopen(fd,type) _fdopen(fd,type) 179 | # endif 180 | #endif 181 | 182 | #if defined(__BORLANDC__) && !defined(MSDOS) 183 | #pragma warn -8004 184 | #pragma warn -8008 185 | #pragma warn -8066 186 | #endif 187 | 188 | /* provide prototypes for these when building zlib without LFS */ 189 | #if !defined(_WIN32) && \ 190 | (!defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0) 191 | ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t)); 192 | ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t)); 193 | #endif 194 | 195 | /* common defaults */ 196 | 197 | #ifndef OS_CODE 198 | # define OS_CODE 3 /* assume Unix */ 199 | #endif 200 | 201 | #ifndef F_OPEN 202 | # define F_OPEN(name, mode) fopen((name), (mode)) 203 | #endif 204 | 205 | /* functions */ 206 | 207 | #if defined(pyr) || defined(Z_SOLO) 208 | # define NO_MEMCPY 209 | #endif 210 | #if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__) 211 | /* Use our own functions for small and medium model with MSC <= 5.0. 212 | * You may have to use the same strategy for Borland C (untested). 213 | * The __SC__ check is for Symantec. 214 | */ 215 | # define NO_MEMCPY 216 | #endif 217 | #if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY) 218 | # define HAVE_MEMCPY 219 | #endif 220 | #ifdef HAVE_MEMCPY 221 | # ifdef SMALL_MEDIUM /* MSDOS small or medium model */ 222 | # define zmemcpy _fmemcpy 223 | # define zmemcmp _fmemcmp 224 | # define zmemzero(dest, len) _fmemset(dest, 0, len) 225 | # else 226 | # define zmemcpy memcpy 227 | # define zmemcmp memcmp 228 | # define zmemzero(dest, len) memset(dest, 0, len) 229 | # endif 230 | #else 231 | void ZLIB_INTERNAL zmemcpy OF((Bytef* dest, const Bytef* source, uInt len)); 232 | int ZLIB_INTERNAL zmemcmp OF((const Bytef* s1, const Bytef* s2, uInt len)); 233 | void ZLIB_INTERNAL zmemzero OF((Bytef* dest, uInt len)); 234 | #endif 235 | 236 | /* Diagnostic functions */ 237 | #ifdef ZLIB_DEBUG 238 | # include 239 | extern int ZLIB_INTERNAL z_verbose; 240 | extern void ZLIB_INTERNAL z_error OF((char *m)); 241 | # define Assert(cond,msg) {if(!(cond)) z_error(msg);} 242 | # define Trace(x) {if (z_verbose>=0) fprintf x ;} 243 | # define Tracev(x) {if (z_verbose>0) fprintf x ;} 244 | # define Tracevv(x) {if (z_verbose>1) fprintf x ;} 245 | # define Tracec(c,x) {if (z_verbose>0 && (c)) fprintf x ;} 246 | # define Tracecv(c,x) {if (z_verbose>1 && (c)) fprintf x ;} 247 | #else 248 | # define Assert(cond,msg) 249 | # define Trace(x) 250 | # define Tracev(x) 251 | # define Tracevv(x) 252 | # define Tracec(c,x) 253 | # define Tracecv(c,x) 254 | #endif 255 | 256 | #ifndef Z_SOLO 257 | voidpf ZLIB_INTERNAL zcalloc OF((voidpf opaque, unsigned items, 258 | unsigned size)); 259 | void ZLIB_INTERNAL zcfree OF((voidpf opaque, voidpf ptr)); 260 | #endif 261 | 262 | #define ZALLOC(strm, items, size) \ 263 | (*((strm)->zalloc))((strm)->opaque, (items), (size)) 264 | #define ZFREE(strm, addr) (*((strm)->zfree))((strm)->opaque, (voidpf)(addr)) 265 | #define TRY_FREE(s, p) {if (p) ZFREE(s, p);} 266 | 267 | /* Reverse the bytes in a 32-bit value */ 268 | #define ZSWAP32(q) ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \ 269 | (((q) & 0xff00) << 8) + (((q) & 0xff) << 24)) 270 | 271 | #endif /* ZUTIL_H */ 272 | -------------------------------------------------------------------------------- /src/aes.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #include "aes.hpp" 6 | #include "utils.hpp" 7 | 8 | // Rijndael S-box 9 | static std::uint8_t sbox[256]; 10 | static std::uint8_t inv_sbox[256]; 11 | 12 | static std::uint8_t mul2 [256]; 13 | static std::uint8_t mul3 [256]; 14 | static std::uint8_t mul9 [256]; 15 | static std::uint8_t mul11[256]; 16 | static std::uint8_t mul13[256]; 17 | static std::uint8_t mul14[256]; 18 | 19 | static std::uint8_t rcon[256]; 20 | 21 | static std::uint8_t gmul(std::uint8_t a, std::uint8_t b) { 22 | std::uint8_t p = 0; 23 | 24 | for (int i = 0; i < 8; i++) { 25 | if (b & 1) 26 | p ^= a; 27 | 28 | bool hi_bit_set = a & 0x80; 29 | a <<= 1; 30 | if (hi_bit_set) 31 | a ^= 0x1b; 32 | 33 | b >>= 1; 34 | } 35 | 36 | return p; 37 | } 38 | 39 | static void build_tables() { 40 | static bool built_tables = false; 41 | if (built_tables) 42 | return; 43 | 44 | built_tables = true; 45 | 46 | // Build the S-box 47 | std::uint8_t p = 1, q = 1; 48 | 49 | do { 50 | p = p ^ (p << 1) ^ (p & 0x80 ? 0x1B : 0x00); 51 | 52 | q ^= q << 1; 53 | q ^= q << 2; 54 | q ^= q << 4; 55 | q ^= q & 0x80 ? 0x09 : 0x00; 56 | 57 | std::uint8_t xformed = (q ^ rotl(q, 1) ^ rotl(q, 2) ^ rotl(q, 3) ^ rotl(q, 4)) ^ 0x63; 58 | sbox[p] = xformed; 59 | inv_sbox[xformed] = p; 60 | } while(p != 1); 61 | 62 | sbox [0x00] = 0x63; 63 | inv_sbox[0x63] = 0x00; 64 | 65 | // Multiplication Tables 66 | for (int i = 0; i < 256; i++) { 67 | mul2 [i] = gmul(i, 2); 68 | mul3 [i] = gmul(i, 3); 69 | mul9 [i] = gmul(i, 9); 70 | mul11[i] = gmul(i, 11); 71 | mul13[i] = gmul(i, 13); 72 | mul14[i] = gmul(i, 14); 73 | } 74 | 75 | for (int i = 1; i < 256; i++) { 76 | rcon[i] = 1; 77 | 78 | for (int j = i; j != 1; j--) 79 | rcon[i] = gmul(rcon[i], 2); 80 | } 81 | } 82 | 83 | AES::AES(const std::uint8_t *key, const std::uint8_t *iv) { 84 | build_tables(); 85 | expand_key(key); 86 | 87 | std::copy_n(iv, block_len, this->iv); 88 | } 89 | 90 | void AES::cbc_encrypt(void *data, std::size_t size, void *result) { 91 | assert(size % block_len == 0); 92 | auto in = static_cast(data); 93 | auto out = static_cast(result); 94 | std::uint8_t *iv = this->iv; 95 | 96 | for (std::size_t i = 0; i < size; i += block_len) { 97 | xor_with_iv(in, iv); 98 | encrypt_block(in, out); 99 | 100 | iv = out; 101 | in += block_len; 102 | out += block_len; 103 | } 104 | 105 | std::copy_n(iv, block_len, this->iv); 106 | } 107 | 108 | void AES::cbc_decrypt(void *data, std::size_t size, void *result) { 109 | assert(size % block_len == 0); 110 | auto in = static_cast(data); 111 | auto out = static_cast(result); 112 | std::uint8_t *iv = this->iv; 113 | 114 | for (std::size_t i = 0; i < size; i += block_len) { 115 | decrypt_block(in, out); 116 | xor_with_iv(out, iv); 117 | 118 | iv = in; 119 | in += block_len; 120 | out += block_len; 121 | } 122 | 123 | std::copy_n(iv, block_len, this->iv); 124 | } 125 | 126 | inline void AES::add_round_key(State state, const State round_key, int round) { 127 | for (int i = 0; i < 0x10; i++) 128 | state[i] ^= round_key[(round * 16) + i]; 129 | } 130 | 131 | inline void AES::sub_bytes(State state) { 132 | for (int i = 0; i < 0x10; i++) 133 | state[i] = sbox[state[i]]; 134 | } 135 | 136 | inline void AES::shift_rows(State state) { 137 | State tmp; 138 | 139 | // Column 1 140 | tmp[0x00] = state[0x00]; 141 | tmp[0x01] = state[0x05]; 142 | tmp[0x02] = state[0x0a]; 143 | tmp[0x03] = state[0x0f]; 144 | 145 | // Column 2 146 | tmp[0x04] = state[0x04]; 147 | tmp[0x05] = state[0x09]; 148 | tmp[0x06] = state[0x0e]; 149 | tmp[0x07] = state[0x03]; 150 | 151 | // Column 3 152 | tmp[0x08] = state[0x08]; 153 | tmp[0x09] = state[0x0d]; 154 | tmp[0x0a] = state[0x02]; 155 | tmp[0x0b] = state[0x07]; 156 | 157 | // Column 4 158 | tmp[0x0c] = state[0x0c]; 159 | tmp[0x0d] = state[0x01]; 160 | tmp[0x0e] = state[0x06]; 161 | tmp[0x0f] = state[0x0b]; 162 | 163 | std::copy_n(tmp, block_len, state); 164 | } 165 | 166 | inline void AES::mix_columns(State state) { 167 | State tmp; 168 | 169 | // Column 1 170 | tmp[0x00] = mul2[state[0]] ^ mul3[state[1]] ^ state[2] ^ state[3]; 171 | tmp[0x01] = state[0] ^ mul2[state[1]] ^ mul3[state[2]] ^ state[3]; 172 | tmp[0x02] = state[0] ^ state[1] ^ mul2[state[2]] ^ mul3[state[3]]; 173 | tmp[0x03] = mul3[state[0]] ^ state[1] ^ state[2] ^ mul2[state[3]]; 174 | 175 | // Column 2 176 | tmp[0x04] = mul2[state[4]] ^ mul3[state[5]] ^ state[6] ^ state[7]; 177 | tmp[0x05] = state[4] ^ mul2[state[5]] ^ mul3[state[6]] ^ state[7]; 178 | tmp[0x06] = state[4] ^ state[5] ^ mul2[state[6]] ^ mul3[state[7]]; 179 | tmp[0x07] = mul3[state[4]] ^ state[5] ^ state[6] ^ mul2[state[7]]; 180 | 181 | // Column 3 182 | tmp[0x08] = mul2[state[8]] ^ mul3[state[9]] ^ state[10] ^ state[11]; 183 | tmp[0x09] = state[8] ^ mul2[state[9]] ^ mul3[state[10]] ^ state[11]; 184 | tmp[0x0a] = state[8] ^ state[9] ^ mul2[state[10]] ^ mul3[state[11]]; 185 | tmp[0x0b] = mul3[state[8]] ^ state[9] ^ state[10] ^ mul2[state[11]]; 186 | 187 | // Column 4 188 | tmp[0x0c] = mul2[state[12]] ^ mul3[state[13]] ^ state[14] ^ state[15]; 189 | tmp[0x0d] = state[12] ^ mul2[state[13]] ^ mul3[state[14]] ^ state[15]; 190 | tmp[0x0e] = state[12] ^ state[13] ^ mul2[state[14]] ^ mul3[state[15]]; 191 | tmp[0x0f] = mul3[state[12]] ^ state[13] ^ state[14] ^ mul2[state[15]]; 192 | 193 | std::copy_n(tmp, block_len, state); 194 | } 195 | 196 | inline void AES::inverse_sub_bytes(State state) { 197 | for (int i = 0; i < 0x10; i++) 198 | state[i] = inv_sbox[state[i]]; 199 | } 200 | 201 | inline void AES::inverse_shift_rows(State state) { 202 | State tmp; 203 | 204 | // Column 1 205 | tmp[0x00] = state[0x00]; 206 | tmp[0x01] = state[0x0d]; 207 | tmp[0x02] = state[0x0a]; 208 | tmp[0x03] = state[0x07]; 209 | 210 | // Column 2 211 | tmp[0x04] = state[0x04]; 212 | tmp[0x05] = state[0x01]; 213 | tmp[0x06] = state[0x0e]; 214 | tmp[0x07] = state[0x0b]; 215 | 216 | // Column 3 217 | tmp[0x08] = state[0x08]; 218 | tmp[0x09] = state[0x05]; 219 | tmp[0x0a] = state[0x02]; 220 | tmp[0x0b] = state[0x0f]; 221 | 222 | // Column 4 223 | tmp[0x0c] = state[0x0c]; 224 | tmp[0x0d] = state[0x09]; 225 | tmp[0x0e] = state[0x06]; 226 | tmp[0x0f] = state[0x03]; 227 | 228 | std::copy_n(tmp, block_len, state); 229 | } 230 | 231 | inline void AES::inverse_mix_columns(State state) { 232 | State tmp; 233 | 234 | tmp[0x00] = mul14[state[0]] ^ mul11[state[1]] ^ mul13[state[2]] ^ mul9[state[3]]; 235 | tmp[0x01] = mul9[state[0]] ^ mul14[state[1]] ^ mul11[state[2]] ^ mul13[state[3]]; 236 | tmp[0x02] = mul13[state[0]] ^ mul9[state[1]] ^ mul14[state[2]] ^ mul11[state[3]]; 237 | tmp[0x03] = mul11[state[0]] ^ mul13[state[1]] ^ mul9[state[2]] ^ mul14[state[3]]; 238 | 239 | tmp[0x04] = mul14[state[4]] ^ mul11[state[5]] ^ mul13[state[6]] ^ mul9[state[7]]; 240 | tmp[0x05] = mul9[state[4]] ^ mul14[state[5]] ^ mul11[state[6]] ^ mul13[state[7]]; 241 | tmp[0x06] = mul13[state[4]] ^ mul9[state[5]] ^ mul14[state[6]] ^ mul11[state[7]]; 242 | tmp[0x07] = mul11[state[4]] ^ mul13[state[5]] ^ mul9[state[6]] ^ mul14[state[7]]; 243 | 244 | tmp[0x08] = mul14[state[8]] ^ mul11[state[9]] ^ mul13[state[10]] ^ mul9[state[11]]; 245 | tmp[0x09] = mul9[state[8]] ^ mul14[state[9]] ^ mul11[state[10]] ^ mul13[state[11]]; 246 | tmp[0x0a] = mul13[state[8]] ^ mul9[state[9]] ^ mul14[state[10]] ^ mul11[state[11]]; 247 | tmp[0x0b] = mul11[state[8]] ^ mul13[state[9]] ^ mul9[state[10]] ^ mul14[state[11]]; 248 | 249 | tmp[0x0c] = mul14[state[12]] ^ mul11[state[13]] ^ mul13[state[14]] ^ mul9[state[15]]; 250 | tmp[0x0d] = mul9[state[12]] ^ mul14[state[13]] ^ mul11[state[14]] ^ mul13[state[15]]; 251 | tmp[0x0e] = mul13[state[12]] ^ mul9[state[13]] ^ mul14[state[14]] ^ mul11[state[15]]; 252 | tmp[0x0f] = mul11[state[12]] ^ mul13[state[13]] ^ mul9[state[14]] ^ mul14[state[15]]; 253 | 254 | std::copy_n(tmp, block_len, state); 255 | } 256 | 257 | inline void AES::xor_with_iv(std::uint8_t *data, const std::uint8_t *iv) { 258 | for (std::size_t i = 0; i < block_len; i++) 259 | data[i] ^= iv[i]; 260 | } 261 | 262 | void AES::encrypt_block(const std::uint8_t *in, std::uint8_t *out) { 263 | State state; 264 | std::copy_n(in, block_len, state); 265 | 266 | add_round_key(state, expanded_key, 0); 267 | for (int i = 0; i < 13; i++) { 268 | sub_bytes(state); 269 | shift_rows(state); 270 | mix_columns(state); 271 | add_round_key(state, expanded_key, i+1); 272 | } 273 | 274 | sub_bytes(state); 275 | shift_rows(state); 276 | add_round_key(state, expanded_key, 14); 277 | 278 | std::copy_n(state, block_len, out); 279 | } 280 | 281 | void AES::decrypt_block(const std::uint8_t *in, std::uint8_t *out) { 282 | State state; 283 | std::copy_n(in, block_len, state); 284 | 285 | add_round_key(state, expanded_key, 14); 286 | for (int i = 12; i >= 0; i--) { 287 | inverse_shift_rows(state); 288 | inverse_sub_bytes(state); 289 | add_round_key(state, expanded_key, i+1); 290 | inverse_mix_columns(state); 291 | } 292 | 293 | inverse_shift_rows(state); 294 | inverse_sub_bytes(state); 295 | add_round_key(state, expanded_key, 0); 296 | 297 | std::copy_n(state, block_len, out); 298 | } 299 | 300 | void AES::schedule_core(std::uint8_t *in, unsigned int i) { 301 | std::uint8_t t = in[0]; 302 | in[0] = in[1]; 303 | in[1] = in[2]; 304 | in[2] = in[3]; 305 | in[3] = t; 306 | 307 | in[0] = sbox[in[0]]; 308 | in[1] = sbox[in[1]]; 309 | in[2] = sbox[in[2]]; 310 | in[3] = sbox[in[3]]; 311 | 312 | in[0] ^= rcon[i]; 313 | } 314 | 315 | void AES::expand_key(const std::uint8_t *in) { 316 | std::copy_n(in, 32, expanded_key); 317 | 318 | std::uint8_t t[4]; 319 | std::uint8_t c = 32; 320 | std::uint8_t i = 1; 321 | 322 | while (c < 240) { 323 | for (int a = 0; a < 4; a++) 324 | t[a] = expanded_key[a + c - 4]; 325 | 326 | if ((c & 31) == 0) 327 | schedule_core(t, i++); 328 | 329 | if ((c & 31) == 16) { 330 | for (int a = 0; a < 4; a++) 331 | t[a] = sbox[t[a]]; 332 | } 333 | 334 | for (int a = 0; a < 4; a++) { 335 | expanded_key[c] = expanded_key[c - 32] ^ t[a]; 336 | c++; 337 | } 338 | } 339 | } 340 | -------------------------------------------------------------------------------- /src/aes.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | class AES 6 | { 7 | public: 8 | // Note: Never use the same IV with the same key 9 | AES(const std::uint8_t *key, const std::uint8_t *iv); 10 | 11 | // All data must be padded to be a multiple of 16-bytes. Try #PKCS7 12 | void cbc_encrypt(void *data, std::size_t size, void *result); 13 | void cbc_decrypt(void *data, std::size_t size, void *result); 14 | 15 | private: 16 | using State = std::uint8_t[16]; 17 | 18 | static const unsigned int block_len = 16; // 128 bits 19 | 20 | inline void add_round_key(State state, const State round_key, int round); 21 | inline void sub_bytes(State state); 22 | inline void shift_rows(State state); 23 | inline void mix_columns(State state); 24 | 25 | inline void inverse_sub_bytes(State state); 26 | inline void inverse_shift_rows(State state); 27 | inline void inverse_mix_columns(State state); 28 | 29 | inline void xor_with_iv(std::uint8_t *data, const std::uint8_t *iv); 30 | 31 | void encrypt_block(const std::uint8_t *in, std::uint8_t *out); 32 | void decrypt_block(const std::uint8_t *in, std::uint8_t *out); 33 | 34 | void schedule_core(std::uint8_t *in, unsigned int i); 35 | void expand_key(const std::uint8_t *in); 36 | 37 | std::uint8_t expanded_key[240]; 38 | std::uint8_t iv[block_len]; 39 | }; 40 | -------------------------------------------------------------------------------- /src/crc32.cpp: -------------------------------------------------------------------------------- 1 | #include "crc32.hpp" 2 | 3 | static const std::uint32_t crc_table[256] = { 4 | 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 5 | 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, 6 | 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 7 | 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 8 | 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 9 | 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 10 | 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 11 | 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, 12 | 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 13 | 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 14 | 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 15 | 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 16 | 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 17 | 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f, 18 | 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 19 | 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 20 | 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 21 | 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433, 22 | 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 23 | 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 24 | 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 25 | 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 26 | 0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 27 | 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, 28 | 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 29 | 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 30 | 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 31 | 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 32 | 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 33 | 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, 34 | 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 35 | 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 36 | 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 37 | 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 38 | 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 39 | 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 40 | 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 41 | 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, 42 | 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 43 | 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 44 | 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 45 | 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 46 | 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 47 | 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79, 48 | 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 49 | 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 50 | 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 51 | 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, 52 | 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 53 | 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, 54 | 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 55 | 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 56 | 0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 57 | 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, 58 | 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 59 | 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 60 | 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 61 | 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 62 | 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 63 | 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, 64 | 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 65 | 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf, 66 | 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 67 | 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d 68 | }; 69 | 70 | CRC32::CRC32() : hash(0xFFFFFFFF) { 71 | } 72 | 73 | void CRC32::update(const void *data, std::size_t size) { 74 | auto buffer = reinterpret_cast(data); 75 | 76 | for (std::size_t i = 0; i < size; i++) { 77 | hash = crc_table[(hash ^ buffer[i]) & 0xFF] ^ (hash >> 8); 78 | } 79 | } 80 | 81 | std::uint32_t CRC32::get_hash() const { 82 | return hash ^ 0xFFFFFFFF; 83 | } 84 | -------------------------------------------------------------------------------- /src/crc32.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | class CRC32 7 | { 8 | public: 9 | CRC32(); 10 | 11 | void update(const void *data, std::size_t size); 12 | std::uint32_t get_hash() const; 13 | 14 | private: 15 | std::uint32_t hash; 16 | }; 17 | -------------------------------------------------------------------------------- /src/image.cpp: -------------------------------------------------------------------------------- 1 | #include "image.hpp" 2 | #include "stb/stb_image.h" 3 | #include "stb/stb_image_write.h" 4 | 5 | #include 6 | 7 | Image::Image() : width(0), height(0) { 8 | } 9 | 10 | bool Image::load(const std::string &path) { 11 | int x, y, n = 4; 12 | 13 | auto *buffer = stbi_load(path.c_str(), &x, &y, &n, n); 14 | if (!buffer) 15 | return false; 16 | 17 | image = std::make_unique(x * y * 4); 18 | std::copy_n(buffer, x * y * 4, image.get()); 19 | stbi_image_free(buffer); 20 | 21 | width = x; 22 | height = y; 23 | 24 | return true; 25 | } 26 | 27 | bool Image::save(const std::string &path) { 28 | int result = stbi_write_png(path.c_str(), width, height, 4, image.get(), width * 4); 29 | 30 | return result != 0; 31 | } 32 | 33 | void Image::encode(const std::uint8_t *data, std::size_t size, EncodingLevel level, std::size_t offset) { 34 | auto image = this->image.get() + offset; 35 | 36 | if (level == EncodingLevel::Low) { 37 | for (auto i = 0; i < size; i++, image += 8) { 38 | image[0] = (image[0] & ~0b1) | ((data[i] >> 0) & 0b1); 39 | image[1] = (image[1] & ~0b1) | ((data[i] >> 1) & 0b1); 40 | image[2] = (image[2] & ~0b1) | ((data[i] >> 2) & 0b1); 41 | image[3] = (image[3] & ~0b1) | ((data[i] >> 3) & 0b1); 42 | image[4] = (image[4] & ~0b1) | ((data[i] >> 4) & 0b1); 43 | image[5] = (image[5] & ~0b1) | ((data[i] >> 5) & 0b1); 44 | image[6] = (image[6] & ~0b1) | ((data[i] >> 6) & 0b1); 45 | image[7] = (image[7] & ~0b1) | ((data[i] >> 7) & 0b1); 46 | } 47 | } 48 | 49 | else if (level == EncodingLevel::Med) { 50 | for (auto i = 0; i < size; i++, image += 4) { 51 | image[0] = (image[0] & ~0b11) | ((data[i] >> 0) & 0b11); 52 | image[1] = (image[1] & ~0b11) | ((data[i] >> 2) & 0b11); 53 | image[2] = (image[2] & ~0b11) | ((data[i] >> 4) & 0b11); 54 | image[3] = (image[3] & ~0b11) | ((data[i] >> 6) & 0b11); 55 | } 56 | } 57 | 58 | // High 59 | else { 60 | for (auto i = 0; i < size / 2; i++, image += 4, data += 2) { 61 | image[0] = (image[0] & ~0xf) | (data[0] & 0xf); 62 | image[1] = (image[1] & ~0xf) | (data[0] >> 4); 63 | image[2] = (image[2] & ~0xf) | (data[1] & 0xf); 64 | image[3] = (image[3] & ~0xf) | (data[1] >> 4); 65 | } 66 | 67 | if (size % 2) { 68 | image[0] = (image[0] & ~0xf) | (*data & 0xf); 69 | image[1] = (image[1] & ~0xf) | (*data >> 4); 70 | } 71 | } 72 | } 73 | 74 | std::unique_ptr Image::decode(std::size_t size, EncodingLevel level, std::size_t offset) { 75 | auto data = std::make_unique(size); 76 | auto image = this->image.get() + offset; 77 | 78 | if (level == EncodingLevel::Low) { 79 | for (auto i = 0; i < size; i++, image += 8) { 80 | data[i] = ((image[0] & 0b1) << 0) | ((image[1] & 0b1) << 1) | 81 | ((image[2] & 0b1) << 2) | ((image[3] & 0b1) << 3) | 82 | ((image[4] & 0b1) << 4) | ((image[5] & 0b1) << 5) | 83 | ((image[6] & 0b1) << 6) | ((image[7] & 0b1) << 7); 84 | } 85 | } 86 | 87 | else if (level == EncodingLevel::Med) { 88 | for (auto i = 0; i < size; i++, image += 4) { 89 | data[i] = ((image[0] & 0b11) << 0) | ((image[1] & 0b11) << 2) | 90 | ((image[2] & 0b11) << 4) | ((image[3] & 0b11) << 6); 91 | } 92 | } 93 | 94 | // High 95 | else { 96 | auto buffer = data.get(); 97 | 98 | for (auto i = 0; i < size / 2; i++, image += 4, buffer += 2) { 99 | buffer[0] = (image[0] & 0xf) | (image[1] << 4); 100 | buffer[1] = (image[2] & 0xf) | (image[3] << 4); 101 | } 102 | 103 | if (size % 2) 104 | *buffer = (image[0] & 0xf) | (image[1] << 4); 105 | } 106 | 107 | return data; 108 | } 109 | 110 | std::size_t Image::encoded_size(std::size_t size, EncodingLevel level) { 111 | if (level == EncodingLevel::Low) 112 | return size * 8; 113 | 114 | else if (level == EncodingLevel::Med) 115 | return size * 4; 116 | 117 | // High 118 | return size * 2; 119 | } 120 | -------------------------------------------------------------------------------- /src/image.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | class Image 8 | { 9 | public: 10 | enum class EncodingLevel { 11 | Low = 0, 12 | Med = 1, 13 | High = 2, 14 | }; 15 | 16 | Image(); 17 | 18 | bool load(const std::string &path); 19 | bool save(const std::string &path); 20 | 21 | void encode(const std::uint8_t *data, std::size_t size, EncodingLevel level, std::size_t offset = 0); 22 | std::unique_ptr decode(std::size_t size, EncodingLevel level, std::size_t offset = 0); 23 | 24 | static std::size_t encoded_size(std::size_t size, EncodingLevel level); 25 | 26 | unsigned int w() const { return width; } 27 | unsigned int h() const { return height; } 28 | 29 | private: 30 | std::unique_ptr image; 31 | unsigned int width, height; 32 | }; 33 | -------------------------------------------------------------------------------- /src/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | #include "argparse/argparse.hpp" 8 | #include "aes.hpp" 9 | #include "sha256.hpp" 10 | #include "crc32.hpp" 11 | #include "random.hpp" 12 | #include "image.hpp" 13 | #include "utils.hpp" 14 | 15 | #define VERSION 1 16 | #define KEY_ROUNDS 20000 17 | #define LEVEL Image::EncodingLevel::Low 18 | 19 | namespace fs = std::filesystem; 20 | 21 | // 64 bytes 22 | struct Header { 23 | // std::uint8_t salt[16]; 24 | // std::uint8_t iv [16]; 25 | std::uint8_t sig[4]; // File Signature (HIDE) 26 | std::uint16_t version; // Format Version 27 | std::uint8_t level; // Encoding level 28 | std::uint8_t flags; // Flags 29 | std::uint32_t offset; // Offset to data 30 | std::uint32_t size; // Size of data 31 | std::uint32_t hash; // CRC32 hash of data 32 | std::uint8_t name[32]; // File name, unused space filled with zeros 33 | std::uint8_t reserved[12]; // Must be filled with zeros 34 | }; 35 | static_assert(sizeof(Header) == 64); 36 | 37 | const char *level_to_str[3] = { 38 | "Low (Default)", 39 | "Medium", 40 | "High" 41 | }; 42 | 43 | int encode(Image &image, const std::array &password, const std::string &input, const std::string &output, Image::EncodingLevel level) { 44 | // Open the data file 45 | std::ifstream file(input, std::ios::in | std::ios::binary | std::ios::ate); 46 | if (!file.is_open()) { 47 | std::cerr << "ERROR: Unable to open file '" << input << "'" << std::endl; 48 | return -1; 49 | } 50 | 51 | std::cout << "* Image size: " << image.w() << "x" << image.h() << " pixels" << std::endl; 52 | std::cout << "* Encoding level: " << level_to_str[static_cast(level)] << std::endl; 53 | 54 | // Find the data and padded-data size 55 | std::size_t size = file.tellg(); 56 | std::size_t padded_size = size + 1; // At least one byte of padding 57 | 58 | if (padded_size % 16) 59 | padded_size = (size / 16 + 1) * 16; 60 | 61 | // Find the maximum possible size for the file 62 | unsigned int max_size = image.w()*image.h()*4/Image::encoded_size(1, level) - Image::encoded_size(sizeof(Header)+32, Image::EncodingLevel::Low); // FIXME 63 | 64 | std::cout << "* Max embed size: " << data_size(max_size) << std::endl; 65 | std::cout << "* Embed size: " << data_size(size) << std::endl; 66 | std::cout << "* Encrypted embed size: " << data_size(padded_size) << std::endl; 67 | 68 | // Make sure that it isn't too big 69 | if (padded_size > max_size) { 70 | std::cerr << "ERROR: Data-File too big, maximum possible size: " << (max_size / 1024) << " KiB" << std::endl; 71 | return -1; 72 | } 73 | 74 | // Read the data 75 | auto padded_data = std::make_unique(padded_size); 76 | file.seekg(0, std::ios::beg); 77 | file.read(reinterpret_cast(padded_data.get()), size); 78 | file.close(); 79 | 80 | // Pad the data (#PKCS7) 81 | std::uint8_t left = padded_size - size; 82 | std::fill_n(padded_data.get() + size, left, left); 83 | 84 | // Pick a random offset inside the image to store the data 85 | std::uint32_t offset; 86 | Random random; 87 | if (!random.get(&offset, sizeof(offset))) 88 | { 89 | std::cerr << "Unable to generate random number" << std::endl; 90 | return -1; 91 | } 92 | 93 | offset = (offset + Image::encoded_size(sizeof(Header) + 32, Image::EncodingLevel::Low)) % (Image::encoded_size(max_size - padded_size, level)); 94 | 95 | // Calculate a hash of the data 96 | CRC32 crc; 97 | crc.update(padded_data.get(), size); 98 | 99 | std::cout << "* Generated CRC32 checksum" << std::endl; 100 | 101 | // Copy the header information 102 | Header header; 103 | header.sig[0] = 'H'; header.sig[1] = 'I'; header.sig[2] = 'D'; header.sig[3] = 'E'; 104 | header.version = VERSION; 105 | header.level = static_cast(level); 106 | header.flags = 0; 107 | header.offset = offset; 108 | header.size = padded_size; 109 | header.hash = crc.get_hash(); 110 | 111 | // Copy the file name to the header 112 | auto name = fs::path(input).filename().string(); 113 | if (name.size() > sizeof(header.name)) { 114 | std::cerr << "ERROR: File name '" << name << "' is over 32 characters" << std::endl; 115 | return -1; 116 | } 117 | std::copy_n(name.data(), name.size(), header.name); 118 | std::fill_n(&header.name[name.size()], sizeof(header.name) - name.size(), 0x00); 119 | std::fill_n(header.reserved, sizeof(header.reserved), 0x00); 120 | 121 | // Generate the Salt and IV 122 | std::uint8_t salt[16], iv[16]; 123 | if (!random.get(salt, sizeof salt) || !random.get(iv, sizeof iv)) 124 | { 125 | std::cerr << "ERROR: Unable to generate random number" << std::endl; 126 | return -1; 127 | } 128 | 129 | // Generate the Key 130 | std::uint8_t key[32]; 131 | pbkdf2_hmac_sha256(password.data(), password.size(), salt, sizeof(salt), key, sizeof(key), KEY_ROUNDS); 132 | 133 | std::cout << "* Generated encryption key with PBKDF2-HMAC-SHA-256 (" << KEY_ROUNDS << " rounds)" << std::endl; 134 | 135 | // Encrypt the header 136 | AES aes(key, iv); 137 | auto encrypted_header = std::make_unique(sizeof header); 138 | aes.cbc_encrypt(&header, sizeof(header), encrypted_header.get()); 139 | 140 | // Encrypt the data 141 | auto encrypted_data = std::make_unique(padded_size); 142 | aes.cbc_encrypt(padded_data.get(), padded_size, encrypted_data.get()); 143 | 144 | std::cout << "* Encrypted embed with AES-256-CBC" << std::endl; 145 | 146 | // Encode the data 147 | image.encode(salt, 16, level); 148 | image.encode(iv, 16, level, Image::encoded_size(16, Image::EncodingLevel::Low)); 149 | image.encode(encrypted_header.get(), sizeof(Header), level, Image::encoded_size(32, Image::EncodingLevel::Low)); 150 | image.encode(encrypted_data.get(), padded_size, level, offset); 151 | 152 | std::cout << "* Embedded " << name << " into image" << std::endl; 153 | 154 | // Save the encoded image 155 | if (!image.save(output)) { 156 | std::cout << "Unable to save image!" << std::endl; 157 | return false; 158 | } 159 | 160 | std::cout << "* Successfully wrote to " << output << std::endl; 161 | 162 | return true; 163 | } 164 | 165 | int decode(Image &image, const std::array &password, std::string output) { 166 | std::cout << "* Image size: " << image.w() << "x" << image.h() << " pixels" << std::endl; 167 | 168 | // Extract the Salt and IV 169 | auto salt = image.decode(16, Image::EncodingLevel::Low); 170 | auto iv = image.decode(16, Image::EncodingLevel::Low, Image::encoded_size(16, Image::EncodingLevel::Low)); 171 | 172 | // Generate the key 173 | std::uint8_t key[32]; 174 | pbkdf2_hmac_sha256(password.data(), password.size(), salt.get(), 16, key, sizeof(key), KEY_ROUNDS); 175 | 176 | std::cout << "* Generated decryption key with PBKDF2-HMAC-SHA-256 (" << KEY_ROUNDS << " rounds)" << std::endl; 177 | 178 | // Extract the header 179 | auto encrypted_header = image.decode(sizeof(Header), Image::EncodingLevel::Low, Image::encoded_size(32, Image::EncodingLevel::Low)); 180 | 181 | // Decrypt the header 182 | AES aes(key, iv.get()); 183 | Header header; 184 | aes.cbc_decrypt(encrypted_header.get(), sizeof(Header), &header); 185 | auto level = static_cast(header.level); 186 | 187 | // Make sure that the file-signature match, i.e. successful decryption 188 | if (header.sig[0] != 'H' || header.sig[1] != 'I' || header.sig[2] != 'D' || header.sig[3] != 'E') { 189 | std::cerr << "ERROR: Decryption failed, invalid key or corrupt file" << std::endl; 190 | return -1; 191 | } 192 | 193 | // Make sure that the version is correct 194 | if (header.version != VERSION) { 195 | std::cerr << "ERROR: Unsupported file-version " << header.version << std::endl; 196 | return -1; 197 | } 198 | 199 | // Make sure that the reserved data is all zeros 200 | for (auto r : header.reserved) { 201 | if (r) { 202 | std::cerr << "ERROR: Decryption failed, invalid key or corrupt file" << std::endl; 203 | return -1; 204 | } 205 | } 206 | 207 | std::cout << "* Successfully decrypted header" << std::endl; 208 | std::cout << "* File signatures match" << std::endl; 209 | 210 | // Copy the name, accounting for the fact that there might be no null-terminator 211 | std::string name; 212 | if (header.name[sizeof(header.name)-1]) 213 | name = std::string(reinterpret_cast(header.name), sizeof(header.name)); 214 | else 215 | name = std::string(reinterpret_cast(header.name)); 216 | 217 | std::cout << "* Detected embed " << name << std::endl; 218 | std::cout << "* Encoding level: " << level_to_str[header.level] << std::endl; 219 | 220 | // Decode the data 221 | auto encrypted_data = image.decode(header.size, level, header.offset); 222 | 223 | std::cout << "* Encrypted embed size: " << data_size(header.size) << std::endl; 224 | 225 | // Decrypt the data 226 | auto padded_data = new std::uint8_t[header.size]; 227 | aes.cbc_decrypt(encrypted_data.get(), header.size, padded_data); 228 | 229 | std::cout << "* Successfully decrypted the embed" << std::endl; 230 | 231 | // Find how much padding to strip 232 | std::uint8_t left = padded_data[header.size - 1]; 233 | std::size_t size = header.size - left; 234 | 235 | std::cout << "* Decrypted embed size: " << data_size(size) << std::endl; 236 | 237 | // Calculate the CRC32 hash 238 | CRC32 crc; 239 | crc.update(padded_data, size); 240 | 241 | // Make sure that the data matches 242 | if (crc.get_hash() != header.hash) { 243 | std::cerr << "ERROR: File is corrupted!" << std::endl; 244 | return -1; 245 | } 246 | 247 | std::cout << "* CRC32 checksum matches" << std::endl; 248 | 249 | // If the output path is empty, just use the embedded file name 250 | if (output.empty()) 251 | output = name; 252 | 253 | // Open the output file 254 | std::ofstream file(output, std::ios::out | std::ios::binary); 255 | if (!file.is_open()) { 256 | std::cerr << "ERROR: Unable to save file '" << output << "'" << std::endl; 257 | return -1; 258 | } 259 | 260 | // Write the data 261 | file.write(reinterpret_cast(padded_data), size); 262 | file.close(); 263 | 264 | delete[] padded_data; 265 | 266 | std::cout << "* Successfully wrote to " << output << std::endl; 267 | 268 | return 0; 269 | } 270 | 271 | int main(int argc, char **argv) { 272 | // Main parser 273 | argparse::ArgumentParser program("steganography"); 274 | 275 | // Encode subcommand 276 | argparse::ArgumentParser encode_command("encode"); 277 | encode_command.add_description("Encodes an embed-file into an image"); 278 | 279 | encode_command.add_argument("-i", "--input") 280 | .required() 281 | .help("specify the input image."); 282 | 283 | encode_command.add_argument("-o", "--output") 284 | .required() 285 | .help("specify the output image."); 286 | 287 | encode_command.add_argument("-e", "--embed") 288 | .required() 289 | .help("specify the file to embed."); 290 | 291 | encode_command.add_argument("-p", "--passwd") 292 | .help("specify the encryption password."); 293 | 294 | // Decode subcommand 295 | argparse::ArgumentParser decode_command("decode"); 296 | decode_command.add_description("Decodes and extracts an embed-file from an image"); 297 | 298 | decode_command.add_argument("-i", "--input") 299 | .required() 300 | .help("specify the input image."); 301 | 302 | decode_command.add_argument("-o", "--output") 303 | .default_value(std::string("")) 304 | .help("specify the output file."); 305 | 306 | decode_command.add_argument("-p", "--passwd") 307 | .help("specify the encryption password."); 308 | 309 | // Add the subcommands to the main parser 310 | program.add_subparser(encode_command); 311 | program.add_subparser(decode_command); 312 | 313 | // Parse the arguments 314 | try { 315 | program.parse_args(argc, argv); 316 | } 317 | catch (const std::runtime_error &err) { 318 | std::cerr << err.what() << std::endl; 319 | std::cerr << program; 320 | return -1; 321 | } 322 | 323 | // Generates the password hash from a user string 324 | auto generate_password = [](const argparse::ArgumentParser &parser) -> std::array { 325 | // Get the password string 326 | std::string str; 327 | if (parser.is_used("--passwd")) { 328 | str = parser.get("--passwd"); 329 | } 330 | else { 331 | std::cout << "Password: "; 332 | std::getline(std::cin, str); 333 | } 334 | 335 | // Generate the password hash 336 | std::array hash; 337 | SHA256 sha; 338 | sha.update(str.data(), str.size()); 339 | sha.finish(); 340 | sha.get_hash(hash.data()); 341 | 342 | return hash; 343 | }; 344 | 345 | // Encode command 346 | if (program.is_subcommand_used("encode")) { 347 | auto input_path = encode_command.get("--input"); 348 | auto output_path = encode_command.get("--output"); 349 | auto embed_path = encode_command.get("--embed"); 350 | 351 | // Attempt to load the image 352 | Image image; 353 | if (!image.load(input_path)) { 354 | std::cerr << "ERROR: Failed to load image " << input_path << std::endl; 355 | return -1; 356 | } 357 | 358 | // Generate the password hash 359 | auto password = generate_password(encode_command); 360 | 361 | // Encode the image 362 | if (encode(image, password, embed_path, output_path, LEVEL) < 0) 363 | return -1; 364 | } 365 | 366 | // Decode command 367 | else if (program.is_subcommand_used("decode")) { 368 | auto input_path = decode_command.get("--input"); 369 | auto output_path = decode_command.get("--output"); 370 | 371 | // Attempt to load the image 372 | Image image; 373 | if (!image.load(input_path)) { 374 | std::cerr << "ERROR: Failed to load image " << input_path << std::endl; 375 | return -1; 376 | } 377 | 378 | // Generate the password hash 379 | auto password = generate_password(decode_command); 380 | 381 | // Decode the image 382 | if (decode(image, password, output_path) < 0) 383 | return -1; 384 | } 385 | 386 | // No subcommands were given 387 | else { 388 | std::cerr << program << std::endl; 389 | } 390 | 391 | return 0; 392 | } 393 | -------------------------------------------------------------------------------- /src/random.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #if defined(__linux__) || defined(__APPLE__) 6 | #elif defined(_WIN32) 7 | #include 8 | #include 9 | #pragma comment( lib, "Bcrypt" ) 10 | #else 11 | #error "Unsupported OS" 12 | #endif 13 | 14 | 15 | class Random 16 | { 17 | 18 | #if defined(__linux__) || defined(__APPLE__) 19 | public: 20 | Random() { 21 | file = fopen("/dev/urandom", "rb"); 22 | } 23 | ~Random() { 24 | if (file) 25 | fclose(file); 26 | } 27 | 28 | bool get(void* data, std::size_t size) { 29 | return fread(data, 1, size, file) == size; 30 | } 31 | 32 | private: 33 | FILE* file; 34 | 35 | #elif defined(_WIN32) 36 | public: 37 | Random() = default; 38 | ~Random() = default; 39 | 40 | bool get(void* data, std::size_t size) { 41 | auto status = BCryptGenRandom( 42 | NULL, 43 | (BYTE*)data, 44 | size, 45 | BCRYPT_USE_SYSTEM_PREFERRED_RNG); 46 | 47 | if (!BCRYPT_SUCCESS(status)) 48 | { 49 | std::cerr << "ERROR: Unable to generate random number" << std::endl; 50 | return false; 51 | } 52 | return true; 53 | } 54 | 55 | #else 56 | #error "Unsupported OS" 57 | #endif 58 | }; 59 | -------------------------------------------------------------------------------- /src/sha256.cpp: -------------------------------------------------------------------------------- 1 | #include "sha256.hpp" 2 | #include "utils.hpp" 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | static const std::uint32_t k[64] = { 9 | 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 10 | 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 11 | 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 12 | 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 13 | 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 14 | 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 15 | 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 16 | 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 17 | }; 18 | 19 | 20 | SHA256::SHA256() { 21 | h[0] = 0x6a09e667; 22 | h[1] = 0xbb67ae85; 23 | h[2] = 0x3c6ef372; 24 | h[3] = 0xa54ff53a; 25 | h[4] = 0x510e527f; 26 | h[5] = 0x9b05688c; 27 | h[6] = 0x1f83d9ab; 28 | h[7] = 0x5be0cd19; 29 | 30 | data_size = 0; 31 | last_size = 0; 32 | } 33 | 34 | void SHA256::update(const void *data, std::size_t size) { 35 | auto *buffer = static_cast(data); 36 | data_size += size * 8; 37 | 38 | // Use up the left-over data from last time 39 | if (size + last_size >= 64) { 40 | std::uint64_t need = 64 - last_size; 41 | std::copy(buffer, buffer + need, last_data + last_size); 42 | 43 | buffer += need; 44 | size -= need; 45 | 46 | last_size = 0; 47 | process_chunk(last_data); 48 | } 49 | 50 | while (size >= 64) { 51 | process_chunk(buffer); 52 | 53 | buffer += 64; 54 | size -= 64; 55 | } 56 | 57 | std::copy(buffer, buffer + size, last_data + last_size); 58 | last_size += size; 59 | } 60 | 61 | void SHA256::finish() { 62 | last_data[last_size++] = 0x80; 63 | std::fill(last_data + last_size, last_data + 64, 0); 64 | 65 | if (last_size > 56) { 66 | process_chunk(last_data); 67 | std::fill(last_data, last_data + 64, 0); 68 | } 69 | 70 | for (int i = 8; i > 0; i--) { 71 | last_data[55+i] = data_size & 0xff; 72 | data_size >>= 8; 73 | } 74 | 75 | process_chunk(last_data); 76 | } 77 | 78 | void SHA256::get_hash(std::uint8_t hash[32]) const { 79 | for (int i = 0; i < 8; i++) { 80 | hash[i*4+0] = (h[i] >> 24) & 0xff; 81 | hash[i*4+1] = (h[i] >> 16) & 0xff; 82 | hash[i*4+2] = (h[i] >> 8) & 0xff; 83 | hash[i*4+3] = (h[i] >> 0) & 0xff; 84 | } 85 | } 86 | 87 | void SHA256::process_chunk(const std::uint8_t *data) { 88 | std::uint32_t w[64]; 89 | 90 | for (int i = 0; i < 16; i++) { 91 | w[i] = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3]; 92 | data += 4; 93 | } 94 | 95 | for (int i = 16; i < 64; i++) { 96 | std::uint32_t s0 = rotr(w[i-15], 7) ^ rotr(w[i-15], 18) ^ (w[i-15] >> 3); 97 | std::uint32_t s1 = rotr(w[i- 2], 17) ^ rotr(w[i- 2], 19) ^ (w[i- 2] >> 10); 98 | w[i] = w[i-16] + s0 + w[i-7] + s1; 99 | } 100 | 101 | std::uint32_t tv[8]; 102 | std::copy(h, h+8, tv); 103 | 104 | for (int i = 0; i < 64; i++) { 105 | std::uint32_t S1 = rotr(tv[4], 6) ^ rotr(tv[4], 11) ^ rotr(tv[4], 25); 106 | std::uint32_t ch = (tv[4] & tv[5]) ^ ((~tv[4]) & tv[6]); 107 | std::uint32_t temp1 = tv[7] + S1 + ch + k[i] + w[i]; 108 | std::uint32_t S0 = rotr(tv[0], 2) ^ rotr(tv[0], 13) ^ rotr(tv[0], 22); 109 | std::uint32_t maj = (tv[0] & tv[1]) ^ (tv[0] & tv[2]) ^ (tv[1] & tv[2]); 110 | std::uint32_t temp2 = S0 + maj; 111 | 112 | tv[7] = tv[6]; 113 | tv[6] = tv[5]; 114 | tv[5] = tv[4]; 115 | tv[4] = tv[3] + temp1; 116 | tv[3] = tv[2]; 117 | tv[2] = tv[1]; 118 | tv[1] = tv[0]; 119 | tv[0] = temp1 + temp2; 120 | } 121 | 122 | for (int i = 0; i < 8; i++) 123 | h[i] += tv[i]; 124 | } 125 | 126 | 127 | static void H(const void *data1, std::size_t size1, const void *data2, std::size_t size2, std::uint8_t hash[32]) { 128 | SHA256 sha; 129 | sha.update(data1, size1); 130 | sha.update(data2, size2); 131 | sha.finish(); 132 | sha.get_hash(hash); 133 | } 134 | 135 | void hmac_sha256(const void *data, std::size_t size, const void *key, std::size_t key_size, std::uint8_t hash[32]) { 136 | std::uint8_t K[64]; 137 | std::fill_n(K, 64, 0x00); 138 | 139 | if (key_size <= 64) 140 | std::copy_n(static_cast(key), key_size, K); 141 | 142 | else if (key_size > 64) { 143 | SHA256 sha; 144 | sha.update(key, key_size); 145 | sha.finish(); 146 | sha.get_hash(K); 147 | } 148 | 149 | std::uint8_t ipad[64], opad[64]; 150 | for (int i = 0; i < 64; i++) { 151 | ipad[i] = K[i] ^ 0x36; 152 | opad[i] = K[i] ^ 0x5c; 153 | } 154 | 155 | std::uint8_t ihash[32]; 156 | H(ipad, 64, data, size, ihash); 157 | H(opad, 64, ihash, 32, hash); 158 | } 159 | 160 | void pbkdf2_hmac_sha256(const void *pass, std::size_t pass_size, const void *salt, std::size_t salt_size, void *result, std::size_t result_size, std::size_t rounds) { 161 | std::uint8_t u1[32], u2[32], f[32]; 162 | std::uint8_t *s = new std::uint8_t[salt_size + 4]; 163 | std::uint8_t *r = static_cast(result); 164 | 165 | std::copy_n(static_cast(salt), salt_size, s); 166 | 167 | for (std::size_t count = 1; result_size > 0; count++) { 168 | s[salt_size+0] = (count >> 24) & 0xff; 169 | s[salt_size+1] = (count >> 16) & 0xff; 170 | s[salt_size+2] = (count >> 8) & 0xff; 171 | s[salt_size+3] = (count >> 0) & 0xff; 172 | 173 | hmac_sha256(s, salt_size + 4, pass, pass_size, u1); 174 | std::copy_n(u1, sizeof(u1), f); 175 | 176 | for (std::size_t i = 1; i < rounds; i++) { 177 | hmac_sha256(u1, sizeof(u1), pass, pass_size, u2); 178 | std::copy_n(u2, sizeof(u2), u1); 179 | 180 | for (std::size_t j = 0; j < sizeof(f); j++) 181 | f[j] ^= u2[j]; 182 | } 183 | 184 | std::size_t size = std::min(result_size, (std::size_t)32); 185 | std::copy_n(f, size, r); 186 | 187 | r += size; 188 | result_size -= size; 189 | } 190 | 191 | delete[] s; 192 | } 193 | -------------------------------------------------------------------------------- /src/sha256.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | class SHA256 7 | { 8 | public: 9 | SHA256(); 10 | 11 | void update(const void *data, std::size_t size); 12 | void finish(); 13 | void get_hash(std::uint8_t hash[32]) const; 14 | 15 | private: 16 | void process_chunk(const std::uint8_t *data); 17 | 18 | std::uint32_t h[8]; 19 | std::uint64_t data_size; 20 | 21 | // The left-over data 22 | std::uint64_t last_size; 23 | std::uint8_t last_data[64]; 24 | }; 25 | 26 | void hmac_sha256(const void *data, std::size_t size, const void *key, std::size_t key_size, std::uint8_t hash[32]); 27 | void pbkdf2_hmac_sha256(const void *pass, std::size_t pass_size, const void *salt, std::size_t salt_size, void *result, std::size_t result_size, std::size_t rounds); 28 | -------------------------------------------------------------------------------- /src/utils.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | inline std::string data_size(std::size_t size) { 8 | std::stringstream ss; 9 | 10 | if (size >= 1024*1024) 11 | ss << std::fixed << std::setprecision(2) << size / float(1024*1024) << " MiB"; 12 | else if (size >= 1024) 13 | ss << std::fixed << std::setprecision(2) << size / float(1024) << " KiB"; 14 | else 15 | ss << size << " B"; 16 | 17 | return ss.str(); 18 | } 19 | 20 | // Rotate bits left shift places 21 | template T rotl(const T &t, std::size_t shift) { 22 | constexpr std::size_t bits = sizeof(T) * 8; 23 | return (t << shift) | (t >> (bits - shift)); 24 | } 25 | 26 | // Rotate bits right shift places 27 | template T rotr(const T &t, std::size_t shift) { 28 | constexpr std::size_t bits = sizeof(T) * 8; 29 | return (t >> shift) | (t << (bits - shift)); 30 | } 31 | --------------------------------------------------------------------------------