1
2
3
4
5
6 package base32
7
8 import (
9 "bytes"
10 "io"
11 "strconv"
12 "strings"
13 )
14
15
18
19
20
21
22
23 type Encoding struct {
24 encode string
25 decodeMap [256]byte
26 padChar rune
27 }
28
29 const (
30 StdPadding rune = '='
31 NoPadding rune = -1
32 )
33
34 const encodeStd = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"
35 const encodeHex = "0123456789ABCDEFGHIJKLMNOPQRSTUV"
36
37
38
39 func NewEncoding(encoder string) *Encoding {
40 e := new(Encoding)
41 e.encode = encoder
42 e.padChar = StdPadding
43
44 for i := 0; i < len(e.decodeMap); i++ {
45 e.decodeMap[i] = 0xFF
46 }
47 for i := 0; i < len(encoder); i++ {
48 e.decodeMap[encoder[i]] = byte(i)
49 }
50 return e
51 }
52
53
54
55 var StdEncoding = NewEncoding(encodeStd)
56
57
58
59 var HexEncoding = NewEncoding(encodeHex)
60
61 var removeNewlinesMapper = func(r rune) rune {
62 if r == '\r' || r == '\n' {
63 return -1
64 }
65 return r
66 }
67
68
69
70
71
72
73 func (enc Encoding) WithPadding(padding rune) *Encoding {
74 if padding == '\r' || padding == '\n' || padding > 0xff {
75 panic("invalid padding")
76 }
77
78 for i := 0; i < len(enc.encode); i++ {
79 if rune(enc.encode[i]) == padding {
80 panic("padding contained in alphabet")
81 }
82 }
83
84 enc.padChar = padding
85 return &enc
86 }
87
88
91
92
93
94
95
96
97
98 func (enc *Encoding) Encode(dst, src []byte) {
99 if len(src) == 0 {
100 return
101 }
102
103 for len(src) > 0 {
104 var b [8]byte
105
106
107
108 switch len(src) {
109 default:
110 b[7] = src[4] & 0x1F
111 b[6] = src[4] >> 5
112 fallthrough
113 case 4:
114 b[6] |= (src[3] << 3) & 0x1F
115 b[5] = (src[3] >> 2) & 0x1F
116 b[4] = src[3] >> 7
117 fallthrough
118 case 3:
119 b[4] |= (src[2] << 1) & 0x1F
120 b[3] = (src[2] >> 4) & 0x1F
121 fallthrough
122 case 2:
123 b[3] |= (src[1] << 4) & 0x1F
124 b[2] = (src[1] >> 1) & 0x1F
125 b[1] = (src[1] >> 6) & 0x1F
126 fallthrough
127 case 1:
128 b[1] |= (src[0] << 2) & 0x1F
129 b[0] = src[0] >> 3
130 }
131
132
133 size := len(dst)
134 if size >= 8 {
135
136 dst[0] = enc.encode[b[0]]
137 dst[1] = enc.encode[b[1]]
138 dst[2] = enc.encode[b[2]]
139 dst[3] = enc.encode[b[3]]
140 dst[4] = enc.encode[b[4]]
141 dst[5] = enc.encode[b[5]]
142 dst[6] = enc.encode[b[6]]
143 dst[7] = enc.encode[b[7]]
144 } else {
145 for i := 0; i < size; i++ {
146 dst[i] = enc.encode[b[i]]
147 }
148 }
149
150
151 if len(src) < 5 {
152 if enc.padChar == NoPadding {
153 break
154 }
155
156 dst[7] = byte(enc.padChar)
157 if len(src) < 4 {
158 dst[6] = byte(enc.padChar)
159 dst[5] = byte(enc.padChar)
160 if len(src) < 3 {
161 dst[4] = byte(enc.padChar)
162 if len(src) < 2 {
163 dst[3] = byte(enc.padChar)
164 dst[2] = byte(enc.padChar)
165 }
166 }
167 }
168
169 break
170 }
171
172 src = src[5:]
173 dst = dst[8:]
174 }
175 }
176
177
178 func (enc *Encoding) EncodeToString(src []byte) string {
179 buf := make([]byte, enc.EncodedLen(len(src)))
180 enc.Encode(buf, src)
181 return string(buf)
182 }
183
184 type encoder struct {
185 err error
186 enc *Encoding
187 w io.Writer
188 buf [5]byte
189 nbuf int
190 out [1024]byte
191 }
192
193 func (e *encoder) Write(p []byte) (n int, err error) {
194 if e.err != nil {
195 return 0, e.err
196 }
197
198
199 if e.nbuf > 0 {
200 var i int
201 for i = 0; i < len(p) && e.nbuf < 5; i++ {
202 e.buf[e.nbuf] = p[i]
203 e.nbuf++
204 }
205 n += i
206 p = p[i:]
207 if e.nbuf < 5 {
208 return
209 }
210 e.enc.Encode(e.out[0:], e.buf[0:])
211 if _, e.err = e.w.Write(e.out[0:8]); e.err != nil {
212 return n, e.err
213 }
214 e.nbuf = 0
215 }
216
217
218 for len(p) >= 5 {
219 nn := len(e.out) / 8 * 5
220 if nn > len(p) {
221 nn = len(p)
222 nn -= nn % 5
223 }
224 e.enc.Encode(e.out[0:], p[0:nn])
225 if _, e.err = e.w.Write(e.out[0 : nn/5*8]); e.err != nil {
226 return n, e.err
227 }
228 n += nn
229 p = p[nn:]
230 }
231
232
233 for i := 0; i < len(p); i++ {
234 e.buf[i] = p[i]
235 }
236 e.nbuf = len(p)
237 n += len(p)
238 return
239 }
240
241
242
243 func (e *encoder) Close() error {
244
245 if e.err == nil && e.nbuf > 0 {
246 e.enc.Encode(e.out[0:], e.buf[0:e.nbuf])
247 e.nbuf = 0
248 _, e.err = e.w.Write(e.out[0:8])
249 }
250 return e.err
251 }
252
253
254
255
256
257
258 func NewEncoder(enc *Encoding, w io.Writer) io.WriteCloser {
259 return &encoder{enc: enc, w: w}
260 }
261
262
263
264 func (enc *Encoding) EncodedLen(n int) int {
265 if enc.padChar == NoPadding {
266 return (n*8 + 4) / 5
267 }
268 return (n + 4) / 5 * 8
269 }
270
271
274
275 type CorruptInputError int64
276
277 func (e CorruptInputError) Error() string {
278 return "illegal base32 data at input byte " + strconv.FormatInt(int64(e), 10)
279 }
280
281
282
283
284
285 func (enc *Encoding) decode(dst, src []byte) (n int, end bool, err error) {
286 olen := len(src)
287 for len(src) > 0 && !end {
288
289 var dbuf [8]byte
290 dlen := 8
291
292 for j := 0; j < 8; {
293
294
295 if len(src) == 0 && enc.padChar != NoPadding {
296 return n, false, CorruptInputError(olen - len(src) - j)
297 }
298
299
300 if len(src) == 0 && enc.padChar == NoPadding {
301 dlen, end = j, true
302 break
303 }
304
305 in := src[0]
306 src = src[1:]
307 if in == byte(enc.padChar) && j >= 2 && len(src) < 8 {
308
309 if len(src)+j < 8-1 {
310
311 return n, false, CorruptInputError(olen)
312 }
313 for k := 0; k < 8-1-j; k++ {
314 if len(src) > k && src[k] != byte(enc.padChar) {
315
316 return n, false, CorruptInputError(olen - len(src) + k - 1)
317 }
318 }
319 dlen, end = j, true
320
321
322
323
324
325 if dlen == 1 || dlen == 3 || dlen == 6 {
326 return n, false, CorruptInputError(olen - len(src) - 1)
327 }
328 break
329 }
330 dbuf[j] = enc.decodeMap[in]
331 if dbuf[j] == 0xFF {
332 return n, false, CorruptInputError(olen - len(src) - 1)
333 }
334 j++
335 }
336
337
338
339 switch dlen {
340 case 8:
341 dst[4] = dbuf[6]<<5 | dbuf[7]
342 fallthrough
343 case 7:
344 dst[3] = dbuf[4]<<7 | dbuf[5]<<2 | dbuf[6]>>3
345 fallthrough
346 case 5:
347 dst[2] = dbuf[3]<<4 | dbuf[4]>>1
348 fallthrough
349 case 4:
350 dst[1] = dbuf[1]<<6 | dbuf[2]<<1 | dbuf[3]>>4
351 fallthrough
352 case 2:
353 dst[0] = dbuf[0]<<3 | dbuf[1]>>2
354 }
355
356 if !end {
357 dst = dst[5:]
358 }
359
360 switch dlen {
361 case 2:
362 n += 1
363 case 4:
364 n += 2
365 case 5:
366 n += 3
367 case 7:
368 n += 4
369 case 8:
370 n += 5
371 }
372 }
373 return n, end, nil
374 }
375
376
377
378
379
380
381 func (enc *Encoding) Decode(dst, src []byte) (n int, err error) {
382 src = bytes.Map(removeNewlinesMapper, src)
383 n, _, err = enc.decode(dst, src)
384 return
385 }
386
387
388 func (enc *Encoding) DecodeString(s string) ([]byte, error) {
389 s = strings.Map(removeNewlinesMapper, s)
390 dbuf := make([]byte, enc.DecodedLen(len(s)))
391 n, _, err := enc.decode(dbuf, []byte(s))
392 return dbuf[:n], err
393 }
394
395 type decoder struct {
396 err error
397 enc *Encoding
398 r io.Reader
399 end bool
400 buf [1024]byte
401 nbuf int
402 out []byte
403 outbuf [1024 / 8 * 5]byte
404 }
405
406 func readEncodedData(r io.Reader, buf []byte, min int) (n int, err error) {
407 for n < min && err == nil {
408 var nn int
409 nn, err = r.Read(buf[n:])
410 n += nn
411 }
412 if n < min && n > 0 && err == io.EOF {
413 err = io.ErrUnexpectedEOF
414 }
415 return
416 }
417
418 func (d *decoder) Read(p []byte) (n int, err error) {
419
420 if len(d.out) > 0 {
421 n = copy(p, d.out)
422 d.out = d.out[n:]
423 if len(d.out) == 0 {
424 return n, d.err
425 }
426 return n, nil
427 }
428
429 if d.err != nil {
430 return 0, d.err
431 }
432
433
434 nn := len(p) / 5 * 8
435 if nn < 8 {
436 nn = 8
437 }
438 if nn > len(d.buf) {
439 nn = len(d.buf)
440 }
441
442 nn, d.err = readEncodedData(d.r, d.buf[d.nbuf:nn], 8-d.nbuf)
443 d.nbuf += nn
444 if d.nbuf < 8 {
445 return 0, d.err
446 }
447
448
449 nr := d.nbuf / 8 * 8
450 nw := d.nbuf / 8 * 5
451 if nw > len(p) {
452 nw, d.end, err = d.enc.decode(d.outbuf[0:], d.buf[0:nr])
453 d.out = d.outbuf[0:nw]
454 n = copy(p, d.out)
455 d.out = d.out[n:]
456 } else {
457 n, d.end, err = d.enc.decode(p, d.buf[0:nr])
458 }
459 d.nbuf -= nr
460 for i := 0; i < d.nbuf; i++ {
461 d.buf[i] = d.buf[i+nr]
462 }
463
464 if err != nil && (d.err == nil || d.err == io.EOF) {
465 d.err = err
466 }
467
468 if len(d.out) > 0 {
469
470
471
472
473 return n, nil
474 }
475
476 return n, d.err
477 }
478
479 type newlineFilteringReader struct {
480 wrapped io.Reader
481 }
482
483 func (r *newlineFilteringReader) Read(p []byte) (int, error) {
484 n, err := r.wrapped.Read(p)
485 for n > 0 {
486 offset := 0
487 for i, b := range p[0:n] {
488 if b != '\r' && b != '\n' {
489 if i != offset {
490 p[offset] = b
491 }
492 offset++
493 }
494 }
495 if err != nil || offset > 0 {
496 return offset, err
497 }
498
499 n, err = r.wrapped.Read(p)
500 }
501 return n, err
502 }
503
504
505 func NewDecoder(enc *Encoding, r io.Reader) io.Reader {
506 return &decoder{enc: enc, r: &newlineFilteringReader{r}}
507 }
508
509
510
511 func (enc *Encoding) DecodedLen(n int) int {
512 if enc.padChar == NoPadding {
513 return n * 5 / 8
514 }
515
516 return n / 8 * 5
517 }
518
View as plain text