/*

** 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 1

#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

typedef struct binascii_state {

PyObject *Error;

PyObject *Incomplete;

PyObject *reverse_table_cache;

} binascii_state;

static inline binascii_state *

get_binascii_state(PyObject *module)

{

return (binascii_state *)PyModule_GetState(module);

}

/* Align to 64 bytes for L1 cache line friendliness */

static const _Py_ALIGNED_DEF(64, unsigned char) table_a2b_base64[] = {

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,62, -1,-1,-1,63,

52,53,54,55, 56,57,58,59, 60,61,-1,-1, -1,64,-1,-1, /* PAD->64 detected by fast path */

-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10, 11,12,13,14,

15,16,17,18, 19,20,21,22, 23,24,25,-1, -1,-1,-1,-1,

-1,26,27,28, 29,30,31,32, 33,34,35,36, 37,38,39,40,

41,42,43,44, 45,46,47,48, 49,50,51,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

};

#define BASE64_PAD '='

/* Max binary chunk size; limited only by available memory */

#define BASE64_MAXBIN ((PY_SSIZE_T_MAX - 3) / 2)

/*

* Fast base64 encoding/decoding helpers.

*

* Process complete groups without loop-carried dependencies.

*/

/* Align to 64 bytes for L1 cache line friendliness */

static const _Py_ALIGNED_DEF(64, unsigned char) table_b2a_base64[] =

"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

/* Encode 3 bytes into 4 base64 characters. */

static inline void

base64_encode_trio(const unsigned char *in, unsigned char *out,

const unsigned char *table)

{

unsigned int combined = ((unsigned int)in[0] << 16) |

((unsigned int)in[1] << 8) |

(unsigned int)in[2];

out[0] = table[(combined >> 18) & 0x3f];

out[1] = table[(combined >> 12) & 0x3f];

out[2] = table[(combined >> 6) & 0x3f];

out[3] = table[combined & 0x3f];

}

/* Encode multiple complete 3-byte groups.

* Returns the number of input bytes processed (always a multiple of 3).

*/

static inline Py_ssize_t

base64_encode_fast(const unsigned char *in, Py_ssize_t in_len,

unsigned char *out, const unsigned char *table)

{

Py_ssize_t n_trios = in_len / 3;

const unsigned char *in_end = in + n_trios * 3;

while (in < in_end) {

base64_encode_trio(in, out, table);

in += 3;

out += 4;

}

return n_trios * 3;

}

/* Decode 4 base64 characters into 3 bytes.

* Returns 1 on success, 0 if any character is invalid.

*/

static inline int

base64_decode_quad(const unsigned char *in, unsigned char *out,

const unsigned char *table)

{

unsigned char v0 = table[in[0]];

unsigned char v1 = table[in[1]];

unsigned char v2 = table[in[2]];

unsigned char v3 = table[in[3]];

if ((v0 | v1 | v2 | v3) & 0xc0) {

return 0;

}

out[0] = (v0 << 2) | (v1 >> 4);

out[1] = (v1 << 4) | (v2 >> 2);

out[2] = (v2 << 6) | v3;

return 1;

}

/* Decode multiple complete 4-character groups (no padding allowed).

* Returns the number of input characters processed.

* Stops at the first invalid character, padding, or incomplete group.

*/

static inline Py_ssize_t

base64_decode_fast(const unsigned char *in, Py_ssize_t in_len,

unsigned char *out, const unsigned char *table)

{

Py_ssize_t n_quads = in_len / 4;

Py_ssize_t i;

for (i = 0; i < n_quads; i++) {

if (!base64_decode_quad(in + i * 4, out + i * 3, table)) {

break;

}

}

return i * 4;

}

static const _Py_ALIGNED_DEF(64, unsigned char) table_a2b_base85[] = {

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,62,-1,63, 64,65,66,-1, 67,68,69,70, -1,71,-1,-1,

0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,72, 73,74,75,76,

77,10,11,12, 13,14,15,16, 17,18,19,20, 21,22,23,24,

25,26,27,28, 29,30,31,32, 33,34,35,-1, -1,-1,78,79,

80,36,37,38, 39,40,41,42, 43,44,45,46, 47,48,49,50,

51,52,53,54, 55,56,57,58, 59,60,61,81, 82,83,84,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

};

