| /** |
| * Javascript implementation of basic PEM (Privacy Enhanced Mail) algorithms. |
| * |
| * See: RFC 1421. |
| * |
| * @author Dave Longley |
| * |
| * Copyright (c) 2013-2014 Digital Bazaar, Inc. |
| * |
| * A Forge PEM object has the following fields: |
| * |
| * type: identifies the type of message (eg: "RSA PRIVATE KEY"). |
| * |
| * procType: identifies the type of processing performed on the message, |
| * it has two subfields: version and type, eg: 4,ENCRYPTED. |
| * |
| * contentDomain: identifies the type of content in the message, typically |
| * only uses the value: "RFC822". |
| * |
| * dekInfo: identifies the message encryption algorithm and mode and includes |
| * any parameters for the algorithm, it has two subfields: algorithm and |
| * parameters, eg: DES-CBC,F8143EDE5960C597. |
| * |
| * headers: contains all other PEM encapsulated headers -- where order is |
| * significant (for pairing data like recipient ID + key info). |
| * |
| * body: the binary-encoded body. |
| */ |
| (function() { |
| /* ########## Begin module implementation ########## */ |
| function initModule(forge) { |
| |
| // shortcut for pem API |
| var pem = forge.pem = forge.pem || {}; |
| |
| /** |
| * Encodes (serializes) the given PEM object. |
| * |
| * @param msg the PEM message object to encode. |
| * @param options the options to use: |
| * maxline the maximum characters per line for the body, (default: 64). |
| * |
| * @return the PEM-formatted string. |
| */ |
| pem.encode = function(msg, options) { |
| options = options || {}; |
| var rval = '-----BEGIN ' + msg.type + '-----\r\n'; |
| |
| // encode special headers |
| var header; |
| if(msg.procType) { |
| header = { |
| name: 'Proc-Type', |
| values: [String(msg.procType.version), msg.procType.type] |
| }; |
| rval += foldHeader(header); |
| } |
| if(msg.contentDomain) { |
| header = {name: 'Content-Domain', values: [msg.contentDomain]}; |
| rval += foldHeader(header); |
| } |
| if(msg.dekInfo) { |
| header = {name: 'DEK-Info', values: [msg.dekInfo.algorithm]}; |
| if(msg.dekInfo.parameters) { |
| header.values.push(msg.dekInfo.parameters); |
| } |
| rval += foldHeader(header); |
| } |
| |
| if(msg.headers) { |
| // encode all other headers |
| for(var i = 0; i < msg.headers.length; ++i) { |
| rval += foldHeader(msg.headers[i]); |
| } |
| } |
| |
| // terminate header |
| if(msg.procType) { |
| rval += '\r\n'; |
| } |
| |
| // add body |
| rval += forge.util.encode64(msg.body, options.maxline || 64) + '\r\n'; |
| |
| rval += '-----END ' + msg.type + '-----\r\n'; |
| return rval; |
| }; |
| |
| /** |
| * Decodes (deserializes) all PEM messages found in the given string. |
| * |
| * @param str the PEM-formatted string to decode. |
| * |
| * @return the PEM message objects in an array. |
| */ |
| pem.decode = function(str) { |
| var rval = []; |
| |
| // split string into PEM messages (be lenient w/EOF on BEGIN line) |
| var rMessage = /\s*-----BEGIN ([A-Z0-9- ]+)-----\r?\n?([\x21-\x7e\s]+?(?:\r?\n\r?\n))?([:A-Za-z0-9+\/=\s]+?)-----END \1-----/g; |
| var rHeader = /([\x21-\x7e]+):\s*([\x21-\x7e\s^:]+)/; |
| var rCRLF = /\r?\n/; |
| var match; |
| while(true) { |
| match = rMessage.exec(str); |
| if(!match) { |
| break; |
| } |
| |
| var msg = { |
| type: match[1], |
| procType: null, |
| contentDomain: null, |
| dekInfo: null, |
| headers: [], |
| body: forge.util.decode64(match[3]) |
| }; |
| rval.push(msg); |
| |
| // no headers |
| if(!match[2]) { |
| continue; |
| } |
| |
| // parse headers |
| var lines = match[2].split(rCRLF); |
| var li = 0; |
| while(match && li < lines.length) { |
| // get line, trim any rhs whitespace |
| var line = lines[li].replace(/\s+$/, ''); |
| |
| // RFC2822 unfold any following folded lines |
| for(var nl = li + 1; nl < lines.length; ++nl) { |
| var next = lines[nl]; |
| if(!/\s/.test(next[0])) { |
| break; |
| } |
| line += next; |
| li = nl; |
| } |
| |
| // parse header |
| match = line.match(rHeader); |
| if(match) { |
| var header = {name: match[1], values: []}; |
| var values = match[2].split(','); |
| for(var vi = 0; vi < values.length; ++vi) { |
| header.values.push(ltrim(values[vi])); |
| } |
| |
| // Proc-Type must be the first header |
| if(!msg.procType) { |
| if(header.name !== 'Proc-Type') { |
| throw new Error('Invalid PEM formatted message. The first ' + |
| 'encapsulated header must be "Proc-Type".'); |
| } else if(header.values.length !== 2) { |
| throw new Error('Invalid PEM formatted message. The "Proc-Type" ' + |
| 'header must have two subfields.'); |
| } |
| msg.procType = {version: values[0], type: values[1]}; |
| } else if(!msg.contentDomain && header.name === 'Content-Domain') { |
| // special-case Content-Domain |
| msg.contentDomain = values[0] || ''; |
| } else if(!msg.dekInfo && header.name === 'DEK-Info') { |
| // special-case DEK-Info |
| if(header.values.length === 0) { |
| throw new Error('Invalid PEM formatted message. The "DEK-Info" ' + |
| 'header must have at least one subfield.'); |
| } |
| msg.dekInfo = {algorithm: values[0], parameters: values[1] || null}; |
| } else { |
| msg.headers.push(header); |
| } |
| } |
| |
| ++li; |
| } |
| |
| if(msg.procType === 'ENCRYPTED' && !msg.dekInfo) { |
| throw new Error('Invalid PEM formatted message. The "DEK-Info" ' + |
| 'header must be present if "Proc-Type" is "ENCRYPTED".'); |
| } |
| } |
| |
| if(rval.length === 0) { |
| throw new Error('Invalid PEM formatted message.'); |
| } |
| |
| return rval; |
| }; |
| |
| function foldHeader(header) { |
| var rval = header.name + ': '; |
| |
| // ensure values with CRLF are folded |
| var values = []; |
| var insertSpace = function(match, $1) { |
| return ' ' + $1; |
| }; |
| for(var i = 0; i < header.values.length; ++i) { |
| values.push(header.values[i].replace(/^(\S+\r\n)/, insertSpace)); |
| } |
| rval += values.join(',') + '\r\n'; |
| |
| // do folding |
| var length = 0; |
| var candidate = -1; |
| for(var i = 0; i < rval.length; ++i, ++length) { |
| if(length > 65 && candidate !== -1) { |
| var insert = rval[candidate]; |
| if(insert === ',') { |
| ++candidate; |
| rval = rval.substr(0, candidate) + '\r\n ' + rval.substr(candidate); |
| } else { |
| rval = rval.substr(0, candidate) + |
| '\r\n' + insert + rval.substr(candidate + 1); |
| } |
| length = (i - candidate - 1); |
| candidate = -1; |
| ++i; |
| } else if(rval[i] === ' ' || rval[i] === '\t' || rval[i] === ',') { |
| candidate = i; |
| } |
| } |
| |
| return rval; |
| } |
| |
| function ltrim(str) { |
| return str.replace(/^\s+/, ''); |
| } |
| |
| } // end module implementation |
| |
| /* ########## Begin module wrapper ########## */ |
| var name = 'pem'; |
| if(typeof define !== 'function') { |
| // NodeJS -> AMD |
| if(typeof module === 'object' && module.exports) { |
| var nodeJS = true; |
| define = function(ids, factory) { |
| factory(require, module); |
| }; |
| } else { |
| // <script> |
| if(typeof forge === 'undefined') { |
| forge = {}; |
| } |
| return initModule(forge); |
| } |
| } |
| // AMD |
| var deps; |
| var defineFunc = function(require, module) { |
| module.exports = function(forge) { |
| var mods = deps.map(function(dep) { |
| return require(dep); |
| }).concat(initModule); |
| // handle circular dependencies |
| forge = forge || {}; |
| forge.defined = forge.defined || {}; |
| if(forge.defined[name]) { |
| return forge[name]; |
| } |
| forge.defined[name] = true; |
| for(var i = 0; i < mods.length; ++i) { |
| mods[i](forge); |
| } |
| return forge[name]; |
| }; |
| }; |
| var tmpDefine = define; |
| define = function(ids, factory) { |
| deps = (typeof ids === 'string') ? factory.slice(2) : ids.slice(2); |
| if(nodeJS) { |
| delete define; |
| return tmpDefine.apply(null, Array.prototype.slice.call(arguments, 0)); |
| } |
| define = tmpDefine; |
| return define.apply(null, Array.prototype.slice.call(arguments, 0)); |
| }; |
| define(['require', 'module', './util'], function() { |
| defineFunc.apply(null, Array.prototype.slice.call(arguments, 0)); |
| }); |
| })(); |