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 | var forge = require('./forge');
|
30 | require('./util');
|
31 |
|
32 |
|
33 | var pem = module.exports = forge.pem = forge.pem || {};
|
34 |
|
35 |
|
36 |
|
37 |
|
38 |
|
39 |
|
40 |
|
41 |
|
42 |
|
43 |
|
44 | pem.encode = function(msg, options) {
|
45 | options = options || {};
|
46 | var rval = '-----BEGIN ' + msg.type + '-----\r\n';
|
47 |
|
48 |
|
49 | var header;
|
50 | if(msg.procType) {
|
51 | header = {
|
52 | name: 'Proc-Type',
|
53 | values: [String(msg.procType.version), msg.procType.type]
|
54 | };
|
55 | rval += foldHeader(header);
|
56 | }
|
57 | if(msg.contentDomain) {
|
58 | header = {name: 'Content-Domain', values: [msg.contentDomain]};
|
59 | rval += foldHeader(header);
|
60 | }
|
61 | if(msg.dekInfo) {
|
62 | header = {name: 'DEK-Info', values: [msg.dekInfo.algorithm]};
|
63 | if(msg.dekInfo.parameters) {
|
64 | header.values.push(msg.dekInfo.parameters);
|
65 | }
|
66 | rval += foldHeader(header);
|
67 | }
|
68 |
|
69 | if(msg.headers) {
|
70 |
|
71 | for(var i = 0; i < msg.headers.length; ++i) {
|
72 | rval += foldHeader(msg.headers[i]);
|
73 | }
|
74 | }
|
75 |
|
76 |
|
77 | if(msg.procType) {
|
78 | rval += '\r\n';
|
79 | }
|
80 |
|
81 |
|
82 | rval += forge.util.encode64(msg.body, options.maxline || 64) + '\r\n';
|
83 |
|
84 | rval += '-----END ' + msg.type + '-----\r\n';
|
85 | return rval;
|
86 | };
|
87 |
|
88 |
|
89 |
|
90 |
|
91 |
|
92 |
|
93 |
|
94 |
|
95 | pem.decode = function(str) {
|
96 | var rval = [];
|
97 |
|
98 |
|
99 | var rMessage = /\s*-----BEGIN ([A-Z0-9- ]+)-----\r?\n?([\x21-\x7e\s]+?(?:\r?\n\r?\n))?([:A-Za-z0-9+\/=\s]+?)-----END \1-----/g;
|
100 | var rHeader = /([\x21-\x7e]+):\s*([\x21-\x7e\s^:]+)/;
|
101 | var rCRLF = /\r?\n/;
|
102 | var match;
|
103 | while(true) {
|
104 | match = rMessage.exec(str);
|
105 | if(!match) {
|
106 | break;
|
107 | }
|
108 |
|
109 | var msg = {
|
110 | type: match[1],
|
111 | procType: null,
|
112 | contentDomain: null,
|
113 | dekInfo: null,
|
114 | headers: [],
|
115 | body: forge.util.decode64(match[3])
|
116 | };
|
117 | rval.push(msg);
|
118 |
|
119 |
|
120 | if(!match[2]) {
|
121 | continue;
|
122 | }
|
123 |
|
124 |
|
125 | var lines = match[2].split(rCRLF);
|
126 | var li = 0;
|
127 | while(match && li < lines.length) {
|
128 |
|
129 | var line = lines[li].replace(/\s+$/, '');
|
130 |
|
131 |
|
132 | for(var nl = li + 1; nl < lines.length; ++nl) {
|
133 | var next = lines[nl];
|
134 | if(!/\s/.test(next[0])) {
|
135 | break;
|
136 | }
|
137 | line += next;
|
138 | li = nl;
|
139 | }
|
140 |
|
141 |
|
142 | match = line.match(rHeader);
|
143 | if(match) {
|
144 | var header = {name: match[1], values: []};
|
145 | var values = match[2].split(',');
|
146 | for(var vi = 0; vi < values.length; ++vi) {
|
147 | header.values.push(ltrim(values[vi]));
|
148 | }
|
149 |
|
150 |
|
151 | if(!msg.procType) {
|
152 | if(header.name !== 'Proc-Type') {
|
153 | throw new Error('Invalid PEM formatted message. The first ' +
|
154 | 'encapsulated header must be "Proc-Type".');
|
155 | } else if(header.values.length !== 2) {
|
156 | throw new Error('Invalid PEM formatted message. The "Proc-Type" ' +
|
157 | 'header must have two subfields.');
|
158 | }
|
159 | msg.procType = {version: values[0], type: values[1]};
|
160 | } else if(!msg.contentDomain && header.name === 'Content-Domain') {
|
161 |
|
162 | msg.contentDomain = values[0] || '';
|
163 | } else if(!msg.dekInfo && header.name === 'DEK-Info') {
|
164 |
|
165 | if(header.values.length === 0) {
|
166 | throw new Error('Invalid PEM formatted message. The "DEK-Info" ' +
|
167 | 'header must have at least one subfield.');
|
168 | }
|
169 | msg.dekInfo = {algorithm: values[0], parameters: values[1] || null};
|
170 | } else {
|
171 | msg.headers.push(header);
|
172 | }
|
173 | }
|
174 |
|
175 | ++li;
|
176 | }
|
177 |
|
178 | if(msg.procType === 'ENCRYPTED' && !msg.dekInfo) {
|
179 | throw new Error('Invalid PEM formatted message. The "DEK-Info" ' +
|
180 | 'header must be present if "Proc-Type" is "ENCRYPTED".');
|
181 | }
|
182 | }
|
183 |
|
184 | if(rval.length === 0) {
|
185 | throw new Error('Invalid PEM formatted message.');
|
186 | }
|
187 |
|
188 | return rval;
|
189 | };
|
190 |
|
191 | function foldHeader(header) {
|
192 | var rval = header.name + ': ';
|
193 |
|
194 |
|
195 | var values = [];
|
196 | var insertSpace = function(match, $1) {
|
197 | return ' ' + $1;
|
198 | };
|
199 | for(var i = 0; i < header.values.length; ++i) {
|
200 | values.push(header.values[i].replace(/^(\S+\r\n)/, insertSpace));
|
201 | }
|
202 | rval += values.join(',') + '\r\n';
|
203 |
|
204 |
|
205 | var length = 0;
|
206 | var candidate = -1;
|
207 | for(var i = 0; i < rval.length; ++i, ++length) {
|
208 | if(length > 65 && candidate !== -1) {
|
209 | var insert = rval[candidate];
|
210 | if(insert === ',') {
|
211 | ++candidate;
|
212 | rval = rval.substr(0, candidate) + '\r\n ' + rval.substr(candidate);
|
213 | } else {
|
214 | rval = rval.substr(0, candidate) +
|
215 | '\r\n' + insert + rval.substr(candidate + 1);
|
216 | }
|
217 | length = (i - candidate - 1);
|
218 | candidate = -1;
|
219 | ++i;
|
220 | } else if(rval[i] === ' ' || rval[i] === '\t' || rval[i] === ',') {
|
221 | candidate = i;
|
222 | }
|
223 | }
|
224 |
|
225 | return rval;
|
226 | }
|
227 |
|
228 | function ltrim(str) {
|
229 | return str.replace(/^\s+/, '');
|
230 | }
|