static const _Py_ALIGNED_DEF(64, unsigned char) table_a2b_base85_a85[] = {

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10, 11,12,13,14,

15,16,17,18, 19,20,21,22, 23,24,25,26, 27,28,29,30,

31,32,33,34, 35,36,37,38, 39,40,41,42, 43,44,45,46,

47,48,49,50, 51,52,53,54, 55,56,57,58, 59,60,61,62,

63,64,65,66, 67,68,69,70, 71,72,73,74, 75,76,77,78,

79,80,81,82, 83,84,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

};

static const _Py_ALIGNED_DEF(64, unsigned char) table_b2a_base85[] =

"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" \

"abcdefghijklmnopqrstuvwxyz!#$%&()*+-;<=>?@^_`{|}~";

static const _Py_ALIGNED_DEF(64, unsigned char) table_b2a_base85_a85[] =

"!\"#$%&\'()*+,-./0123456789:;<=>?@" \

"ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstu";

#define BASE85_A85_PREFIX '<'

#define BASE85_A85_AFFIX '~'

#define BASE85_A85_SUFFIX '>'

#define BASE85_A85_Z 0x00000000

#define BASE85_A85_Y 0x20202020

static const _Py_ALIGNED_DEF(64, unsigned char) table_a2b_base32[] = {

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,26,27, 28,29,30,31, -1,-1,-1,-1, -1,-1,-1,-1,

-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10, 11,12,13,14,

15,16,17,18, 19,20,21,22, 23,24,25,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,

};

static const _Py_ALIGNED_DEF(64, unsigned char) table_b2a_base32[] =

"ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";

#define BASE32_PAD '='

/*

* Fast base32 encoding/decoding helpers.

*

* Analogous to the helpers for base64.

*/

/* Encode 5 bytes into 8 base32 characters. */

static inline void

base32_encode_quint(const unsigned char *in, unsigned char *out,

const unsigned char table[])

{

uint64_t combined = ((uint64_t)in[0] << 32) |

((uint64_t)in[1] << 24) |

((uint64_t)in[2] << 16) |

((uint64_t)in[3] << 8) |

(uint64_t)in[4];

out[0] = table[(combined >> 35) & 0x1f];

out[1] = table[(combined >> 30) & 0x1f];

out[2] = table[(combined >> 25) & 0x1f];

out[3] = table[(combined >> 20) & 0x1f];

out[4] = table[(combined >> 15) & 0x1f];

out[5] = table[(combined >> 10) & 0x1f];

out[6] = table[(combined >> 5) & 0x1f];

out[7] = table[combined & 0x1f];

}

/*

* Encode multiple complete 5-byte groups.

* Returns the number of input bytes processed (always a multiple of 5).

*/

static inline Py_ssize_t

base32_encode_fast(const unsigned char *in, Py_ssize_t in_len,

unsigned char *out, const unsigned char table[])

{

Py_ssize_t n_quints = in_len / 5;

const unsigned char *in_end = in + n_quints * 5;

while (in < in_end) {

base32_encode_quint(in, out, table);

in += 5;

out += 8;

}

return n_quints * 5;

}

/*

* Decode 8 base32 characters into 5 bytes.

* Returns 1 on success, 0 if any character is invalid.

*/

static inline int

base32_decode_octa(const unsigned char *in, unsigned char *out,

const unsigned char table[])

{

unsigned char v0 = table[in[0]];

unsigned char v1 = table[in[1]];

unsigned char v2 = table[in[2]];

unsigned char v3 = table[in[3]];

unsigned char v4 = table[in[4]];

unsigned char v5 = table[in[5]];

unsigned char v6 = table[in[6]];

unsigned char v7 = table[in[7]];

if ((v0 | v1 | v2 | v3 | v4 | v5 | v6 | v7) & 0xe0) {

return 0;

}

out[0] = (v0 << 3) | (v1 >> 2);

out[1] = (v1 << 6) | (v2 << 1) | (v3 >> 4);

out[2] = (v3 << 4) | (v4 >> 1);

out[3] = (v4 << 7) | (v5 << 2) | (v6 >> 3);

out[4] = (v6 << 5) | v7;

return 1;

}

/*

* Decode multiple complete 8-character groups (no padding allowed).

* Returns the number of input characters processed.

* Stops at the first invalid character, padding, or incomplete group.

*/

static inline Py_ssize_t

base32_decode_fast(const unsigned char *in, Py_ssize_t in_len,

unsigned char *out, const unsigned char table[])

