Source file src/pkg/encoding/base32/base32.go
1 // Copyright 2011 The Go Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 // Package base32 implements base32 encoding as specified by RFC 4648. 6 package base32 7 8 import ( 9 "io" 10 "strconv" 11 ) 12 13 /* 14 * Encodings 15 */ 16 17 // An Encoding is a radix 32 encoding/decoding scheme, defined by a 18 // 32-character alphabet. The most common is the "base32" encoding 19 // introduced for SASL GSSAPI and standardized in RFC 4648. 20 // The alternate "base32hex" encoding is used in DNSSEC. 21 type Encoding struct { 22 encode string 23 decodeMap [256]byte 24 } 25 26 const encodeStd = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567" 27 const encodeHex = "0123456789ABCDEFGHIJKLMNOPQRSTUV" 28 29 // NewEncoding returns a new Encoding defined by the given alphabet, 30 // which must be a 32-byte string. 31 func NewEncoding(encoder string) *Encoding { 32 e := new(Encoding) 33 e.encode = encoder 34 for i := 0; i < len(e.decodeMap); i++ { 35 e.decodeMap[i] = 0xFF 36 } 37 for i := 0; i < len(encoder); i++ { 38 e.decodeMap[encoder[i]] = byte(i) 39 } 40 return e 41 } 42 43 // StdEncoding is the standard base32 encoding, as defined in 44 // RFC 4648. 45 var StdEncoding = NewEncoding(encodeStd) 46 47 // HexEncoding is the ``Extended Hex Alphabet'' defined in RFC 4648. 48 // It is typically used in DNS. 49 var HexEncoding = NewEncoding(encodeHex) 50 51 /* 52 * Encoder 53 */ 54 55 // Encode encodes src using the encoding enc, writing 56 // EncodedLen(len(src)) bytes to dst. 57 // 58 // The encoding pads the output to a multiple of 8 bytes, 59 // so Encode is not appropriate for use on individual blocks 60 // of a large data stream. Use NewEncoder() instead. 61 func (enc *Encoding) Encode(dst, src []byte) { 62 if len(src) == 0 { 63 return 64 } 65 66 for len(src) > 0 { 67 dst[0] = 0 68 dst[1] = 0 69 dst[2] = 0 70 dst[3] = 0 71 dst[4] = 0 72 dst[5] = 0 73 dst[6] = 0 74 dst[7] = 0 75 76 // Unpack 8x 5-bit source blocks into a 5 byte 77 // destination quantum 78 switch len(src) { 79 default: 80 dst[7] |= src[4] & 0x1F 81 dst[6] |= src[4] >> 5 82 fallthrough 83 case 4: 84 dst[6] |= (src[3] << 3) & 0x1F 85 dst[5] |= (src[3] >> 2) & 0x1F 86 dst[4] |= src[3] >> 7 87 fallthrough 88 case 3: 89 dst[4] |= (src[2] << 1) & 0x1F 90 dst[3] |= (src[2] >> 4) & 0x1F 91 fallthrough 92 case 2: 93 dst[3] |= (src[1] << 4) & 0x1F 94 dst[2] |= (src[1] >> 1) & 0x1F 95 dst[1] |= (src[1] >> 6) & 0x1F 96 fallthrough 97 case 1: 98 dst[1] |= (src[0] << 2) & 0x1F 99 dst[0] |= src[0] >> 3 100 } 101 102 // Encode 5-bit blocks using the base32 alphabet 103 for j := 0; j < 8; j++ { 104 dst[j] = enc.encode[dst[j]] 105 } 106 107 // Pad the final quantum 108 if len(src) < 5 { 109 dst[7] = '=' 110 if len(src) < 4 { 111 dst[6] = '=' 112 dst[5] = '=' 113 if len(src) < 3 { 114 dst[4] = '=' 115 if len(src) < 2 { 116 dst[3] = '=' 117 dst[2] = '=' 118 } 119 } 120 } 121 break 122 } 123 src = src[5:] 124 dst = dst[8:] 125 } 126 } 127 128 // EncodeToString returns the base32 encoding of src. 129 func (enc *Encoding) EncodeToString(src []byte) string { 130 buf := make([]byte, enc.EncodedLen(len(src))) 131 enc.Encode(buf, src) 132 return string(buf) 133 } 134 135 type encoder struct { 136 err error 137 enc *Encoding 138 w io.Writer 139 buf [5]byte // buffered data waiting to be encoded 140 nbuf int // number of bytes in buf 141 out [1024]byte // output buffer 142 } 143 144 func (e *encoder) Write(p []byte) (n int, err error) { 145 if e.err != nil { 146 return 0, e.err 147 } 148 149 // Leading fringe. 150 if e.nbuf > 0 { 151 var i int 152 for i = 0; i < len(p) && e.nbuf < 5; i++ { 153 e.buf[e.nbuf] = p[i] 154 e.nbuf++ 155 } 156 n += i 157 p = p[i:] 158 if e.nbuf < 5 { 159 return 160 } 161 e.enc.Encode(e.out[0:], e.buf[0:]) 162 if _, e.err = e.w.Write(e.out[0:8]); e.err != nil { 163 return n, e.err 164 } 165 e.nbuf = 0 166 } 167 168 // Large interior chunks. 169 for len(p) >= 5 { 170 nn := len(e.out) / 8 * 5 171 if nn > len(p) { 172 nn = len(p) 173 } 174 nn -= nn % 5 175 if nn > 0 { 176 e.enc.Encode(e.out[0:], p[0:nn]) 177 if _, e.err = e.w.Write(e.out[0 : nn/5*8]); e.err != nil { 178 return n, e.err 179 } 180 } 181 n += nn 182 p = p[nn:] 183 } 184 185 // Trailing fringe. 186 for i := 0; i < len(p); i++ { 187 e.buf[i] = p[i] 188 } 189 e.nbuf = len(p) 190 n += len(p) 191 return 192 } 193 194 // Close flushes any pending output from the encoder. 195 // It is an error to call Write after calling Close. 196 func (e *encoder) Close() error { 197 // If there's anything left in the buffer, flush it out 198 if e.err == nil && e.nbuf > 0 { 199 e.enc.Encode(e.out[0:], e.buf[0:e.nbuf]) 200 e.nbuf = 0 201 _, e.err = e.w.Write(e.out[0:8]) 202 } 203 return e.err 204 } 205 206 // NewEncoder returns a new base32 stream encoder. Data written to 207 // the returned writer will be encoded using enc and then written to w. 208 // Base32 encodings operate in 5-byte blocks; when finished 209 // writing, the caller must Close the returned encoder to flush any 210 // partially written blocks. 211 func NewEncoder(enc *Encoding, w io.Writer) io.WriteCloser { 212 return &encoder{enc: enc, w: w} 213 } 214 215 // EncodedLen returns the length in bytes of the base32 encoding 216 // of an input buffer of length n. 217 func (enc *Encoding) EncodedLen(n int) int { return (n + 4) / 5 * 8 } 218 219 /* 220 * Decoder 221 */ 222 223 type CorruptInputError int64 224 225 func (e CorruptInputError) Error() string { 226 return "illegal base32 data at input byte " + strconv.FormatInt(int64(e), 10) 227 } 228 229 // decode is like Decode but returns an additional 'end' value, which 230 // indicates if end-of-message padding was encountered and thus any 231 // additional data is an error. 232 func (enc *Encoding) decode(dst, src []byte) (n int, end bool, err error) { 233 osrc := src 234 for len(src) > 0 && !end { 235 // Decode quantum using the base32 alphabet 236 var dbuf [8]byte 237 dlen := 8 238 239 // do the top bytes contain any data? 240 dbufloop: 241 for j := 0; j < 8; { 242 if len(src) == 0 { 243 return n, false, CorruptInputError(len(osrc) - len(src) - j) 244 } 245 in := src[0] 246 src = src[1:] 247 if in == '\r' || in == '\n' { 248 // Ignore this character. 249 continue 250 } 251 if in == '=' && j >= 2 && len(src) < 8 { 252 // We've reached the end and there's 253 // padding, the rest should be padded 254 for k := 0; k < 8-j-1; k++ { 255 if len(src) > k && src[k] != '=' { 256 return n, false, CorruptInputError(len(osrc) - len(src) + k - 1) 257 } 258 } 259 dlen = j 260 end = true 261 break dbufloop 262 } 263 dbuf[j] = enc.decodeMap[in] 264 if dbuf[j] == 0xFF { 265 return n, false, CorruptInputError(len(osrc) - len(src) - 1) 266 } 267 j++ 268 } 269 270 // Pack 8x 5-bit source blocks into 5 byte destination 271 // quantum 272 switch dlen { 273 case 7, 8: 274 dst[4] = dbuf[6]<<5 | dbuf[7] 275 fallthrough 276 case 6, 5: 277 dst[3] = dbuf[4]<<7 | dbuf[5]<<2 | dbuf[6]>>3 278 fallthrough 279 case 4: 280 dst[2] = dbuf[3]<<4 | dbuf[4]>>1 281 fallthrough 282 case 3: 283 dst[1] = dbuf[1]<<6 | dbuf[2]<<1 | dbuf[3]>>4 284 fallthrough 285 case 2: 286 dst[0] = dbuf[0]<<3 | dbuf[1]>>2 287 } 288 dst = dst[5:] 289 switch dlen { 290 case 2: 291 n += 1 292 case 3, 4: 293 n += 2 294 case 5: 295 n += 3 296 case 6, 7: 297 n += 4 298 case 8: 299 n += 5 300 } 301 } 302 return n, end, nil 303 } 304 305 // Decode decodes src using the encoding enc. It writes at most 306 // DecodedLen(len(src)) bytes to dst and returns the number of bytes 307 // written. If src contains invalid base32 data, it will return the 308 // number of bytes successfully written and CorruptInputError. 309 // New line characters (\r and \n) are ignored. 310 func (enc *Encoding) Decode(dst, src []byte) (n int, err error) { 311 n, _, err = enc.decode(dst, src) 312 return 313 } 314 315 // DecodeString returns the bytes represented by the base32 string s. 316 func (enc *Encoding) DecodeString(s string) ([]byte, error) { 317 dbuf := make([]byte, enc.DecodedLen(len(s))) 318 n, err := enc.Decode(dbuf, []byte(s)) 319 return dbuf[:n], err 320 } 321 322 type decoder struct { 323 err error 324 enc *Encoding 325 r io.Reader 326 end bool // saw end of message 327 buf [1024]byte // leftover input 328 nbuf int 329 out []byte // leftover decoded output 330 outbuf [1024 / 8 * 5]byte 331 } 332 333 func (d *decoder) Read(p []byte) (n int, err error) { 334 if d.err != nil { 335 return 0, d.err 336 } 337 338 // Use leftover decoded output from last read. 339 if len(d.out) > 0 { 340 n = copy(p, d.out) 341 d.out = d.out[n:] 342 return n, nil 343 } 344 345 // Read a chunk. 346 nn := len(p) / 5 * 8 347 if nn < 8 { 348 nn = 8 349 } 350 if nn > len(d.buf) { 351 nn = len(d.buf) 352 } 353 nn, d.err = io.ReadAtLeast(d.r, d.buf[d.nbuf:nn], 8-d.nbuf) 354 d.nbuf += nn 355 if d.nbuf < 8 { 356 return 0, d.err 357 } 358 359 // Decode chunk into p, or d.out and then p if p is too small. 360 nr := d.nbuf / 8 * 8 361 nw := d.nbuf / 8 * 5 362 if nw > len(p) { 363 nw, d.end, d.err = d.enc.decode(d.outbuf[0:], d.buf[0:nr]) 364 d.out = d.outbuf[0:nw] 365 n = copy(p, d.out) 366 d.out = d.out[n:] 367 } else { 368 n, d.end, d.err = d.enc.decode(p, d.buf[0:nr]) 369 } 370 d.nbuf -= nr 371 for i := 0; i < d.nbuf; i++ { 372 d.buf[i] = d.buf[i+nr] 373 } 374 375 if d.err == nil { 376 d.err = err 377 } 378 return n, d.err 379 } 380 381 // NewDecoder constructs a new base32 stream decoder. 382 func NewDecoder(enc *Encoding, r io.Reader) io.Reader { 383 return &decoder{enc: enc, r: r} 384 } 385 386 // DecodedLen returns the maximum length in bytes of the decoded data 387 // corresponding to n bytes of base32-encoded data. 388 func (enc *Encoding) DecodedLen(n int) int { return n / 8 * 5 }