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 |
| 141 | _b32alphabet = { |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 142 | 0: b'A', 9: b'J', 18: b'S', 27: b'3', |
| 143 | 1: b'B', 10: b'K', 19: b'T', 28: b'4', |
| 144 | 2: b'C', 11: b'L', 20: b'U', 29: b'5', |
| 145 | 3: b'D', 12: b'M', 21: b'V', 30: b'6', |
| 146 | 4: b'E', 13: b'N', 22: b'W', 31: b'7', |
| 147 | 5: b'F', 14: b'O', 23: b'X', |
| 148 | 6: b'G', 15: b'P', 24: b'Y', |
| 149 | 7: b'H', 16: b'Q', 25: b'Z', |
| 150 | 8: b'I', 17: b'R', 26: b'2', |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 151 | } |
| 152 | |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 153 | _b32tab = [v[0] for k, v in sorted(_b32alphabet.items())] |
| 154 | _b32rev = dict([(v[0], k) for k, v in _b32alphabet.items()]) |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 155 | |
| 156 | |
| 157 | def b32encode(s): |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 158 | """Encode a byte string using Base32. |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 159 | |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 160 | 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] | 161 | """ |
Guido van Rossum | 254348e | 2007-11-21 19:29:53 +0000 | [diff] [blame] | 162 | if not isinstance(s, bytes_types): |
Alexandre Vassalotti | 5209857f | 2008-05-03 04:39:38 +0000 | [diff] [blame] | 163 | raise TypeError("expected bytes, not %s" % s.__class__.__name__) |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 164 | quanta, leftover = divmod(len(s), 5) |
| 165 | # Pad the last quantum with zero bits if necessary |
| 166 | if leftover: |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 167 | s = s + bytes(5 - leftover) # Don't use += ! |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 168 | quanta += 1 |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 169 | encoded = bytes() |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 170 | for i in range(quanta): |
| 171 | # c1 and c2 are 16 bits wide, c3 is 8 bits wide. The intent of this |
| 172 | # code is to process the 40 bits in units of 5 bits. So we take the 1 |
| 173 | # leftover bit of c1 and tack it onto c2. Then we take the 2 leftover |
| 174 | # bits of c2 and tack them onto c3. The shifts and masks are intended |
| 175 | # to give us values of exactly 5 bits in width. |
| 176 | c1, c2, c3 = struct.unpack('!HHB', s[i*5:(i+1)*5]) |
| 177 | c2 += (c1 & 1) << 16 # 17 bits wide |
| 178 | c3 += (c2 & 3) << 8 # 10 bits wide |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 179 | encoded += bytes([_b32tab[c1 >> 11], # bits 1 - 5 |
| 180 | _b32tab[(c1 >> 6) & 0x1f], # bits 6 - 10 |
| 181 | _b32tab[(c1 >> 1) & 0x1f], # bits 11 - 15 |
| 182 | _b32tab[c2 >> 12], # bits 16 - 20 (1 - 5) |
| 183 | _b32tab[(c2 >> 7) & 0x1f], # bits 21 - 25 (6 - 10) |
| 184 | _b32tab[(c2 >> 2) & 0x1f], # bits 26 - 30 (11 - 15) |
| 185 | _b32tab[c3 >> 5], # bits 31 - 35 (1 - 5) |
| 186 | _b32tab[c3 & 0x1f], # bits 36 - 40 (1 - 5) |
| 187 | ]) |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 188 | # Adjust for any leftover partial quanta |
| 189 | if leftover == 1: |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 190 | return encoded[:-6] + b'======' |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 191 | elif leftover == 2: |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 192 | return encoded[:-4] + b'====' |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 193 | elif leftover == 3: |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 194 | return encoded[:-3] + b'===' |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 195 | elif leftover == 4: |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 196 | return encoded[:-1] + b'=' |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 197 | return encoded |
| 198 | |
| 199 | |
| 200 | def b32decode(s, casefold=False, map01=None): |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 201 | """Decode a Base32 encoded byte string. |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 202 | |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 203 | s is the byte string to decode. Optional casefold is a flag |
| 204 | specifying whether a lowercase alphabet is acceptable as input. |
| 205 | For security purposes, the default is False. |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 206 | |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 207 | RFC 3548 allows for optional mapping of the digit 0 (zero) to the |
| 208 | letter O (oh), and for optional mapping of the digit 1 (one) to |
| 209 | either the letter I (eye) or letter L (el). The optional argument |
| 210 | map01 when not None, specifies which letter the digit 1 should be |
| 211 | mapped to (when map01 is not None, the digit 0 is always mapped to |
| 212 | the letter O). For security purposes the default is None, so that |
| 213 | 0 and 1 are not allowed in the input. |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 214 | |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 215 | The decoded byte string is returned. binascii.Error is raised if |
| 216 | the input is incorrectly padded or if there are non-alphabet |
| 217 | characters present in the input. |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 218 | """ |
Antoine Pitrou | ea6b4d5 | 2012-02-20 19:30:23 +0100 | [diff] [blame] | 219 | s = _bytes_from_decode_data(s) |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 220 | quanta, leftover = divmod(len(s), 8) |
| 221 | if leftover: |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 222 | raise binascii.Error('Incorrect padding') |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 223 | # Handle section 2.4 zero and one mapping. The flag map01 will be either |
| 224 | # False, or the character to map the digit 1 (one) to. It should be |
| 225 | # either L (el) or I (eye). |
Alexandre Vassalotti | 5209857f | 2008-05-03 04:39:38 +0000 | [diff] [blame] | 226 | if map01 is not None: |
Antoine Pitrou | ea6b4d5 | 2012-02-20 19:30:23 +0100 | [diff] [blame] | 227 | map01 = _bytes_from_decode_data(map01) |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 228 | assert len(map01) == 1, repr(map01) |
Guido van Rossum | 95c1c48 | 2012-06-22 15:16:09 -0700 | [diff] [blame] | 229 | s = s.translate(bytes.maketrans(b'01', b'O' + map01)) |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 230 | if casefold: |
Guido van Rossum | 98297ee | 2007-11-06 21:34:58 +0000 | [diff] [blame] | 231 | s = s.upper() |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 232 | # Strip off pad characters from the right. We need to count the pad |
| 233 | # characters because this will tell us how many null bytes to remove from |
| 234 | # the end of the decoded string. |
| 235 | padchars = 0 |
Antoine Pitrou | fd03645 | 2008-08-19 17:56:33 +0000 | [diff] [blame] | 236 | mo = re.search(b'(?P<pad>[=]*)$', s) |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 237 | if mo: |
| 238 | padchars = len(mo.group('pad')) |
| 239 | if padchars > 0: |
| 240 | s = s[:-padchars] |
| 241 | # Now decode the full quanta |
| 242 | parts = [] |
| 243 | acc = 0 |
| 244 | shift = 35 |
| 245 | for c in s: |
| 246 | val = _b32rev.get(c) |
| 247 | if val is None: |
| 248 | raise TypeError('Non-base32 digit found') |
| 249 | acc += _b32rev[c] << shift |
| 250 | shift -= 5 |
| 251 | if shift < 0: |
Ezio Melotti | 84befb0 | 2010-07-28 00:23:21 +0000 | [diff] [blame] | 252 | parts.append(binascii.unhexlify(bytes('%010x' % acc, "ascii"))) |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 253 | acc = 0 |
| 254 | shift = 35 |
| 255 | # Process the last, partial quanta |
Guido van Rossum | 09549f4 | 2007-08-27 20:40:10 +0000 | [diff] [blame] | 256 | last = binascii.unhexlify(bytes('%010x' % acc, "ascii")) |
Andrew M. Kuchling | 6e57c2a | 2005-06-08 22:51:38 +0000 | [diff] [blame] | 257 | if padchars == 0: |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 258 | last = b'' # No characters |
Andrew M. Kuchling | 6e57c2a | 2005-06-08 22:51:38 +0000 | [diff] [blame] | 259 | elif padchars == 1: |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 260 | last = last[:-1] |
| 261 | elif padchars == 3: |
| 262 | last = last[:-2] |
| 263 | elif padchars == 4: |
| 264 | last = last[:-3] |
| 265 | elif padchars == 6: |
| 266 | last = last[:-4] |
Andrew M. Kuchling | 6e57c2a | 2005-06-08 22:51:38 +0000 | [diff] [blame] | 267 | else: |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 268 | raise binascii.Error('Incorrect padding') |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 269 | parts.append(last) |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 270 | return b''.join(parts) |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 271 | |
| 272 | |
Antoine Pitrou | fd03645 | 2008-08-19 17:56:33 +0000 | [diff] [blame] | 273 | |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 274 | # RFC 3548, Base 16 Alphabet specifies uppercase, but hexlify() returns |
| 275 | # lowercase. The RFC also recommends against accepting input case |
| 276 | # insensitively. |
| 277 | def b16encode(s): |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 278 | """Encode a byte string using Base16. |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 279 | |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 280 | 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] | 281 | """ |
Alexandre Vassalotti | 5209857f | 2008-05-03 04:39:38 +0000 | [diff] [blame] | 282 | if not isinstance(s, bytes_types): |
| 283 | raise TypeError("expected bytes, not %s" % s.__class__.__name__) |
Guido van Rossum | 98297ee | 2007-11-06 21:34:58 +0000 | [diff] [blame] | 284 | return binascii.hexlify(s).upper() |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 285 | |
| 286 | |
| 287 | def b16decode(s, casefold=False): |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 288 | """Decode a Base16 encoded byte string. |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 289 | |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 290 | s is the byte string to decode. Optional casefold is a flag |
| 291 | specifying whether a lowercase alphabet is acceptable as input. |
| 292 | For security purposes, the default is False. |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 293 | |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 294 | The decoded byte string is returned. binascii.Error is raised if |
| 295 | s were incorrectly padded or if there are non-alphabet characters |
| 296 | present in the string. |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 297 | """ |
Antoine Pitrou | ea6b4d5 | 2012-02-20 19:30:23 +0100 | [diff] [blame] | 298 | s = _bytes_from_decode_data(s) |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 299 | if casefold: |
Guido van Rossum | 98297ee | 2007-11-06 21:34:58 +0000 | [diff] [blame] | 300 | s = s.upper() |
Antoine Pitrou | fd03645 | 2008-08-19 17:56:33 +0000 | [diff] [blame] | 301 | if re.search(b'[^0-9A-F]', s): |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 302 | raise binascii.Error('Non-base16 digit found') |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 303 | return binascii.unhexlify(s) |
| 304 | |
| 305 | |
Antoine Pitrou | fd03645 | 2008-08-19 17:56:33 +0000 | [diff] [blame] | 306 | |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 307 | # Legacy interface. This code could be cleaned up since I don't believe |
| 308 | # 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] | 309 | # though. The files should be opened in binary mode. |
Skip Montanaro | e99d5ea | 2001-01-20 19:54:20 +0000 | [diff] [blame] | 310 | |
Guido van Rossum | f194546 | 1995-06-14 23:43:44 +0000 | [diff] [blame] | 311 | MAXLINESIZE = 76 # Excluding the CRLF |
Guido van Rossum | 54e54c6 | 2001-09-04 19:14:14 +0000 | [diff] [blame] | 312 | MAXBINSIZE = (MAXLINESIZE//4)*3 |
Guido van Rossum | f194546 | 1995-06-14 23:43:44 +0000 | [diff] [blame] | 313 | |
Guido van Rossum | f194546 | 1995-06-14 23:43:44 +0000 | [diff] [blame] | 314 | def encode(input, output): |
Guido van Rossum | 54a40cb | 2007-08-27 22:27:41 +0000 | [diff] [blame] | 315 | """Encode a file; input and output are binary files.""" |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 316 | while True: |
Guido van Rossum | 4acc25b | 2000-02-02 15:10:15 +0000 | [diff] [blame] | 317 | s = input.read(MAXBINSIZE) |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 318 | if not s: |
| 319 | break |
Guido van Rossum | 4acc25b | 2000-02-02 15:10:15 +0000 | [diff] [blame] | 320 | while len(s) < MAXBINSIZE: |
| 321 | ns = input.read(MAXBINSIZE-len(s)) |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 322 | if not ns: |
| 323 | break |
| 324 | s += ns |
Guido van Rossum | 4acc25b | 2000-02-02 15:10:15 +0000 | [diff] [blame] | 325 | line = binascii.b2a_base64(s) |
| 326 | output.write(line) |
Guido van Rossum | f194546 | 1995-06-14 23:43:44 +0000 | [diff] [blame] | 327 | |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 328 | |
Guido van Rossum | f194546 | 1995-06-14 23:43:44 +0000 | [diff] [blame] | 329 | def decode(input, output): |
Guido van Rossum | 54a40cb | 2007-08-27 22:27:41 +0000 | [diff] [blame] | 330 | """Decode a file; input and output are binary files.""" |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 331 | while True: |
Guido van Rossum | 4acc25b | 2000-02-02 15:10:15 +0000 | [diff] [blame] | 332 | line = input.readline() |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 333 | if not line: |
| 334 | break |
Guido van Rossum | 4acc25b | 2000-02-02 15:10:15 +0000 | [diff] [blame] | 335 | s = binascii.a2b_base64(line) |
| 336 | output.write(s) |
Guido van Rossum | f194546 | 1995-06-14 23:43:44 +0000 | [diff] [blame] | 337 | |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 338 | |
Georg Brandl | b54d801 | 2009-06-04 09:11:51 +0000 | [diff] [blame] | 339 | def encodebytes(s): |
| 340 | """Encode a bytestring into a bytestring containing multiple lines |
| 341 | of base-64 data.""" |
Guido van Rossum | 254348e | 2007-11-21 19:29:53 +0000 | [diff] [blame] | 342 | if not isinstance(s, bytes_types): |
Guido van Rossum | 98b349f | 2007-08-27 21:47:52 +0000 | [diff] [blame] | 343 | raise TypeError("expected bytes, not %s" % s.__class__.__name__) |
Peter Schneider-Kamp | fbb2b4c | 2001-06-07 18:56:13 +0000 | [diff] [blame] | 344 | pieces = [] |
| 345 | for i in range(0, len(s), MAXBINSIZE): |
| 346 | chunk = s[i : i + MAXBINSIZE] |
| 347 | pieces.append(binascii.b2a_base64(chunk)) |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 348 | return b"".join(pieces) |
Guido van Rossum | f194546 | 1995-06-14 23:43:44 +0000 | [diff] [blame] | 349 | |
Georg Brandl | b54d801 | 2009-06-04 09:11:51 +0000 | [diff] [blame] | 350 | def encodestring(s): |
| 351 | """Legacy alias of encodebytes().""" |
| 352 | import warnings |
| 353 | warnings.warn("encodestring() is a deprecated alias, use encodebytes()", |
| 354 | DeprecationWarning, 2) |
| 355 | return encodebytes(s) |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 356 | |
Guido van Rossum | 54a40cb | 2007-08-27 22:27:41 +0000 | [diff] [blame] | 357 | |
Georg Brandl | b54d801 | 2009-06-04 09:11:51 +0000 | [diff] [blame] | 358 | def decodebytes(s): |
| 359 | """Decode a bytestring of base-64 data into a bytestring.""" |
Guido van Rossum | 254348e | 2007-11-21 19:29:53 +0000 | [diff] [blame] | 360 | if not isinstance(s, bytes_types): |
Guido van Rossum | 98b349f | 2007-08-27 21:47:52 +0000 | [diff] [blame] | 361 | raise TypeError("expected bytes, not %s" % s.__class__.__name__) |
Peter Schneider-Kamp | fbb2b4c | 2001-06-07 18:56:13 +0000 | [diff] [blame] | 362 | return binascii.a2b_base64(s) |
Guido van Rossum | f194546 | 1995-06-14 23:43:44 +0000 | [diff] [blame] | 363 | |
Georg Brandl | b54d801 | 2009-06-04 09:11:51 +0000 | [diff] [blame] | 364 | def decodestring(s): |
| 365 | """Legacy alias of decodebytes().""" |
| 366 | import warnings |
| 367 | warnings.warn("decodestring() is a deprecated alias, use decodebytes()", |
| 368 | DeprecationWarning, 2) |
| 369 | return decodebytes(s) |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 370 | |
Antoine Pitrou | fd03645 | 2008-08-19 17:56:33 +0000 | [diff] [blame] | 371 | |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 372 | # Usable as a script... |
| 373 | def main(): |
| 374 | """Small main program""" |
Guido van Rossum | 4acc25b | 2000-02-02 15:10:15 +0000 | [diff] [blame] | 375 | import sys, getopt |
| 376 | try: |
| 377 | opts, args = getopt.getopt(sys.argv[1:], 'deut') |
Guido van Rossum | b940e11 | 2007-01-10 16:19:56 +0000 | [diff] [blame] | 378 | except getopt.error as msg: |
Guido van Rossum | 4acc25b | 2000-02-02 15:10:15 +0000 | [diff] [blame] | 379 | sys.stdout = sys.stderr |
Guido van Rossum | be19ed7 | 2007-02-09 05:37:30 +0000 | [diff] [blame] | 380 | print(msg) |
| 381 | print("""usage: %s [-d|-e|-u|-t] [file|-] |
Guido van Rossum | 4acc25b | 2000-02-02 15:10:15 +0000 | [diff] [blame] | 382 | -d, -u: decode |
| 383 | -e: encode (default) |
Guido van Rossum | be19ed7 | 2007-02-09 05:37:30 +0000 | [diff] [blame] | 384 | -t: encode and decode string 'Aladdin:open sesame'"""%sys.argv[0]) |
Guido van Rossum | 4acc25b | 2000-02-02 15:10:15 +0000 | [diff] [blame] | 385 | sys.exit(2) |
| 386 | func = encode |
| 387 | for o, a in opts: |
| 388 | if o == '-e': func = encode |
| 389 | if o == '-d': func = decode |
| 390 | if o == '-u': func = decode |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 391 | if o == '-t': test(); return |
Guido van Rossum | 4acc25b | 2000-02-02 15:10:15 +0000 | [diff] [blame] | 392 | if args and args[0] != '-': |
Antoine Pitrou | b86680e | 2010-10-14 21:15:17 +0000 | [diff] [blame] | 393 | with open(args[0], 'rb') as f: |
| 394 | func(f, sys.stdout.buffer) |
Guido van Rossum | 4acc25b | 2000-02-02 15:10:15 +0000 | [diff] [blame] | 395 | else: |
Victor Stinner | 479736b | 2010-05-25 21:12:34 +0000 | [diff] [blame] | 396 | func(sys.stdin.buffer, sys.stdout.buffer) |
Guido van Rossum | f194546 | 1995-06-14 23:43:44 +0000 | [diff] [blame] | 397 | |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 398 | |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 399 | def test(): |
| 400 | s0 = b"Aladdin:open sesame" |
| 401 | print(repr(s0)) |
Georg Brandl | 706824f | 2009-06-04 09:42:55 +0000 | [diff] [blame] | 402 | s1 = encodebytes(s0) |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 403 | print(repr(s1)) |
Georg Brandl | 706824f | 2009-06-04 09:42:55 +0000 | [diff] [blame] | 404 | s2 = decodebytes(s1) |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 405 | print(repr(s2)) |
| 406 | assert s0 == s2 |
Guido van Rossum | f194546 | 1995-06-14 23:43:44 +0000 | [diff] [blame] | 407 | |
Barry Warsaw | 4c904d1 | 2004-01-04 01:12:26 +0000 | [diff] [blame] | 408 | |
Guido van Rossum | f194546 | 1995-06-14 23:43:44 +0000 | [diff] [blame] | 409 | if __name__ == '__main__': |
Guido van Rossum | 4581ae5 | 2007-05-22 21:56:47 +0000 | [diff] [blame] | 410 | main() |