{

Py_ssize_t n_quints = in_len / 8;

Py_ssize_t i;

for (i = 0; i < n_quints; i++) {

if (!base32_decode_octa(in + i * 8, out + i * 5, table)) {

break;

}

}

return i * 8;

}

static const unsigned short crctab_hqx[256] = {

0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,

0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,

0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,

0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,

0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,

0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,

0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,

0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,

0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,

0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,

0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,

0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,

0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,

0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,

0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,

0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,

0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,

0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,

0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,

0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,

0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,

0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,

0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,

0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,

0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,

0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,

0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,

0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,

0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,

0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,

0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,

0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0,

};

/*[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)

{

if (arg == NULL) {

PyBuffer_Release(buf);

return 1;

}

if (PyUnicode_Check(arg)) {

if (!PyUnicode_IS_ASCII(arg)) {

PyErr_SetString(PyExc_ValueError,

"string argument should contain only ASCII characters");

return 0;

}

assert(PyUnicode_KIND(arg) == PyUnicode_1BYTE_KIND);

buf->buf = (void *) PyUnicode_1BYTE_DATA(arg);

buf->len = PyUnicode_GET_LENGTH(arg);

buf->obj = NULL;

return 1;

}

if (PyObject_GetBuffer(arg, buf, PyBUF_SIMPLE) != 0) {

PyErr_Format(PyExc_TypeError,

"argument should be bytes, buffer or ASCII string, "

"not '%.100s'", Py_TYPE(arg)->tp_name);

return 0;

}

assert(PyBuffer_IsContiguous(buf, 'C'));

return Py_CLEANUP_SUPPORTED;

}

/* The function inserts '\n' each width characters, moving the data right.

* It assumes that we allocated enough space for all of the newlines in data.

* Returns the size of the data including the newlines.

*/

static Py_ssize_t

wraplines(unsigned char *data, Py_ssize_t size, size_t width)

{

if ((size_t)size <= width) {

return size;

}

unsigned char *src = data + size;

Py_ssize_t newlines = (size - 1) / width;

Py_ssize_t line_len = size - newlines * width;

size += newlines;

unsigned char *dst = data + size;

while ((src -= line_len) != data) {

dst -= line_len;

memmove(dst, src, line_len);

*--dst = '\n';

line_len = width;

}

assert(dst == data + width);

return size;

}

#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]*/

{

const unsigned char *ascii_data;

int leftbits = 0;

unsigned char this_ch;

unsigned int leftchar = 0;

Py_ssize_t ascii_len, bin_len;

binascii_state *state;

ascii_data = data->buf;

ascii_len = data->len;

assert(ascii_len >= 0);

/* First byte: binary data length (in bytes) */

bin_len = (*ascii_data++ - ' ') & 077;

ascii_len--;

/* Allocate the buffer */

PyBytesWriter *writer = PyBytesWriter_Create(bin_len);

if (writer == NULL) {

return NULL;

}

unsigned char *bin_data = PyBytesWriter_GetData(writer);

for( ; bin_len > 0 ; ascii_len--, ascii_data++ ) {

/* XXX is it really best to add NULs if there's no more data */

this_ch = (ascii_len > 0) ? *ascii_data : 0;

if ( this_ch == '\n' || this_ch == '\r' || ascii_len <= 0) {

/*

** Whitespace. Assume some spaces got eaten at

** end-of-line. (We check this later)

*/

this_ch = 0;

} else {

/* Check the character for legality

** The 64 in stead of the expected 63 is because

** there are a few uuencodes out there that use

** '`' as zero instead of space.

*/

if ( this_ch < ' ' || this_ch > (' ' + 64)) {

state = get_binascii_state(module);

if (state == NULL) {

goto error;

}

PyErr_SetString(state->Error, "Illegal char");

goto error;

}

this_ch = (this_ch - ' ') & 077;

}

/*

** Shift it in on the low end, and see if there's

** a byte ready for output.

*/

leftchar = (leftchar << 6) | (this_ch);

leftbits += 6;

if ( leftbits >= 8 ) {

leftbits -= 8;

*bin_data++ = (leftchar >> leftbits) & 0xff;

leftchar &= ((1 << leftbits) - 1);

bin_len--;

}

}

/*

** Finally, check that if there's anything left on the line

** that it's whitespace only.

*/

while( ascii_len-- > 0 ) {

this_ch = *ascii_data++;

/* Extra '`' may be written as padding in some cases */

if ( this_ch != ' ' && this_ch != ' '+64 &&

this_ch != '\n' && this_ch != '\r' ) {

state = get_binascii_state(module);

if (state == NULL) {

goto error;

}

PyErr_SetString(state->Error, "Trailing garbage");

goto error;

}

}

return PyBytesWriter_Finish(writer);

error:

PyBytesWriter_Discard(writer);

return NULL;

}

