Skip to main content
Module

x/sheetjs/bits/44_offcrypto.js

πŸ“— SheetJS Community Edition -- Spreadsheet Data Toolkit
Extremely Popular
Latest
File
function _JS2ANSI(str/*:string*/)/*:Array<number>*/ { if(typeof cptable !== 'undefined') return cptable.utils.encode(current_ansi, str); var o/*:Array<number>*/ = [], oo = str.split(""); for(var i = 0; i < oo.length; ++i) o[i] = oo[i].charCodeAt(0); return o;}
/* [MS-OFFCRYPTO] 2.1.4 Version */function parse_CRYPTOVersion(blob, length/*:?number*/) { var o/*:any*/ = {}; o.Major = blob.read_shift(2); o.Minor = blob.read_shift(2); /*:: if(length == null) return o; */ if(length >= 4) blob.l += length - 4; return o;}
/* [MS-OFFCRYPTO] 2.1.5 DataSpaceVersionInfo */function parse_DataSpaceVersionInfo(blob) { var o = {}; o.id = blob.read_shift(0, 'lpp4'); o.R = parse_CRYPTOVersion(blob, 4); o.U = parse_CRYPTOVersion(blob, 4); o.W = parse_CRYPTOVersion(blob, 4); return o;}
/* [MS-OFFCRYPTO] 2.1.6.1 DataSpaceMapEntry Structure */function parse_DataSpaceMapEntry(blob) { var len = blob.read_shift(4); var end = blob.l + len - 4; var o = {}; var cnt = blob.read_shift(4); var comps/*:Array<{t:number, v:string}>*/ = []; /* [MS-OFFCRYPTO] 2.1.6.2 DataSpaceReferenceComponent Structure */ while(cnt-- > 0) comps.push({ t: blob.read_shift(4), v: blob.read_shift(0, 'lpp4') }); o.name = blob.read_shift(0, 'lpp4'); o.comps = comps; if(blob.l != end) throw new Error("Bad DataSpaceMapEntry: " + blob.l + " != " + end); return o;}
/* [MS-OFFCRYPTO] 2.1.6 DataSpaceMap */function parse_DataSpaceMap(blob) { var o = []; blob.l += 4; // must be 0x8 var cnt = blob.read_shift(4); while(cnt-- > 0) o.push(parse_DataSpaceMapEntry(blob)); return o;}
/* [MS-OFFCRYPTO] 2.1.7 DataSpaceDefinition */function parse_DataSpaceDefinition(blob)/*:Array<string>*/ { var o/*:Array<string>*/ = []; blob.l += 4; // must be 0x8 var cnt = blob.read_shift(4); while(cnt-- > 0) o.push(blob.read_shift(0, 'lpp4')); return o;}
/* [MS-OFFCRYPTO] 2.1.8 DataSpaceDefinition */function parse_TransformInfoHeader(blob) { var o = {}; /*var len = */blob.read_shift(4); blob.l += 4; // must be 0x1 o.id = blob.read_shift(0, 'lpp4'); o.name = blob.read_shift(0, 'lpp4'); o.R = parse_CRYPTOVersion(blob, 4); o.U = parse_CRYPTOVersion(blob, 4); o.W = parse_CRYPTOVersion(blob, 4); return o;}
function parse_Primary(blob) { /* [MS-OFFCRYPTO] 2.2.6 IRMDSTransformInfo */ var hdr = parse_TransformInfoHeader(blob); /* [MS-OFFCRYPTO] 2.1.9 EncryptionTransformInfo */ hdr.ename = blob.read_shift(0, '8lpp4'); hdr.blksz = blob.read_shift(4); hdr.cmode = blob.read_shift(4); if(blob.read_shift(4) != 0x04) throw new Error("Bad !Primary record"); return hdr;}
/* [MS-OFFCRYPTO] 2.3.2 Encryption Header */function parse_EncryptionHeader(blob, length/*:number*/) { var tgt = blob.l + length; var o = {}; o.Flags = (blob.read_shift(4) & 0x3F); blob.l += 4; o.AlgID = blob.read_shift(4); var valid = false; switch(o.AlgID) { case 0x660E: case 0x660F: case 0x6610: valid = (o.Flags == 0x24); break; case 0x6801: valid = (o.Flags == 0x04); break; case 0: valid = (o.Flags == 0x10 || o.Flags == 0x04 || o.Flags == 0x24); break; default: throw 'Unrecognized encryption algorithm: ' + o.AlgID; } if(!valid) throw new Error("Encryption Flags/AlgID mismatch"); o.AlgIDHash = blob.read_shift(4); o.KeySize = blob.read_shift(4); o.ProviderType = blob.read_shift(4); blob.l += 8; o.CSPName = blob.read_shift((tgt-blob.l)>>1, 'utf16le'); blob.l = tgt; return o;}
/* [MS-OFFCRYPTO] 2.3.3 Encryption Verifier */function parse_EncryptionVerifier(blob, length/*:number*/) { var o = {}, tgt = blob.l + length; blob.l += 4; // SaltSize must be 0x10 o.Salt = blob.slice(blob.l, blob.l+16); blob.l += 16; o.Verifier = blob.slice(blob.l, blob.l+16); blob.l += 16; /*var sz = */blob.read_shift(4); o.VerifierHash = blob.slice(blob.l, tgt); blob.l = tgt; return o;}
/* [MS-OFFCRYPTO] 2.3.4.* EncryptionInfo Stream */function parse_EncryptionInfo(blob) { var vers = parse_CRYPTOVersion(blob); switch(vers.Minor) { case 0x02: return [vers.Minor, parse_EncInfoStd(blob, vers)]; case 0x03: return [vers.Minor, parse_EncInfoExt(blob, vers)]; case 0x04: return [vers.Minor, parse_EncInfoAgl(blob, vers)]; } throw new Error("ECMA-376 Encrypted file unrecognized Version: " + vers.Minor);}
/* [MS-OFFCRYPTO] 2.3.4.5 EncryptionInfo Stream (Standard Encryption) */function parse_EncInfoStd(blob/*::, vers*/) { var flags = blob.read_shift(4); if((flags & 0x3F) != 0x24) throw new Error("EncryptionInfo mismatch"); var sz = blob.read_shift(4); //var tgt = blob.l + sz; var hdr = parse_EncryptionHeader(blob, sz); var verifier = parse_EncryptionVerifier(blob, blob.length - blob.l); return { t:"Std", h:hdr, v:verifier };}/* [MS-OFFCRYPTO] 2.3.4.6 EncryptionInfo Stream (Extensible Encryption) */function parse_EncInfoExt(/*::blob, vers*/) { throw new Error("File is password-protected: ECMA-376 Extensible"); }/* [MS-OFFCRYPTO] 2.3.4.10 EncryptionInfo Stream (Agile Encryption) */function parse_EncInfoAgl(blob/*::, vers*/) { var KeyData = ["saltSize","blockSize","keyBits","hashSize","cipherAlgorithm","cipherChaining","hashAlgorithm","saltValue"]; blob.l+=4; var xml = blob.read_shift(blob.length - blob.l, 'utf8'); var o = {}; xml.replace(tagregex, function xml_agile(x) { var y/*:any*/ = parsexmltag(x); switch(strip_ns(y[0])) { case '<?xml': break; case '<encryption': case '</encryption>': break; case '<keyData': KeyData.forEach(function(k) { o[k] = y[k]; }); break; case '<dataIntegrity': o.encryptedHmacKey = y.encryptedHmacKey; o.encryptedHmacValue = y.encryptedHmacValue; break; case '<keyEncryptors>': case '<keyEncryptors': o.encs = []; break; case '</keyEncryptors>': break;
case '<keyEncryptor': o.uri = y.uri; break; case '</keyEncryptor>': break; case '<encryptedKey': o.encs.push(y); break; default: throw y[0]; } }); return o;}
/* [MS-OFFCRYPTO] 2.3.5.1 RC4 CryptoAPI Encryption Header */function parse_RC4CryptoHeader(blob, length/*:number*/) { var o = {}; var vers = o.EncryptionVersionInfo = parse_CRYPTOVersion(blob, 4); length -= 4; if(vers.Minor != 2) throw new Error('unrecognized minor version code: ' + vers.Minor); if(vers.Major > 4 || vers.Major < 2) throw new Error('unrecognized major version code: ' + vers.Major); o.Flags = blob.read_shift(4); length -= 4; var sz = blob.read_shift(4); length -= 4; o.EncryptionHeader = parse_EncryptionHeader(blob, sz); length -= sz; o.EncryptionVerifier = parse_EncryptionVerifier(blob, length); return o;}/* [MS-OFFCRYPTO] 2.3.6.1 RC4 Encryption Header */function parse_RC4Header(blob/*::, length*/) { var o = {}; var vers = o.EncryptionVersionInfo = parse_CRYPTOVersion(blob, 4); if(vers.Major != 1 || vers.Minor != 1) throw 'unrecognized version code ' + vers.Major + ' : ' + vers.Minor; o.Salt = blob.read_shift(16); o.EncryptedVerifier = blob.read_shift(16); o.EncryptedVerifierHash = blob.read_shift(16); return o;}
/* [MS-OFFCRYPTO] 2.3.7.1 Binary Document Password Verifier Derivation */function crypto_CreatePasswordVerifier_Method1(Password/*:string*/) { var Verifier = 0x0000, PasswordArray; var PasswordDecoded = _JS2ANSI(Password); var len = PasswordDecoded.length + 1, i, PasswordByte; var Intermediate1, Intermediate2, Intermediate3; PasswordArray = new_raw_buf(len); PasswordArray[0] = PasswordDecoded.length; for(i = 1; i != len; ++i) PasswordArray[i] = PasswordDecoded[i-1]; for(i = len-1; i >= 0; --i) { PasswordByte = PasswordArray[i]; Intermediate1 = ((Verifier & 0x4000) === 0x0000) ? 0 : 1; Intermediate2 = (Verifier << 1) & 0x7FFF; Intermediate3 = Intermediate1 | Intermediate2; Verifier = Intermediate3 ^ PasswordByte; } return Verifier ^ 0xCE4B;}
/* [MS-OFFCRYPTO] 2.3.7.2 Binary Document XOR Array Initialization */var crypto_CreateXorArray_Method1 = (function() { var PadArray = [0xBB, 0xFF, 0xFF, 0xBA, 0xFF, 0xFF, 0xB9, 0x80, 0x00, 0xBE, 0x0F, 0x00, 0xBF, 0x0F, 0x00]; var InitialCode = [0xE1F0, 0x1D0F, 0xCC9C, 0x84C0, 0x110C, 0x0E10, 0xF1CE, 0x313E, 0x1872, 0xE139, 0xD40F, 0x84F9, 0x280C, 0xA96A, 0x4EC3]; var XorMatrix = [0xAEFC, 0x4DD9, 0x9BB2, 0x2745, 0x4E8A, 0x9D14, 0x2A09, 0x7B61, 0xF6C2, 0xFDA5, 0xEB6B, 0xC6F7, 0x9DCF, 0x2BBF, 0x4563, 0x8AC6, 0x05AD, 0x0B5A, 0x16B4, 0x2D68, 0x5AD0, 0x0375, 0x06EA, 0x0DD4, 0x1BA8, 0x3750, 0x6EA0, 0xDD40, 0xD849, 0xA0B3, 0x5147, 0xA28E, 0x553D, 0xAA7A, 0x44D5, 0x6F45, 0xDE8A, 0xAD35, 0x4A4B, 0x9496, 0x390D, 0x721A, 0xEB23, 0xC667, 0x9CEF, 0x29FF, 0x53FE, 0xA7FC, 0x5FD9, 0x47D3, 0x8FA6, 0x0F6D, 0x1EDA, 0x3DB4, 0x7B68, 0xF6D0, 0xB861, 0x60E3, 0xC1C6, 0x93AD, 0x377B, 0x6EF6, 0xDDEC, 0x45A0, 0x8B40, 0x06A1, 0x0D42, 0x1A84, 0x3508, 0x6A10, 0xAA51, 0x4483, 0x8906, 0x022D, 0x045A, 0x08B4, 0x1168, 0x76B4, 0xED68, 0xCAF1, 0x85C3, 0x1BA7, 0x374E, 0x6E9C, 0x3730, 0x6E60, 0xDCC0, 0xA9A1, 0x4363, 0x86C6, 0x1DAD, 0x3331, 0x6662, 0xCCC4, 0x89A9, 0x0373, 0x06E6, 0x0DCC, 0x1021, 0x2042, 0x4084, 0x8108, 0x1231, 0x2462, 0x48C4]; var Ror = function(Byte) { return ((Byte/2) | (Byte*128)) & 0xFF; }; var XorRor = function(byte1, byte2) { return Ror(byte1 ^ byte2); }; var CreateXorKey_Method1 = function(Password) { var XorKey = InitialCode[Password.length - 1]; var CurrentElement = 0x68; for(var i = Password.length-1; i >= 0; --i) { var Char = Password[i]; for(var j = 0; j != 7; ++j) { if(Char & 0x40) XorKey ^= XorMatrix[CurrentElement]; Char *= 2; --CurrentElement; } } return XorKey; }; return function(password/*:string*/) { var Password = _JS2ANSI(password); var XorKey = CreateXorKey_Method1(Password); var Index = Password.length; var ObfuscationArray = new_raw_buf(16); for(var i = 0; i != 16; ++i) ObfuscationArray[i] = 0x00; var Temp, PasswordLastChar, PadIndex; if((Index & 1) === 1) { Temp = XorKey >> 8; ObfuscationArray[Index] = XorRor(PadArray[0], Temp); --Index; Temp = XorKey & 0xFF; PasswordLastChar = Password[Password.length - 1]; ObfuscationArray[Index] = XorRor(PasswordLastChar, Temp); } while(Index > 0) { --Index; Temp = XorKey >> 8; ObfuscationArray[Index] = XorRor(Password[Index], Temp); --Index; Temp = XorKey & 0xFF; ObfuscationArray[Index] = XorRor(Password[Index], Temp); } Index = 15; PadIndex = 15 - Password.length; while(PadIndex > 0) { Temp = XorKey >> 8; ObfuscationArray[Index] = XorRor(PadArray[PadIndex], Temp); --Index; --PadIndex; Temp = XorKey & 0xFF; ObfuscationArray[Index] = XorRor(Password[Index], Temp); --Index; --PadIndex; } return ObfuscationArray; };})();
/* [MS-OFFCRYPTO] 2.3.7.3 Binary Document XOR Data Transformation Method 1 */var crypto_DecryptData_Method1 = function(password/*:string*/, Data, XorArrayIndex, XorArray, O) { /* If XorArray is set, use it; if O is not set, make changes in-place */ if(!O) O = Data; if(!XorArray) XorArray = crypto_CreateXorArray_Method1(password); var Index, Value; for(Index = 0; Index != Data.length; ++Index) { Value = Data[Index]; Value ^= XorArray[XorArrayIndex]; Value = ((Value>>5) | (Value<<3)) & 0xFF; O[Index] = Value; ++XorArrayIndex; } return [O, XorArrayIndex, XorArray];};
var crypto_MakeXorDecryptor = function(password/*:string*/) { var XorArrayIndex = 0, XorArray = crypto_CreateXorArray_Method1(password); return function(Data) { var O = crypto_DecryptData_Method1("", Data, XorArrayIndex, XorArray); XorArrayIndex = O[1]; return O[0]; };};
/* 2.5.343 */function parse_XORObfuscation(blob, length, opts, out) { var o = ({ key: parseuint16(blob), verificationBytes: parseuint16(blob) }/*:any*/); if(opts.password) o.verifier = crypto_CreatePasswordVerifier_Method1(opts.password); out.valid = o.verificationBytes === o.verifier; if(out.valid) out.insitu = crypto_MakeXorDecryptor(opts.password); return o;}
/* 2.4.117 */function parse_FilePassHeader(blob, length/*:number*/, oo) { var o = oo || {}; o.Info = blob.read_shift(2); blob.l -= 2; if(o.Info === 1) o.Data = parse_RC4Header(blob, length); else o.Data = parse_RC4CryptoHeader(blob, length); return o;}function parse_FilePass(blob, length/*:number*/, opts) { var o = ({ Type: opts.biff >= 8 ? blob.read_shift(2) : 0 }/*:any*/); /* wEncryptionType */ if(o.Type) parse_FilePassHeader(blob, length-2, o); else parse_XORObfuscation(blob, opts.biff >= 8 ? length : length - 2, opts, o); return o;}