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