/*[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]*/

{

const unsigned char *bin_data;

int leftbits = 0;

unsigned char this_ch;

unsigned int leftchar = 0;

binascii_state *state;

Py_ssize_t bin_len;

bin_data = data->buf;

bin_len = data->len;

if ( bin_len > 45 ) {

/* The 45 is a limit that appears in all uuencode's */

state = get_binascii_state(module);

if (state == NULL) {

return NULL;

}

PyErr_SetString(state->Error, "At most 45 bytes at once");

return NULL;

}

/* We're lazy and allocate to much (fixed up later) */

Py_ssize_t out_len = 2 + (bin_len + 2) / 3 * 4;

PyBytesWriter *writer = PyBytesWriter_Create(out_len);

if (writer == NULL) {

return NULL;

}

unsigned char *ascii_data = PyBytesWriter_GetData(writer);

/* Store the length */

if (backtick && !bin_len)

*ascii_data++ = '`';

else

*ascii_data++ = ' ' + (unsigned char)bin_len;

for( ; bin_len > 0 || leftbits != 0 ; bin_len--, bin_data++ ) {

/* Shift the data (or padding) into our buffer */

if ( bin_len > 0 ) /* Data */

leftchar = (leftchar << 8) | *bin_data;

else /* Padding */

leftchar <<= 8;

leftbits += 8;

/* See if there are 6-bit groups ready */

while ( leftbits >= 6 ) {

this_ch = (leftchar >> (leftbits-6)) & 0x3f;

leftbits -= 6;

if (backtick && !this_ch)

*ascii_data++ = '`';

else

*ascii_data++ = this_ch + ' ';

}

}

*ascii_data++ = '\n'; /* Append a courtesy newline */

return PyBytesWriter_FinishWithPointer(writer, ascii_data);

}

static PyObject *

get_reverse_table(binascii_state *state, PyObject *alphabet, int size, int padchar)

{

PyObject *reverse_table;

if (state == NULL) {

return NULL;

}

if (PyBytes_GET_SIZE(alphabet) != size) {

PyErr_Format(PyExc_ValueError, "alphabet must have length %d", size);

return NULL;

}

if (PyDict_GetItemRef(state->reverse_table_cache, alphabet, &reverse_table) < 0) {

return NULL;

}

if (reverse_table == NULL) {

unsigned char out[256];

memset(out, (unsigned char)-1, 256);

const unsigned char *in = (const unsigned char *)PyBytes_AS_STRING(alphabet);

for (int i = 0; i < size; i++) {

out[in[i]] = i;

}

if (padchar >= 0) {

assert(padchar < 256);

out[padchar] = size;

}

reverse_table = PyBytes_FromStringAndSize((char *)out, 256);

if (reverse_table == NULL) {

return NULL;

}

if (PyDict_SetItem(state->reverse_table_cache, alphabet, reverse_table) < 0) {

Py_DECREF(reverse_table);

return NULL;

}

}

else {

if (!PyBytes_Check(reverse_table)

|| PyBytes_GET_SIZE(reverse_table) != 256)

{

PyErr_SetString(PyExc_RuntimeError, "Broken binascii cache");

Py_DECREF(reverse_table);

return NULL;

}

}

return reverse_table;

}

typedef unsigned char ignorecache_t[32];

static int

ignorechar(unsigned char c, const Py_buffer *ignorechars,

ignorecache_t ignorecache)

{

if (ignorechars == NULL) {

return 0;

}

if (ignorecache[c >> 3] & (1 << (c & 7))) {

return 1;

}

if (memchr(ignorechars->buf, c, ignorechars->len)) {

ignorecache[c >> 3] |= 1 << (c & 7);

return 1;

}

return 0;

}

/*[clinic input]

binascii.a2b_base64

data: ascii_buffer

/

*

strict_mode: bool(c_default="-1", py_default="<unrepresentable>") = False

When set to true, bytes that are not part of the base64 standard are

not allowed. The same applies to excess data after padding (= / ==).

Set to True by default if ignorechars is specified, False otherwise.

padded: bool = True

When set to false, padding in input is not required.

alphabet: PyBytesObject(c_default="NULL") = BASE64_ALPHABET

ignorechars: Py_buffer = NULL

A byte string containing characters to ignore from the input when

strict_mode is true.

Decode a line of base64 data.

[clinic start generated code]*/

