Benjamin Peterson | 90f5ba5 | 2010-03-11 22:53:45 +0000 | [diff] [blame] | 1 | #! /usr/bin/env python3 |
Guido van Rossum | aa925a5 | 1997-04-02 05:47:39 +0000 | [diff] [blame] | 2 | |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 3 | """RFC 3548: Base16, Base32, Base64 Data Encodings""" |
Guido van Rossum | 4acc25b | 2000-02-02 15:10:15 +0000 | [diff] [blame] | 4 | |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 5 | # Modified 04-Oct-1995 by Jack Jansen to use binascii module |
| 6 | # Modified 30-Dec-2003 by Barry Warsaw to add full RFC 3548 support |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 7 | # Modified 22-May-2007 by Guido van Rossum to use bytes everywhere |
Jack Jansen | 951213e | 1995-10-04 16:39:20 +0000 | [diff] [blame] | 8 | |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 9 | import re |
| 10 | import struct |
Jack Jansen | 951213e | 1995-10-04 16:39:20 +0000 | [diff] [blame] | 11 | import binascii |
| 12 | |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 13 | |
| 14 | __all__ = [ |
| 15 | # Legacy interface exports traditional RFC 1521 Base64 encodings |
Georg Brandl | b54d801 | 2009-06-04 09:11:51 +0000 | [diff] [blame] | 16 | 'encode', 'decode', 'encodebytes', 'decodebytes', |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 17 | # Generalized interface for other encodings |
| 18 | 'b64encode', 'b64decode', 'b32encode', 'b32decode', |
| 19 | 'b16encode', 'b16decode', |
| 20 | # Standard Base64 encoding |
| 21 | 'standard_b64encode', 'standard_b64decode', |
| 22 | # Some common Base64 alternatives. As referenced by RFC 3458, see thread |
| 23 | # starting at: |
| 24 | # |
| 25 | # http://zgp.org/pipermail/p2p-hackers/2001-September/000316.html |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 26 | 'urlsafe_b64encode', 'urlsafe_b64decode', |
| 27 | ] |
| 28 | |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 29 | |
Guido van Rossum | 254348e | 2007-11-21 19:29:53 +0000 | [diff] [blame] | 30 | bytes_types = (bytes, bytearray) # Types acceptable as binary data |
Guido van Rossum | 98297ee | 2007-11-06 21:34:58 +0000 | [diff] [blame] | 31 | |
Antoine Pitrou | ea6b4d5 | 2012-02-20 19:30:23 +0100 | [diff] [blame] | 32 | def _bytes_from_decode_data(s): |
| 33 | if isinstance(s, str): |
| 34 | try: |
| 35 | return s.encode('ascii') |
| 36 | except UnicodeEncodeError: |
| 37 | raise ValueError('string argument should contain only ASCII characters') |
Nick Coghlan | fdf239a | 2013-10-03 00:43:22 +1000 | [diff] [blame^] | 38 | if isinstance(s, bytes_types): |
Antoine Pitrou | ea6b4d5 | 2012-02-20 19:30:23 +0100 | [diff] [blame] | 39 | return s |
Nick Coghlan | fdf239a | 2013-10-03 00:43:22 +1000 | [diff] [blame^] | 40 | try: |
| 41 | return memoryview(s).tobytes() |
| 42 | except TypeError: |
| 43 | raise TypeError("argument should be a bytes-like object or ASCII " |
| 44 | "string, not %r" % s.__class__.__name__) from None |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 45 | |
Antoine Pitrou | fd03645 | 2008-08-19 17:56:33 +0000 | [diff] [blame] | 46 | |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 47 | # Base64 encoding/decoding uses binascii |
| 48 | |
| 49 | def b64encode(s, altchars=None): |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 50 | """Encode a byte string using Base64. |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 51 | |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 52 | s is the byte string to encode. Optional altchars must be a byte |
| 53 | string of length 2 which specifies an alternative alphabet for the |
| 54 | '+' and '/' characters. This allows an application to |
| 55 | e.g. generate url or filesystem safe Base64 strings. |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 56 | |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 57 | The encoded byte string is returned. |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 58 | """ |
| 59 | # Strip off the trailing newline |
| 60 | encoded = binascii.b2a_base64(s)[:-1] |
| 61 | if altchars is not None: |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 62 | assert len(altchars) == 2, repr(altchars) |
Guido van Rossum | 95c1c48 | 2012-06-22 15:16:09 -0700 | [diff] [blame] | 63 | return encoded.translate(bytes.maketrans(b'+/', altchars)) |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 64 | return encoded |
| 65 | |
| 66 | |
R. David Murray | 6495136 | 2010-11-11 20:09:20 +0000 | [diff] [blame] | 67 | def b64decode(s, altchars=None, validate=False): |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 68 | """Decode a Base64 encoded byte string. |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 69 | |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 70 | s is the byte string to decode. Optional altchars must be a |
| 71 | string of length 2 which specifies the alternative alphabet used |
| 72 | instead of the '+' and '/' characters. |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 73 | |
R. David Murray | 6495136 | 2010-11-11 20:09:20 +0000 | [diff] [blame] | 74 | The decoded string is returned. A binascii.Error is raised if s is |
| 75 | incorrectly padded. |
| 76 | |
| 77 | If validate is False (the default), non-base64-alphabet characters are |
| 78 | discarded prior to the padding check. If validate is True, |
| 79 | non-base64-alphabet characters in the input result in a binascii.Error. |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 80 | """ |
Antoine Pitrou | ea6b4d5 | 2012-02-20 19:30:23 +0100 | [diff] [blame] | 81 | s = _bytes_from_decode_data(s) |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 82 | if altchars is not None: |
Antoine Pitrou | ea6b4d5 | 2012-02-20 19:30:23 +0100 | [diff] [blame] | 83 | altchars = _bytes_from_decode_data(altchars) |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 84 | assert len(altchars) == 2, repr(altchars) |
Guido van Rossum | 95c1c48 | 2012-06-22 15:16:09 -0700 | [diff] [blame] | 85 | s = s.translate(bytes.maketrans(altchars, b'+/')) |
R. David Murray | 6495136 | 2010-11-11 20:09:20 +0000 | [diff] [blame] | 86 | if validate and not re.match(b'^[A-Za-z0-9+/]*={0,2}$', s): |
| 87 | raise binascii.Error('Non-base64 digit found') |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 88 | return binascii.a2b_base64(s) |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 89 | |
| 90 | |
| 91 | def standard_b64encode(s): |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 92 | """Encode a byte string using the standard Base64 alphabet. |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 93 | |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 94 | s is the byte string to encode. The encoded byte string is returned. |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 95 | """ |
| 96 | return b64encode(s) |
| 97 | |
| 98 | def standard_b64decode(s): |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 99 | """Decode a byte string encoded with the standard Base64 alphabet. |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 100 | |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 101 | s is the byte string to decode. The decoded byte string is |
| 102 | returned. binascii.Error is raised if the input is incorrectly |
| 103 | padded or if there are non-alphabet characters present in the |
| 104 | input. |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 105 | """ |
| 106 | return b64decode(s) |
| 107 | |
Guido van Rossum | 95c1c48 | 2012-06-22 15:16:09 -0700 | [diff] [blame] | 108 | |
| 109 | _urlsafe_encode_translation = bytes.maketrans(b'+/', b'-_') |
| 110 | _urlsafe_decode_translation = bytes.maketrans(b'-_', b'+/') |
| 111 | |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 112 | def urlsafe_b64encode(s): |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 113 | """Encode a byte string using a url-safe Base64 alphabet. |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 114 | |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 115 | s is the byte string to encode. The encoded byte string is |
| 116 | returned. The alphabet uses '-' instead of '+' and '_' instead of |
| 117 | '/'. |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 118 | """ |
Guido van Rossum | 95c1c48 | 2012-06-22 15:16:09 -0700 | [diff] [blame] | 119 | return b64encode(s).translate(_urlsafe_encode_translation) |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 120 | |
| 121 | def urlsafe_b64decode(s): |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 122 | """Decode a byte string encoded with the standard Base64 alphabet. |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 123 | |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 124 | s is the byte string to decode. The decoded byte string is |
| 125 | returned. binascii.Error is raised if the input is incorrectly |
| 126 | padded or if there are non-alphabet characters present in the |
| 127 | input. |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 128 | |
| 129 | The alphabet uses '-' instead of '+' and '_' instead of '/'. |
| 130 | """ |
Guido van Rossum | 95c1c48 | 2012-06-22 15:16:09 -0700 | [diff] [blame] | 131 | s = _bytes_from_decode_data(s) |
| 132 | s = s.translate(_urlsafe_decode_translation) |
| 133 | return b64decode(s) |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 134 | |
| 135 | |
Antoine Pitrou | fd03645 | 2008-08-19 17:56:33 +0000 | [diff] [blame] | 136 | |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 137 | # Base32 encoding/decoding must be done in Python |
Serhiy Storchaka | 87aa7dc | 2013-05-19 11:49:32 +0300 | [diff] [blame] | 138 | _b32alphabet = b'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567' |
| 139 | _b32tab = [bytes([i]) for i in _b32alphabet] |
| 140 | _b32tab2 = [a + b for a in _b32tab for b in _b32tab] |
| 141 | _b32rev = {v: k for k, v in enumerate(_b32alphabet)} |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 142 | |
| 143 | def b32encode(s): |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 144 | """Encode a byte string using Base32. |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 145 | |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 146 | s is the byte string to encode. The encoded byte string is returned. |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 147 | """ |
Guido van Rossum | 254348e | 2007-11-21 19:29:53 +0000 | [diff] [blame] | 148 | if not isinstance(s, bytes_types): |
Nick Coghlan | fdf239a | 2013-10-03 00:43:22 +1000 | [diff] [blame^] | 149 | s = memoryview(s).tobytes() |
Serhiy Storchaka | 87aa7dc | 2013-05-19 11:49:32 +0300 | [diff] [blame] | 150 | leftover = len(s) % 5 |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 151 | # Pad the last quantum with zero bits if necessary |
| 152 | if leftover: |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 153 | s = s + bytes(5 - leftover) # Don't use += ! |
Serhiy Storchaka | 2c3f2f1 | 2013-05-19 11:41:15 +0300 | [diff] [blame] | 154 | encoded = bytearray() |
Serhiy Storchaka | 87aa7dc | 2013-05-19 11:49:32 +0300 | [diff] [blame] | 155 | from_bytes = int.from_bytes |
| 156 | b32tab2 = _b32tab2 |
| 157 | for i in range(0, len(s), 5): |
| 158 | c = from_bytes(s[i: i + 5], 'big') |
| 159 | encoded += (b32tab2[c >> 30] + # bits 1 - 10 |
| 160 | b32tab2[(c >> 20) & 0x3ff] + # bits 11 - 20 |
| 161 | b32tab2[(c >> 10) & 0x3ff] + # bits 21 - 30 |
| 162 | b32tab2[c & 0x3ff] # bits 31 - 40 |
| 163 | ) |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 164 | # Adjust for any leftover partial quanta |
| 165 | if leftover == 1: |
Serhiy Storchaka | 2c3f2f1 | 2013-05-19 11:41:15 +0300 | [diff] [blame] | 166 | encoded[-6:] = b'======' |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 167 | elif leftover == 2: |
Serhiy Storchaka | 2c3f2f1 | 2013-05-19 11:41:15 +0300 | [diff] [blame] | 168 | encoded[-4:] = b'====' |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 169 | elif leftover == 3: |
Serhiy Storchaka | 2c3f2f1 | 2013-05-19 11:41:15 +0300 | [diff] [blame] | 170 | encoded[-3:] = b'===' |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 171 | elif leftover == 4: |
Serhiy Storchaka | 2c3f2f1 | 2013-05-19 11:41:15 +0300 | [diff] [blame] | 172 | encoded[-1:] = b'=' |
| 173 | return bytes(encoded) |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 174 | |
| 175 | def b32decode(s, casefold=False, map01=None): |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 176 | """Decode a Base32 encoded byte string. |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 177 | |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 178 | s is the byte string to decode. Optional casefold is a flag |
| 179 | specifying whether a lowercase alphabet is acceptable as input. |
| 180 | For security purposes, the default is False. |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 181 | |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 182 | RFC 3548 allows for optional mapping of the digit 0 (zero) to the |
| 183 | letter O (oh), and for optional mapping of the digit 1 (one) to |
| 184 | either the letter I (eye) or letter L (el). The optional argument |
| 185 | map01 when not None, specifies which letter the digit 1 should be |
| 186 | mapped to (when map01 is not None, the digit 0 is always mapped to |
| 187 | the letter O). For security purposes the default is None, so that |
| 188 | 0 and 1 are not allowed in the input. |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 189 | |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 190 | The decoded byte string is returned. binascii.Error is raised if |
| 191 | the input is incorrectly padded or if there are non-alphabet |
| 192 | characters present in the input. |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 193 | """ |
Antoine Pitrou | ea6b4d5 | 2012-02-20 19:30:23 +0100 | [diff] [blame] | 194 | s = _bytes_from_decode_data(s) |
Serhiy Storchaka | 87aa7dc | 2013-05-19 11:49:32 +0300 | [diff] [blame] | 195 | if len(s) % 8: |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 196 | raise binascii.Error('Incorrect padding') |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 197 | # Handle section 2.4 zero and one mapping. The flag map01 will be either |
| 198 | # False, or the character to map the digit 1 (one) to. It should be |
| 199 | # either L (el) or I (eye). |
Alexandre Vassalotti | 5209857f | 2008-05-03 04:39:38 +0000 | [diff] [blame] | 200 | if map01 is not None: |
Antoine Pitrou | ea6b4d5 | 2012-02-20 19:30:23 +0100 | [diff] [blame] | 201 | map01 = _bytes_from_decode_data(map01) |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 202 | assert len(map01) == 1, repr(map01) |
Guido van Rossum | 95c1c48 | 2012-06-22 15:16:09 -0700 | [diff] [blame] | 203 | s = s.translate(bytes.maketrans(b'01', b'O' + map01)) |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 204 | if casefold: |
Guido van Rossum | 98297ee | 2007-11-06 21:34:58 +0000 | [diff] [blame] | 205 | s = s.upper() |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 206 | # Strip off pad characters from the right. We need to count the pad |
| 207 | # characters because this will tell us how many null bytes to remove from |
| 208 | # the end of the decoded string. |
Serhiy Storchaka | 87aa7dc | 2013-05-19 11:49:32 +0300 | [diff] [blame] | 209 | l = len(s) |
| 210 | s = s.rstrip(b'=') |
| 211 | padchars = l - len(s) |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 212 | # Now decode the full quanta |
Serhiy Storchaka | 87aa7dc | 2013-05-19 11:49:32 +0300 | [diff] [blame] | 213 | decoded = bytearray() |
| 214 | b32rev = _b32rev |
| 215 | for i in range(0, len(s), 8): |
| 216 | quanta = s[i: i + 8] |
| 217 | acc = 0 |
| 218 | try: |
| 219 | for c in quanta: |
| 220 | acc = (acc << 5) + b32rev[c] |
| 221 | except KeyError: |
Serhiy Storchaka | 5cc9d32 | 2013-05-28 15:42:34 +0300 | [diff] [blame] | 222 | raise binascii.Error('Non-base32 digit found') from None |
Serhiy Storchaka | 87aa7dc | 2013-05-19 11:49:32 +0300 | [diff] [blame] | 223 | decoded += acc.to_bytes(5, 'big') |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 224 | # Process the last, partial quanta |
Serhiy Storchaka | 87aa7dc | 2013-05-19 11:49:32 +0300 | [diff] [blame] | 225 | if padchars: |
| 226 | acc <<= 5 * padchars |
| 227 | last = acc.to_bytes(5, 'big') |
| 228 | if padchars == 1: |
| 229 | decoded[-5:] = last[:-1] |
| 230 | elif padchars == 3: |
| 231 | decoded[-5:] = last[:-2] |
| 232 | elif padchars == 4: |
| 233 | decoded[-5:] = last[:-3] |
| 234 | elif padchars == 6: |
| 235 | decoded[-5:] = last[:-4] |
| 236 | else: |
| 237 | raise binascii.Error('Incorrect padding') |
| 238 | return bytes(decoded) |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 239 | |
| 240 | |
Antoine Pitrou | fd03645 | 2008-08-19 17:56:33 +0000 | [diff] [blame] | 241 | |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 242 | # RFC 3548, Base 16 Alphabet specifies uppercase, but hexlify() returns |
| 243 | # lowercase. The RFC also recommends against accepting input case |
| 244 | # insensitively. |
| 245 | def b16encode(s): |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 246 | """Encode a byte string using Base16. |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 247 | |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 248 | s is the byte string to encode. The encoded byte string is returned. |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 249 | """ |
Guido van Rossum | 98297ee | 2007-11-06 21:34:58 +0000 | [diff] [blame] | 250 | return binascii.hexlify(s).upper() |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 251 | |
| 252 | |
| 253 | def b16decode(s, casefold=False): |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 254 | """Decode a Base16 encoded byte string. |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 255 | |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 256 | s is the byte string to decode. Optional casefold is a flag |
| 257 | specifying whether a lowercase alphabet is acceptable as input. |
| 258 | For security purposes, the default is False. |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 259 | |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 260 | The decoded byte string is returned. binascii.Error is raised if |
| 261 | s were incorrectly padded or if there are non-alphabet characters |
| 262 | present in the string. |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 263 | """ |
Antoine Pitrou | ea6b4d5 | 2012-02-20 19:30:23 +0100 | [diff] [blame] | 264 | s = _bytes_from_decode_data(s) |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 265 | if casefold: |
Guido van Rossum | 98297ee | 2007-11-06 21:34:58 +0000 | [diff] [blame] | 266 | s = s.upper() |
Antoine Pitrou | fd03645 | 2008-08-19 17:56:33 +0000 | [diff] [blame] | 267 | if re.search(b'[^0-9A-F]', s): |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 268 | raise binascii.Error('Non-base16 digit found') |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 269 | return binascii.unhexlify(s) |
| 270 | |
| 271 | |
Antoine Pitrou | fd03645 | 2008-08-19 17:56:33 +0000 | [diff] [blame] | 272 | |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 273 | # Legacy interface. This code could be cleaned up since I don't believe |
| 274 | # binascii has any line length limitations. It just doesn't seem worth it |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 275 | # though. The files should be opened in binary mode. |
Skip Montanaro | e99d5ea | 2001-01-20 19:54:20 +0000 | [diff] [blame] | 276 | |
Guido van Rossum | f194546 | 1995-06-14 23:43:44 +0000 | [diff] [blame] | 277 | MAXLINESIZE = 76 # Excluding the CRLF |
Guido van Rossum | 54e54c6 | 2001-09-04 19:14:14 +0000 | [diff] [blame] | 278 | MAXBINSIZE = (MAXLINESIZE//4)*3 |
Guido van Rossum | f194546 | 1995-06-14 23:43:44 +0000 | [diff] [blame] | 279 | |
Guido van Rossum | f194546 | 1995-06-14 23:43:44 +0000 | [diff] [blame] | 280 | def encode(input, output): |
Guido van Rossum | 54a40cb | 2007-08-27 22:27:41 +0000 | [diff] [blame] | 281 | """Encode a file; input and output are binary files.""" |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 282 | while True: |
Guido van Rossum | 4acc25b | 2000-02-02 15:10:15 +0000 | [diff] [blame] | 283 | s = input.read(MAXBINSIZE) |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 284 | if not s: |
| 285 | break |
Guido van Rossum | 4acc25b | 2000-02-02 15:10:15 +0000 | [diff] [blame] | 286 | while len(s) < MAXBINSIZE: |
| 287 | ns = input.read(MAXBINSIZE-len(s)) |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 288 | if not ns: |
| 289 | break |
| 290 | s += ns |
Guido van Rossum | 4acc25b | 2000-02-02 15:10:15 +0000 | [diff] [blame] | 291 | line = binascii.b2a_base64(s) |
| 292 | output.write(line) |
Guido van Rossum | f194546 | 1995-06-14 23:43:44 +0000 | [diff] [blame] | 293 | |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 294 | |
Guido van Rossum | f194546 | 1995-06-14 23:43:44 +0000 | [diff] [blame] | 295 | def decode(input, output): |
Guido van Rossum | 54a40cb | 2007-08-27 22:27:41 +0000 | [diff] [blame] | 296 | """Decode a file; input and output are binary files.""" |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 297 | while True: |
Guido van Rossum | 4acc25b | 2000-02-02 15:10:15 +0000 | [diff] [blame] | 298 | line = input.readline() |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 299 | if not line: |
| 300 | break |
Guido van Rossum | 4acc25b | 2000-02-02 15:10:15 +0000 | [diff] [blame] | 301 | s = binascii.a2b_base64(line) |
| 302 | output.write(s) |
Guido van Rossum | f194546 | 1995-06-14 23:43:44 +0000 | [diff] [blame] | 303 | |
Nick Coghlan | fdf239a | 2013-10-03 00:43:22 +1000 | [diff] [blame^] | 304 | def _input_type_check(s): |
| 305 | try: |
| 306 | m = memoryview(s) |
| 307 | except TypeError as err: |
| 308 | msg = "expected bytes-like object, not %s" % s.__class__.__name__ |
| 309 | raise TypeError(msg) from err |
| 310 | if m.format not in ('c', 'b', 'B'): |
| 311 | msg = ("expected single byte elements, not %r from %s" % |
| 312 | (m.format, s.__class__.__name__)) |
| 313 | raise TypeError(msg) |
| 314 | if m.ndim != 1: |
| 315 | msg = ("expected 1-D data, not %d-D data from %s" % |
| 316 | (m.ndim, s.__class__.__name__)) |
| 317 | raise TypeError(msg) |
| 318 | |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 319 | |
Georg Brandl | b54d801 | 2009-06-04 09:11:51 +0000 | [diff] [blame] | 320 | def encodebytes(s): |
| 321 | """Encode a bytestring into a bytestring containing multiple lines |
| 322 | of base-64 data.""" |
Nick Coghlan | fdf239a | 2013-10-03 00:43:22 +1000 | [diff] [blame^] | 323 | _input_type_check(s) |
Peter Schneider-Kamp | fbb2b4c | 2001-06-07 18:56:13 +0000 | [diff] [blame] | 324 | pieces = [] |
| 325 | for i in range(0, len(s), MAXBINSIZE): |
| 326 | chunk = s[i : i + MAXBINSIZE] |
| 327 | pieces.append(binascii.b2a_base64(chunk)) |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 328 | return b"".join(pieces) |
Guido van Rossum | f194546 | 1995-06-14 23:43:44 +0000 | [diff] [blame] | 329 | |
Georg Brandl | b54d801 | 2009-06-04 09:11:51 +0000 | [diff] [blame] | 330 | def encodestring(s): |
| 331 | """Legacy alias of encodebytes().""" |
| 332 | import warnings |
| 333 | warnings.warn("encodestring() is a deprecated alias, use encodebytes()", |
| 334 | DeprecationWarning, 2) |
| 335 | return encodebytes(s) |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 336 | |
Guido van Rossum | 54a40cb | 2007-08-27 22:27:41 +0000 | [diff] [blame] | 337 | |
Georg Brandl | b54d801 | 2009-06-04 09:11:51 +0000 | [diff] [blame] | 338 | def decodebytes(s): |
| 339 | """Decode a bytestring of base-64 data into a bytestring.""" |
Nick Coghlan | fdf239a | 2013-10-03 00:43:22 +1000 | [diff] [blame^] | 340 | _input_type_check(s) |
Peter Schneider-Kamp | fbb2b4c | 2001-06-07 18:56:13 +0000 | [diff] [blame] | 341 | return binascii.a2b_base64(s) |
Guido van Rossum | f194546 | 1995-06-14 23:43:44 +0000 | [diff] [blame] | 342 | |
Georg Brandl | b54d801 | 2009-06-04 09:11:51 +0000 | [diff] [blame] | 343 | def decodestring(s): |
| 344 | """Legacy alias of decodebytes().""" |
| 345 | import warnings |
| 346 | warnings.warn("decodestring() is a deprecated alias, use decodebytes()", |
| 347 | DeprecationWarning, 2) |
| 348 | return decodebytes(s) |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 349 | |
Antoine Pitrou | fd03645 | 2008-08-19 17:56:33 +0000 | [diff] [blame] | 350 | |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 351 | # Usable as a script... |
| 352 | def main(): |
| 353 | """Small main program""" |
Guido van Rossum | 4acc25b | 2000-02-02 15:10:15 +0000 | [diff] [blame] | 354 | import sys, getopt |
| 355 | try: |
| 356 | opts, args = getopt.getopt(sys.argv[1:], 'deut') |
Guido van Rossum | b940e11 | 2007-01-10 16:19:56 +0000 | [diff] [blame] | 357 | except getopt.error as msg: |
Guido van Rossum | 4acc25b | 2000-02-02 15:10:15 +0000 | [diff] [blame] | 358 | sys.stdout = sys.stderr |
Guido van Rossum | be19ed7 | 2007-02-09 05:37:30 +0000 | [diff] [blame] | 359 | print(msg) |
| 360 | print("""usage: %s [-d|-e|-u|-t] [file|-] |
Guido van Rossum | 4acc25b | 2000-02-02 15:10:15 +0000 | [diff] [blame] | 361 | -d, -u: decode |
| 362 | -e: encode (default) |
Guido van Rossum | be19ed7 | 2007-02-09 05:37:30 +0000 | [diff] [blame] | 363 | -t: encode and decode string 'Aladdin:open sesame'"""%sys.argv[0]) |
Guido van Rossum | 4acc25b | 2000-02-02 15:10:15 +0000 | [diff] [blame] | 364 | sys.exit(2) |
| 365 | func = encode |
| 366 | for o, a in opts: |
| 367 | if o == '-e': func = encode |
| 368 | if o == '-d': func = decode |
| 369 | if o == '-u': func = decode |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 370 | if o == '-t': test(); return |
Guido van Rossum | 4acc25b | 2000-02-02 15:10:15 +0000 | [diff] [blame] | 371 | if args and args[0] != '-': |
Antoine Pitrou | b86680e | 2010-10-14 21:15:17 +0000 | [diff] [blame] | 372 | with open(args[0], 'rb') as f: |
| 373 | func(f, sys.stdout.buffer) |
Guido van Rossum | 4acc25b | 2000-02-02 15:10:15 +0000 | [diff] [blame] | 374 | else: |
Victor Stinner | 479736b | 2010-05-25 21:12:34 +0000 | [diff] [blame] | 375 | func(sys.stdin.buffer, sys.stdout.buffer) |
Guido van Rossum | f194546 | 1995-06-14 23:43:44 +0000 | [diff] [blame] | 376 | |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 377 | |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 378 | def test(): |
| 379 | s0 = b"Aladdin:open sesame" |
| 380 | print(repr(s0)) |
Georg Brandl | 706824f | 2009-06-04 09:42:55 +0000 | [diff] [blame] | 381 | s1 = encodebytes(s0) |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 382 | print(repr(s1)) |
Georg Brandl | 706824f | 2009-06-04 09:42:55 +0000 | [diff] [blame] | 383 | s2 = decodebytes(s1) |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 384 | print(repr(s2)) |
| 385 | assert s0 == s2 |
Guido van Rossum | f194546 | 1995-06-14 23:43:44 +0000 | [diff] [blame] | 386 | |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 387 | |
Guido van Rossum | f194546 | 1995-06-14 23:43:44 +0000 | [diff] [blame] | 388 | if __name__ == '__main__': |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 389 | main() |