/* ** Routines to represent binary data in ASCII and vice-versa ** ** This module currently supports the following encodings: ** uuencode: ** each line encodes 45 bytes (except possibly the last) ** First char encodes (binary) length, rest data ** each char encodes 6 bits, as follows: ** binary: 01234567 abcdefgh ijklmnop ** ascii: 012345 67abcd efghij klmnop ** ASCII encoding method is "excess-space": 000000 is encoded as ' ', etc. ** short binary data is zero-extended (so the bits are always in the ** right place), this does *not* reflect in the length. ** base64: ** Line breaks are insignificant, but lines are at most 76 chars ** each char encodes 6 bits, in similar order as uucode/hqx. Encoding ** is done via a table. ** Short binary data is filled (in ASCII) with '='. ** hqx: ** File starts with introductory text, real data starts and ends ** with colons. ** Data consists of three similar parts: info, datafork, resourcefork. ** Each part is protected (at the end) with a 16-bit crc ** The binary data is run-length encoded, and then ascii-fied: ** binary: 01234567 abcdefgh ijklmnop ** ascii: 012345 67abcd efghij klmnop ** ASCII encoding is table-driven, see the code. ** Short binary data results in the runt ascii-byte being output with ** the bits in the right place. ** ** While I was reading dozens of programs that encode or decode the formats ** here (documentation? hihi:-) I have formulated Jansen's Observation: ** ** Programs that encode binary data in ASCII are written in ** such a style that they are as unreadable as possible. Devices used ** include unnecessary global variables, burying important tables ** in unrelated sourcefiles, putting functions in include files, ** using seemingly-descriptive variable names for different purposes, ** calls to empty subroutines and a host of others. ** ** I have attempted to break with this tradition, but I guess that that ** does make the performance sub-optimal. Oh well, too bad... ** ** Jack Jansen, CWI, July 1995. ** ** Added support for quoted-printable encoding, based on rfc 1521 et al ** quoted-printable encoding specifies that non printable characters (anything ** below 32 and above 126) be encoded as =XX where XX is the hexadecimal value ** of the character. It also specifies some other behavior to enable 8bit data ** in a mail message with little difficulty (maximum line sizes, protecting ** some cases of whitespace, etc). ** ** Brandon Long, September 2001. */ #ifndef Py_BUILD_CORE_BUILTIN #define Py_BUILD_CORE_MODULE … #endif #include "Python.h" #include "pycore_long.h" // _PyLong_DigitValue #include "pycore_strhex.h" // _Py_strhex_bytes_with_sep() #ifdef USE_ZLIB_CRC32 # include "zlib.h" #endif binascii_state; static inline binascii_state * get_binascii_state(PyObject *module) { … } static const unsigned char table_a2b_base64[] = …; #define BASE64_PAD … /* Max binary chunk size; limited only by available memory */ #define BASE64_MAXBIN … static const unsigned char table_b2a_base64[] = …; static const unsigned short crctab_hqx[256] = …; /*[clinic input] module binascii [clinic start generated code]*/ /*[clinic end generated code: output=da39a3ee5e6b4b0d input=de89fb46bcaf3fec]*/ /*[python input] class ascii_buffer_converter(CConverter): type = 'Py_buffer' converter = 'ascii_buffer_converter' impl_by_reference = True c_default = "{NULL, NULL}" def cleanup(self): name = self.name return "".join(["if (", name, ".obj)\n PyBuffer_Release(&", name, ");\n"]) [python start generated code]*/ /*[python end generated code: output=da39a3ee5e6b4b0d input=3eb7b63610da92cd]*/ static int ascii_buffer_converter(PyObject *arg, Py_buffer *buf) { … } #include "clinic/binascii.c.h" /*[clinic input] binascii.a2b_uu data: ascii_buffer / Decode a line of uuencoded data. [clinic start generated code]*/ static PyObject * binascii_a2b_uu_impl(PyObject *module, Py_buffer *data) /*[clinic end generated code: output=e027f8e0b0598742 input=7cafeaf73df63d1c]*/ { … } /*[clinic input] binascii.b2a_uu data: Py_buffer / * backtick: bool = False Uuencode line of data. [clinic start generated code]*/ static PyObject * binascii_b2a_uu_impl(PyObject *module, Py_buffer *data, int backtick) /*[clinic end generated code: output=b1b99de62d9bbeb8 input=beb27822241095cd]*/ { … } /*[clinic input] binascii.a2b_base64 data: ascii_buffer / * strict_mode: bool = False Decode a line of base64 data. strict_mode When set to True, bytes that are not part of the base64 standard are not allowed. The same applies to excess data after padding (= / ==). [clinic start generated code]*/ static PyObject * binascii_a2b_base64_impl(PyObject *module, Py_buffer *data, int strict_mode) /*[clinic end generated code: output=5409557788d4f975 input=c0c15fd0f8f9a62d]*/ { … } /*[clinic input] binascii.b2a_base64 data: Py_buffer / * newline: bool = True Base64-code line of data. [clinic start generated code]*/ static PyObject * binascii_b2a_base64_impl(PyObject *module, Py_buffer *data, int newline) /*[clinic end generated code: output=4ad62c8e8485d3b3 input=0e20ff59c5f2e3e1]*/ { … } /*[clinic input] binascii.crc_hqx data: Py_buffer crc: unsigned_int(bitwise=True) / Compute CRC-CCITT incrementally. [clinic start generated code]*/ static PyObject * binascii_crc_hqx_impl(PyObject *module, Py_buffer *data, unsigned int crc) /*[clinic end generated code: output=2fde213d0f547a98 input=56237755370a951c]*/ { … } #ifndef USE_ZLIB_CRC32 /* Crc - 32 BIT ANSI X3.66 CRC checksum files Also known as: ISO 3307 **********************************************************************| * *| * Demonstration program to compute the 32-bit CRC used as the frame *| * check sequence in ADCCP (ANSI X3.66, also known as FIPS PUB 71 *| * and FED-STD-1003, the U.S. versions of CCITT's X.25 link-level *| * protocol). The 32-bit FCS was added via the Federal Register, *| * 1 June 1982, p.23798. I presume but don't know for certain that *| * this polynomial is or will be included in CCITT V.41, which *| * defines the 16-bit CRC (often called CRC-CCITT) polynomial. FIPS *| * PUB 78 says that the 32-bit FCS reduces otherwise undetected *| * errors by a factor of 10^-5 over 16-bit FCS. *| * *| **********************************************************************| Copyright (C) 1986 Gary S. Brown. You may use this program, or code or tables extracted from it, as desired without restriction. First, the polynomial itself and its table of feedback terms. The polynomial is 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+X^0 Note that we take it "backwards" and put the highest-order term in the lowest-order bit. The X^32 term is "implied"; the LSB is the X^31 term, etc. The X^0 term (usually shown as "+1") results in the MSB being 1. Note that the usual hardware shift register implementation, which is what we're using (we're merely optimizing it by doing eight-bit chunks at a time) shifts bits into the lowest-order term. In our implementation, that means shifting towards the right. Why do we do it this way? Because the calculated CRC must be transmitted in order from highest-order term to lowest-order term. UARTs transmit characters in order from LSB to MSB. By storing the CRC this way, we hand it to the UART in the order low-byte to high-byte; the UART sends each low-bit to hight-bit; and the result is transmission bit by bit from highest- to lowest-order term without requiring any bit shuffling on our part. Reception works similarly. The feedback terms table consists of 256, 32-bit entries. Notes: 1. The table can be generated at runtime if desired; code to do so is shown later. It might not be obvious, but the feedback terms simply represent the results of eight shift/xor opera- tions for all combinations of data and CRC register values. 2. The CRC accumulation logic is the same for all CRC polynomials, be they sixteen or thirty-two bits wide. You simply choose the appropriate table. Alternatively, because the table can be generated at runtime, you can start by generating the table for the polynomial in question and use exactly the same "updcrc", if your application needn't simultaneously handle two CRC polynomials. (Note, however, that XMODEM is strange.) 3. For 16-bit CRCs, the table entries need be only 16 bits wide; of course, 32-bit entries work OK if the high 16 bits are zero. 4. The values must be right-shifted by eight bits by the "updcrc" logic; the shift must be unsigned (bring in zeroes). On some hardware you could probably optimize the shift in assembler by using byte-swap instructions. ********************************************************************/ static const unsigned int crc_32_tab[256] = { 0x00000000U, 0x77073096U, 0xee0e612cU, 0x990951baU, 0x076dc419U, 0x706af48fU, 0xe963a535U, 0x9e6495a3U, 0x0edb8832U, 0x79dcb8a4U, 0xe0d5e91eU, 0x97d2d988U, 0x09b64c2bU, 0x7eb17cbdU, 0xe7b82d07U, 0x90bf1d91U, 0x1db71064U, 0x6ab020f2U, 0xf3b97148U, 0x84be41deU, 0x1adad47dU, 0x6ddde4ebU, 0xf4d4b551U, 0x83d385c7U, 0x136c9856U, 0x646ba8c0U, 0xfd62f97aU, 0x8a65c9ecU, 0x14015c4fU, 0x63066cd9U, 0xfa0f3d63U, 0x8d080df5U, 0x3b6e20c8U, 0x4c69105eU, 0xd56041e4U, 0xa2677172U, 0x3c03e4d1U, 0x4b04d447U, 0xd20d85fdU, 0xa50ab56bU, 0x35b5a8faU, 0x42b2986cU, 0xdbbbc9d6U, 0xacbcf940U, 0x32d86ce3U, 0x45df5c75U, 0xdcd60dcfU, 0xabd13d59U, 0x26d930acU, 0x51de003aU, 0xc8d75180U, 0xbfd06116U, 0x21b4f4b5U, 0x56b3c423U, 0xcfba9599U, 0xb8bda50fU, 0x2802b89eU, 0x5f058808U, 0xc60cd9b2U, 0xb10be924U, 0x2f6f7c87U, 0x58684c11U, 0xc1611dabU, 0xb6662d3dU, 0x76dc4190U, 0x01db7106U, 0x98d220bcU, 0xefd5102aU, 0x71b18589U, 0x06b6b51fU, 0x9fbfe4a5U, 0xe8b8d433U, 0x7807c9a2U, 0x0f00f934U, 0x9609a88eU, 0xe10e9818U, 0x7f6a0dbbU, 0x086d3d2dU, 0x91646c97U, 0xe6635c01U, 0x6b6b51f4U, 0x1c6c6162U, 0x856530d8U, 0xf262004eU, 0x6c0695edU, 0x1b01a57bU, 0x8208f4c1U, 0xf50fc457U, 0x65b0d9c6U, 0x12b7e950U, 0x8bbeb8eaU, 0xfcb9887cU, 0x62dd1ddfU, 0x15da2d49U, 0x8cd37cf3U, 0xfbd44c65U, 0x4db26158U, 0x3ab551ceU, 0xa3bc0074U, 0xd4bb30e2U, 0x4adfa541U, 0x3dd895d7U, 0xa4d1c46dU, 0xd3d6f4fbU, 0x4369e96aU, 0x346ed9fcU, 0xad678846U, 0xda60b8d0U, 0x44042d73U, 0x33031de5U, 0xaa0a4c5fU, 0xdd0d7cc9U, 0x5005713cU, 0x270241aaU, 0xbe0b1010U, 0xc90c2086U, 0x5768b525U, 0x206f85b3U, 0xb966d409U, 0xce61e49fU, 0x5edef90eU, 0x29d9c998U, 0xb0d09822U, 0xc7d7a8b4U, 0x59b33d17U, 0x2eb40d81U, 0xb7bd5c3bU, 0xc0ba6cadU, 0xedb88320U, 0x9abfb3b6U, 0x03b6e20cU, 0x74b1d29aU, 0xead54739U, 0x9dd277afU, 0x04db2615U, 0x73dc1683U, 0xe3630b12U, 0x94643b84U, 0x0d6d6a3eU, 0x7a6a5aa8U, 0xe40ecf0bU, 0x9309ff9dU, 0x0a00ae27U, 0x7d079eb1U, 0xf00f9344U, 0x8708a3d2U, 0x1e01f268U, 0x6906c2feU, 0xf762575dU, 0x806567cbU, 0x196c3671U, 0x6e6b06e7U, 0xfed41b76U, 0x89d32be0U, 0x10da7a5aU, 0x67dd4accU, 0xf9b9df6fU, 0x8ebeeff9U, 0x17b7be43U, 0x60b08ed5U, 0xd6d6a3e8U, 0xa1d1937eU, 0x38d8c2c4U, 0x4fdff252U, 0xd1bb67f1U, 0xa6bc5767U, 0x3fb506ddU, 0x48b2364bU, 0xd80d2bdaU, 0xaf0a1b4cU, 0x36034af6U, 0x41047a60U, 0xdf60efc3U, 0xa867df55U, 0x316e8eefU, 0x4669be79U, 0xcb61b38cU, 0xbc66831aU, 0x256fd2a0U, 0x5268e236U, 0xcc0c7795U, 0xbb0b4703U, 0x220216b9U, 0x5505262fU, 0xc5ba3bbeU, 0xb2bd0b28U, 0x2bb45a92U, 0x5cb36a04U, 0xc2d7ffa7U, 0xb5d0cf31U, 0x2cd99e8bU, 0x5bdeae1dU, 0x9b64c2b0U, 0xec63f226U, 0x756aa39cU, 0x026d930aU, 0x9c0906a9U, 0xeb0e363fU, 0x72076785U, 0x05005713U, 0x95bf4a82U, 0xe2b87a14U, 0x7bb12baeU, 0x0cb61b38U, 0x92d28e9bU, 0xe5d5be0dU, 0x7cdcefb7U, 0x0bdbdf21U, 0x86d3d2d4U, 0xf1d4e242U, 0x68ddb3f8U, 0x1fda836eU, 0x81be16cdU, 0xf6b9265bU, 0x6fb077e1U, 0x18b74777U, 0x88085ae6U, 0xff0f6a70U, 0x66063bcaU, 0x11010b5cU, 0x8f659effU, 0xf862ae69U, 0x616bffd3U, 0x166ccf45U, 0xa00ae278U, 0xd70dd2eeU, 0x4e048354U, 0x3903b3c2U, 0xa7672661U, 0xd06016f7U, 0x4969474dU, 0x3e6e77dbU, 0xaed16a4aU, 0xd9d65adcU, 0x40df0b66U, 0x37d83bf0U, 0xa9bcae53U, 0xdebb9ec5U, 0x47b2cf7fU, 0x30b5ffe9U, 0xbdbdf21cU, 0xcabac28aU, 0x53b39330U, 0x24b4a3a6U, 0xbad03605U, 0xcdd70693U, 0x54de5729U, 0x23d967bfU, 0xb3667a2eU, 0xc4614ab8U, 0x5d681b02U, 0x2a6f2b94U, 0xb40bbe37U, 0xc30c8ea1U, 0x5a05df1bU, 0x2d02ef8dU }; static unsigned int internal_crc32(const unsigned char *bin_data, Py_ssize_t len, unsigned int crc) { /* By Jim Ahlstrom; All rights transferred to CNRI */ unsigned int result; crc = ~ crc; while (len-- > 0) { crc = crc_32_tab[(crc ^ *bin_data++) & 0xff] ^ (crc >> 8); /* Note: (crc >> 8) MUST zero fill on left */ } result = (crc ^ 0xFFFFFFFF); return result & 0xffffffff; } #endif /* USE_ZLIB_CRC32 */ /*[clinic input] binascii.crc32 -> unsigned_int data: Py_buffer crc: unsigned_int(bitwise=True) = 0 / Compute CRC-32 incrementally. [clinic start generated code]*/ static unsigned int binascii_crc32_impl(PyObject *module, Py_buffer *data, unsigned int crc) /*[clinic end generated code: output=52cf59056a78593b input=bbe340bc99d25aa8]*/ #ifdef USE_ZLIB_CRC32 /* This is the same as zlibmodule.c zlib_crc32_impl. It exists in two * modules for historical reasons. */ { … } #else /* USE_ZLIB_CRC32 */ { const unsigned char *bin_data = data->buf; Py_ssize_t len = data->len; /* Releasing the GIL for very small buffers is inefficient and may lower performance */ if (len > 1024*5) { unsigned int result; Py_BEGIN_ALLOW_THREADS result = internal_crc32(bin_data, len, crc); Py_END_ALLOW_THREADS return result; } else { return internal_crc32(bin_data, len, crc); } } #endif /* USE_ZLIB_CRC32 */ /*[clinic input] binascii.b2a_hex data: Py_buffer sep: object = NULL An optional single character or byte to separate hex bytes. bytes_per_sep: int = 1 How many bytes between separators. Positive values count from the right, negative values count from the left. Hexadecimal representation of binary data. The return value is a bytes object. This function is also available as "hexlify()". Example: >>> binascii.b2a_hex(b'\xb9\x01\xef') b'b901ef' >>> binascii.hexlify(b'\xb9\x01\xef', ':') b'b9:01:ef' >>> binascii.b2a_hex(b'\xb9\x01\xef', b'_', 2) b'b9_01ef' [clinic start generated code]*/ static PyObject * binascii_b2a_hex_impl(PyObject *module, Py_buffer *data, PyObject *sep, int bytes_per_sep) /*[clinic end generated code: output=a26937946a81d2c7 input=ec0ade6ba2e43543]*/ { … } /*[clinic input] binascii.hexlify = binascii.b2a_hex Hexadecimal representation of binary data. The return value is a bytes object. This function is also available as "b2a_hex()". [clinic start generated code]*/ static PyObject * binascii_hexlify_impl(PyObject *module, Py_buffer *data, PyObject *sep, int bytes_per_sep) /*[clinic end generated code: output=d12aa1b001b15199 input=bc317bd4e241f76b]*/ { … } /*[clinic input] binascii.a2b_hex hexstr: ascii_buffer / Binary data of hexadecimal representation. hexstr must contain an even number of hex digits (upper or lower case). This function is also available as "unhexlify()". [clinic start generated code]*/ static PyObject * binascii_a2b_hex_impl(PyObject *module, Py_buffer *hexstr) /*[clinic end generated code: output=0cc1a139af0eeecb input=9e1e7f2f94db24fd]*/ { … } /*[clinic input] binascii.unhexlify = binascii.a2b_hex Binary data of hexadecimal representation. hexstr must contain an even number of hex digits (upper or lower case). [clinic start generated code]*/ static PyObject * binascii_unhexlify_impl(PyObject *module, Py_buffer *hexstr) /*[clinic end generated code: output=51a64c06c79629e3 input=dd8c012725f462da]*/ { … } #define MAXLINESIZE … /*[clinic input] binascii.a2b_qp data: ascii_buffer header: bool = False Decode a string of qp-encoded data. [clinic start generated code]*/ static PyObject * binascii_a2b_qp_impl(PyObject *module, Py_buffer *data, int header) /*[clinic end generated code: output=e99f7846cfb9bc53 input=bdfb31598d4e47b9]*/ { … } static int to_hex (unsigned char ch, unsigned char *s) { … } /* XXX: This is ridiculously complicated to be backward compatible * (mostly) with the quopri module. It doesn't re-create the quopri * module bug where text ending in CRLF has the CR encoded */ /*[clinic input] binascii.b2a_qp data: Py_buffer quotetabs: bool = False istext: bool = True header: bool = False Encode a string using quoted-printable encoding. On encoding, when istext is set, newlines are not encoded, and white space at end of lines is. When istext is not set, \r and \n (CR/LF) are both encoded. When quotetabs is set, space and tabs are encoded. [clinic start generated code]*/ static PyObject * binascii_b2a_qp_impl(PyObject *module, Py_buffer *data, int quotetabs, int istext, int header) /*[clinic end generated code: output=e9884472ebb1a94c input=e9102879afb0defd]*/ { … } /* List of functions defined in the module */ static struct PyMethodDef binascii_module_methods[] = …; /* Initialization function for the module (*must* be called PyInit_binascii) */ PyDoc_STRVAR(doc_binascii, "Conversion between binary data and ASCII"); static int binascii_exec(PyObject *module) { … } static PyModuleDef_Slot binascii_slots[] = …; static int binascii_traverse(PyObject *module, visitproc visit, void *arg) { … } static int binascii_clear(PyObject *module) { … } static void binascii_free(void *module) { … } static struct PyModuleDef binasciimodule = …; PyMODINIT_FUNC PyInit_binascii(void) { … }
Codebase Browser
cpython