static PyObject *

binascii_a2b_base64_impl(PyObject *module, Py_buffer *data, int strict_mode,

int padded, PyBytesObject *alphabet,

Py_buffer *ignorechars)

/*[clinic end generated code: output=525d840a299ff132 input=74a53dd3b23474b3]*/

{

assert(data->len >= 0);

const unsigned char *ascii_data = data->buf;

size_t ascii_len = data->len;

binascii_state *state = NULL;

PyObject *table_obj = NULL;

const unsigned char *table_a2b = table_a2b_base64;

if (strict_mode == -1) {

strict_mode = (ignorechars->buf != NULL);

}

if (!strict_mode || ignorechars->buf == NULL || ignorechars->len == 0) {

ignorechars = NULL;

}

ignorecache_t ignorecache;

if (ignorechars != NULL) {

memset(ignorecache, 0, sizeof(ignorecache));

}

if (alphabet != NULL) {

state = get_binascii_state(module);

table_obj = get_reverse_table(state, (PyObject *)alphabet, 64, BASE64_PAD);

if (table_obj == NULL) {

return NULL;

}

table_a2b = (const unsigned char *)PyBytes_AS_STRING(table_obj);

}

/* Allocate the buffer */

Py_ssize_t bin_len = ((ascii_len+3)/4)*3; /* Upper bound, corrected later */

PyBytesWriter *writer = PyBytesWriter_Create(bin_len);

if (writer == NULL) {

Py_XDECREF(table_obj);

return NULL;

}

unsigned char *bin_data = PyBytesWriter_GetData(writer);

fastpath:

/* Fast path: use optimized decoder for complete quads.

* This works for both strict and non-strict mode for valid input.

* The fast path stops at padding, invalid chars, or incomplete groups.

*/

if (ascii_len >= 4) {

Py_ssize_t fast_chars = base64_decode_fast(ascii_data, (Py_ssize_t)ascii_len,

bin_data, table_a2b);

if (fast_chars > 0) {

ascii_data += fast_chars;

ascii_len -= fast_chars;

bin_data += (fast_chars / 4) * 3;

}

}

/* Slow path: handle remaining input (padding, invalid chars, partial groups) */

int quad_pos = 0;

unsigned char leftchar = 0;

int pads = 0;

for (; ascii_len; ascii_data++, ascii_len--) {

unsigned char this_ch = *ascii_data;

/* Check for pad sequences and ignore

** the invalid ones.

*/

if (padded && this_ch == BASE64_PAD) {

pads++;

if (quad_pos >= 2 && quad_pos + pads <= 4) {

continue;

}

// See RFC 4648, section 3.3: "specifications MAY ignore the

// pad character, "=", treating it as non-alphabet data, if

// it is present before the end of the encoded data" and

// "the excess pad characters MAY also be ignored."

if (!strict_mode || ignorechar(BASE64_PAD, ignorechars, ignorecache)) {

continue;

}

if (quad_pos == 1) {

/* Set an error below. */

break;

}

state = get_binascii_state(module);

if (state) {

unsigned char *bin_data_start = PyBytesWriter_GetData(writer);

PyErr_SetString(state->Error,

(quad_pos == 0 && bin_data == bin_data_start)

? "Leading padding not allowed"

: "Excess padding not allowed");

}

goto error_end;

}

unsigned char v = table_a2b[this_ch];

if (v >= 64) {

// See RFC 4648, section 3.3.

if (strict_mode && !ignorechar(this_ch, ignorechars, ignorecache)) {

state = get_binascii_state(module);

if (state) {

PyErr_SetString(state->Error,

(this_ch == BASE64_PAD)

? "Padding not allowed"

: "Only base64 data is allowed");

}

goto error_end;

}

continue;

}

// Characters that are not '=', in the middle of the padding, are

// not allowed (except when they are). See RFC 4648, section 3.3.

if (pads && strict_mode &&

!ignorechar(BASE64_PAD, ignorechars, ignorecache))

{

state = get_binascii_state(module);

if (state) {

PyErr_SetString(state->Error, (quad_pos + pads == 4)

? "Excess data after padding"

: "Discontinuous padding not allowed");

}

goto error_end;

}

pads = 0;

switch (quad_pos) {

case 0:

quad_pos = 1;

leftchar = v;

break;

case 1:

quad_pos = 2;

*bin_data++ = (leftchar << 2) | (v >> 4);

leftchar = v & 0x0f;

break;

case 2:

quad_pos = 3;

*bin_data++ = (leftchar << 4) | (v >> 2);

leftchar = v & 0x03;

break;

case 3:

quad_pos = 0;

*bin_data++ = (leftchar << 6) | (v);

leftchar = 0;

ascii_data++;

ascii_len--;

goto fastpath;

}

}

if (quad_pos == 1) {

/* There is exactly one extra valid, non-padding, base64 character.

** This is an invalid length, as there is no possible input that

** could encoded into such a base64 string.

*/

state = get_binascii_state(module);

if (state) {

unsigned char *bin_data_start = PyBytesWriter_GetData(writer);

PyErr_Format(state->Error,

"Invalid base64-encoded string: "

"number of data characters (%zd) cannot be 1 more "

"than a multiple of 4",

(bin_data - bin_data_start) / 3 * 4 + 1);

}

goto error_end;

}

if (padded && quad_pos != 0 && quad_pos + pads < 4) {

state = get_binascii_state(module);

if (state) {

PyErr_SetString(state->Error, "Incorrect padding");

}

goto error_end;

}

Py_XDECREF(table_obj);

return PyBytesWriter_FinishWithPointer(writer, bin_data);

error_end:

Py_XDECREF(table_obj);

PyBytesWriter_Discard(writer);

return NULL;

}

