1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
/*
* This software is licensed under the terms of the GNU General Public
* License version 2, as published by the Free Software Foundation, and
* may be copied, distributed, and modified under those terms.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <b64_decode.h>
#include <console/console.h>
/*
* Translation Table to decode base64 ASCII stream into binary. Borrowed from
*
* http://base64.sourceforge.net/b64.c.
*
*/
static const char cd64[] = "|$$$}rstuvwxyz{$$$$$$$>?@ABCDEFGHIJKLMN"
"OPQRSTUVW$$$$$$XYZ[\\]^_`abcdefghijklmnopq";
struct buffer_descriptor {
const uint8_t *input_buffer;
size_t data_size;
size_t input_index;
};
#define isalnum(c) ((((c) >= 'a') && ((c) <= 'z')) || \
(((c) >= 'A') && ((c) <= 'Z')) || \
(((c) >= '0') && ((c) <= '9')))
/*
* On each invocation this function returns the next valid base64 character
* from the encoded message, ignoring padding and line breaks.
*
* Once all input is consumed, 0 is returned on all following invocations. In
* case any other than expected characters is found in the encoded message, -1
* is returned for error.
*/
static int get_next_char(struct buffer_descriptor *bd)
{
uint8_t c;
/*
* The canonical base64 encoded messages include the following
* characters:
* - '0..9A..Za..z+/' to represent 64 values
* - '=' for padding
* - '<CR><LF>' to split the message into lines.
*/
while (bd->input_index < bd->data_size) {
c = bd->input_buffer[bd->input_index++];
switch (c) {
case '=':
case 0xa:
case 0xd:
continue;
default:
break;
}
if (!isalnum(c) && (c != '+') && (c != '/'))
return -1;
return c;
}
return 0;
}
/*
** decode
**
** decode a base64 encoded stream discarding padding and line breaks.
*/
size_t b64_decode(const uint8_t *input_data,
size_t input_length,
uint8_t *output_data)
{
struct buffer_descriptor bd;
unsigned int interim = 0;
size_t output_size = 0;
/* count of processed input bits, modulo log2(64) */
unsigned int bit_count = 0;
/*
* Keep the context on the stack to make things easier if this needs
* to run with CAR.
*/
bd.input_buffer = input_data;
bd.data_size = input_length;
bd.input_index = 0;
while (1) { /* Until input is exhausted. */
int v = get_next_char(&bd);
if (v < 0) {
printk(BIOS_ERR,
"Incompatible character at offset %zd.\n",
bd.input_index);
return 0;
}
if (!v)
break;
/*
* v is guaranteed to be in the proper range for cd64, the
* result is a 6 bit number.
*/
v = cd64[v - 43] - 62;
if (bit_count >= 2) {
/*
* Once 6 more bits are added to the output, there is
* going to be at least a full byte.
*
* 'remaining_bits' is the exact number of bits which
* need to be added to the output to have another full
* byte ready.
*/
int remaining_bits = 8 - bit_count;
interim <<= remaining_bits;
interim |= v >> (6 - remaining_bits);
/* Pass the new full byte to the output. */
output_data[output_size++] = interim & 0xff;
interim = v;
bit_count -= 2;
} else {
interim <<= 6;
interim |= v;
bit_count += 6;
}
}
return output_size;
}
|