/*[clinic input]

binascii.b2a_base64

data: Py_buffer

/

*

padded: bool = True

When set to false, omit padding in the output.

wrapcol: size_t = 0

newline: bool = True

alphabet: Py_buffer(c_default="{NULL, NULL}") = BASE64_ALPHABET

Base64-code line of data.

[clinic start generated code]*/

static PyObject *

binascii_b2a_base64_impl(PyObject *module, Py_buffer *data, int padded,

size_t wrapcol, int newline, Py_buffer *alphabet)

/*[clinic end generated code: output=a2057b906dc201ab input=cfa33ad73051d3f7]*/

{

const unsigned char *table_b2a = table_b2a_base64;

const unsigned char *bin_data = data->buf;

Py_ssize_t bin_len = data->len;

assert(bin_len >= 0);

if (alphabet->buf != NULL) {

if (alphabet->len != 64) {

PyErr_SetString(PyExc_ValueError, "alphabet must have length 64");

return NULL;

}

table_b2a = alphabet->buf;

}

/* Each group of 3 bytes (rounded up) gets encoded as 4 characters,

* not counting newlines.

* Note that 'b' gets encoded as 'Yg==' (1 in, 4 out).

*

* Use unsigned integer arithmetic to avoid signed integer overflow.

*/

size_t out_len = ((size_t)bin_len + 2u) / 3u * 4u;

unsigned int pads = (3 - (bin_len % 3)) % 3 * 4 / 3;

if (!padded) {

out_len -= pads;

pads = 0;

}

if (wrapcol && out_len) {

/* Each line should encode a whole number of bytes. */

wrapcol = wrapcol < 4 ? 4 : wrapcol / 4 * 4;

out_len += (out_len - 1u) / wrapcol;

}

if (newline) {

out_len++;

}

if (out_len > PY_SSIZE_T_MAX) {

binascii_state *state = get_binascii_state(module);

if (state == NULL) {

return NULL;

}

PyErr_SetString(state->Error, "Too much data for base64");

return NULL;

}

PyBytesWriter *writer = PyBytesWriter_Create(out_len);

if (writer == NULL) {

return NULL;

}

unsigned char *ascii_data = PyBytesWriter_GetData(writer);

/* Use the optimized fast path for complete 3-byte groups */

Py_ssize_t fast_bytes = base64_encode_fast(bin_data, bin_len, ascii_data,

table_b2a);

bin_data += fast_bytes;

ascii_data += (fast_bytes / 3) * 4;

bin_len -= fast_bytes;

/* Handle remaining 0-2 bytes */

if (bin_len == 1) {

/* 1 byte remaining: produces 2 base64 chars + 2 padding */

assert(!padded || pads == 2);

unsigned int val = bin_data[0];

*ascii_data++ = table_b2a[(val >> 2) & 0x3f];