// Copyright 2016 - 2022 The excelize Authors. All rights reserved. Use of // this source code is governed by a BSD-style license that can be found in // the LICENSE file. // // Package excelize providing a set of functions that allow you to write to and // read from XLAM / XLSM / XLSX / XLTM / XLTX files. Supports reading and // writing spreadsheet documents generated by Microsoft Excel™ 2007 and later. // Supports complex components by high compatibility, and provided streaming // API for generating or reading data from a worksheet with huge amounts of // data. This library needs Go version 1.15 or later. package excelize import ( "bytes" "crypto/aes" "crypto/cipher" "crypto/md5" "crypto/rand" "crypto/sha1" "crypto/sha256" "crypto/sha512" "encoding/base64" "encoding/binary" "encoding/xml" "hash" "math" "reflect" "strings" "github.com/richardlehane/mscfb" "golang.org/x/crypto/md4" "golang.org/x/crypto/ripemd160" "golang.org/x/text/encoding/unicode" ) var ( blockKey = []byte{0x14, 0x6e, 0x0b, 0xe7, 0xab, 0xac, 0xd0, 0xd6} // Block keys used for encryption oleIdentifier = []byte{0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1} iterCount = 50000 packageEncryptionChunkSize = 4096 packageOffset = 8 // First 8 bytes are the size of the stream sheetProtectionSpinCount = 1e5 ) // Encryption specifies the encryption structure, streams, and storages are // required when encrypting ECMA-376 documents. type Encryption struct { XMLName xml.Name `xml:"encryption"` KeyData KeyData `xml:"keyData"` DataIntegrity DataIntegrity `xml:"dataIntegrity"` KeyEncryptors KeyEncryptors `xml:"keyEncryptors"` } // KeyData specifies the cryptographic attributes used to encrypt the data. type KeyData struct { SaltSize int `xml:"saltSize,attr"` BlockSize int `xml:"blockSize,attr"` KeyBits int `xml:"keyBits,attr"` HashSize int `xml:"hashSize,attr"` CipherAlgorithm string `xml:"cipherAlgorithm,attr"` CipherChaining string `xml:"cipherChaining,attr"` HashAlgorithm string `xml:"hashAlgorithm,attr"` SaltValue string `xml:"saltValue,attr"` } // DataIntegrity specifies the encrypted copies of the salt and hash values // used to help ensure that the integrity of the encrypted data has not been // compromised. type DataIntegrity struct { EncryptedHmacKey string `xml:"encryptedHmacKey,attr"` EncryptedHmacValue string `xml:"encryptedHmacValue,attr"` } // KeyEncryptors specifies the key encryptors used to encrypt the data. type KeyEncryptors struct { KeyEncryptor []KeyEncryptor `xml:"keyEncryptor"` } // KeyEncryptor specifies that the schema used by this encryptor is the schema // specified for password-based encryptors. type KeyEncryptor struct { XMLName xml.Name `xml:"keyEncryptor"` URI string `xml:"uri,attr"` EncryptedKey EncryptedKey `xml:"encryptedKey"` } // EncryptedKey used to generate the encrypting key. type EncryptedKey struct { XMLName xml.Name `xml:"http://schemas.microsoft.com/office/2006/keyEncryptor/password encryptedKey"` SpinCount int `xml:"spinCount,attr"` EncryptedVerifierHashInput string `xml:"encryptedVerifierHashInput,attr"` EncryptedVerifierHashValue string `xml:"encryptedVerifierHashValue,attr"` EncryptedKeyValue string `xml:"encryptedKeyValue,attr"` KeyData } // StandardEncryptionHeader structure is used by ECMA-376 document encryption // [ECMA-376] and Office binary document RC4 CryptoAPI encryption, to specify // encryption properties for an encrypted stream. type StandardEncryptionHeader struct { Flags uint32 SizeExtra uint32 AlgID uint32 AlgIDHash uint32 KeySize uint32 ProviderType uint32 Reserved1 uint32 Reserved2 uint32 CspName string } // StandardEncryptionVerifier structure is used by Office Binary Document RC4 // CryptoAPI Encryption and ECMA-376 Document Encryption. Every usage of this // structure MUST specify the hashing algorithm and encryption algorithm used // in the EncryptionVerifier structure. type StandardEncryptionVerifier struct { SaltSize uint32 Salt []byte EncryptedVerifier []byte VerifierHashSize uint32 EncryptedVerifierHash []byte } // encryptionInfo structure is used for standard encryption with SHA1 // cryptographic algorithm. type encryption struct { BlockSize, SaltSize int EncryptedKeyValue, EncryptedVerifierHashInput, EncryptedVerifierHashValue, SaltValue []byte KeyBits uint32 } // Decrypt API decrypts the CFB file format with ECMA-376 agile encryption and // standard encryption. Support cryptographic algorithm: MD4, MD5, RIPEMD-160, // SHA1, SHA256, SHA384 and SHA512 currently. func Decrypt(raw []byte, opt *Options) (packageBuf []byte, err error) { doc, err := mscfb.New(bytes.NewReader(raw)) if err != nil { return } encryptionInfoBuf, encryptedPackageBuf := extractPart(doc) mechanism, err := encryptionMechanism(encryptionInfoBuf) if err != nil || mechanism == "extensible" { return } if mechanism == "agile" { return agileDecrypt(encryptionInfoBuf, encryptedPackageBuf, opt) } return standardDecrypt(encryptionInfoBuf, encryptedPackageBuf, opt) } // Encrypt API encrypt data with the password. func Encrypt(raw []byte, opt *Options) (packageBuf []byte, err error) { encryptor := encryption{ EncryptedVerifierHashInput: make([]byte, 16), EncryptedVerifierHashValue: make([]byte, 32), SaltValue: make([]byte, 16), BlockSize: 16, KeyBits: 128, SaltSize: 16, } // Key Encryption encryptionInfoBuffer, err := encryptor.standardKeyEncryption(opt.Password) if err != nil { return nil, err } // Package Encryption encryptedPackage := make([]byte, 8) binary.LittleEndian.PutUint64(encryptedPackage, uint64(len(raw))) encryptedPackage = append(encryptedPackage, encryptor.encrypt(raw)...) // Create a new CFB compoundFile := cfb{} packageBuf = compoundFile.Writer(encryptionInfoBuffer, encryptedPackage) return packageBuf, nil } // extractPart extract data from storage by specified part name. func extractPart(doc *mscfb.Reader) (encryptionInfoBuf, encryptedPackageBuf []byte) { for entry, err := doc.Next(); err == nil; entry, err = doc.Next() { switch entry.Name { case "EncryptionInfo": buf := make([]byte, entry.Size) i, _ := doc.Read(buf) if i > 0 { encryptionInfoBuf = buf } case "EncryptedPackage": buf := make([]byte, entry.Size) i, _ := doc.Read(buf) if i > 0 { encryptedPackageBuf = buf } } } return } // encryptionMechanism parse password-protected documents created mechanism. func encryptionMechanism(buffer []byte) (mechanism string, err error) { if len(buffer) < 4 { err = ErrUnknownEncryptMechanism return } versionMajor, versionMinor := binary.LittleEndian.Uint16(buffer[:2]), binary.LittleEndian.Uint16(buffer[2:4]) if versionMajor == 4 && versionMinor == 4 { mechanism = "agile" return } else if (2 <= versionMajor && versionMajor <= 4) && versionMinor == 2 { mechanism = "standard" return } else if (versionMajor == 3 || versionMajor == 4) && versionMinor == 3 { mechanism = "extensible" } err = ErrUnsupportedEncryptMechanism return } // ECMA-376 Standard Encryption // standardDecrypt decrypt the CFB file format with ECMA-376 standard encryption. func standardDecrypt(encryptionInfoBuf, encryptedPackageBuf []byte, opt *Options) ([]byte, error) { encryptionHeaderSize := binary.LittleEndian.Uint32(encryptionInfoBuf[8:12]) block := encryptionInfoBuf[12 : 12+encryptionHeaderSize] header := StandardEncryptionHeader{ Flags: binary.LittleEndian.Uint32(block[:4]), SizeExtra: binary.LittleEndian.Uint32(block[4:8]), AlgID: binary.LittleEndian.Uint32(block[8:12]), AlgIDHash: binary.LittleEndian.Uint32(block[12:16]), KeySize: binary.LittleEndian.Uint32(block[16:20]), ProviderType: binary.LittleEndian.Uint32(block[20:24]), Reserved1: binary.LittleEndian.Uint32(block[24:28]), Reserved2: binary.LittleEndian.Uint32(block[28:32]), CspName: string(block[32:]), } block = encryptionInfoBuf[12+encryptionHeaderSize:] algIDMap := map[uint32]string{ 0x0000660E: "AES-128", 0x0000660F: "AES-192", 0x00006610: "AES-256", } algorithm := "AES" _, ok := algIDMap[header.AlgID] if !ok { algorithm = "RC4" } verifier := standardEncryptionVerifier(algorithm, block) secretKey, err := standardConvertPasswdToKey(header, verifier, opt) if err != nil { return nil, err } // decrypted data x := encryptedPackageBuf[8:] blob, err := aes.NewCipher(secretKey) if err != nil { return nil, err } decrypted := make([]byte, len(x)) size := 16 for bs, be := 0, size; bs < len(x); bs, be = bs+size, be+size { blob.Decrypt(decrypted[bs:be], x[bs:be]) } return decrypted, err } // standardEncryptionVerifier extract ECMA-376 standard encryption verifier. func standardEncryptionVerifier(algorithm string, blob []byte) StandardEncryptionVerifier { verifier := StandardEncryptionVerifier{ SaltSize: binary.LittleEndian.Uint32(blob[:4]), Salt: blob[4:20], EncryptedVerifier: blob[20:36], VerifierHashSize: binary.LittleEndian.Uint32(blob[36:40]), } if algorithm == "RC4" { verifier.EncryptedVerifierHash = blob[40:60] } else if algorithm == "AES" { verifier.EncryptedVerifierHash = blob[40:72] } return verifier } // standardConvertPasswdToKey generate intermediate key from given password. func standardConvertPasswdToKey(header StandardEncryptionHeader, verifier StandardEncryptionVerifier, opt *Options) ([]byte, error) { encoder := unicode.UTF16(unicode.LittleEndian, unicode.IgnoreBOM).NewEncoder() passwordBuffer, err := encoder.Bytes([]byte(opt.Password)) if err != nil { return nil, err } key := hashing("sha1", verifier.Salt, passwordBuffer) for i := 0; i < iterCount; i++ { iterator := createUInt32LEBuffer(i, 4) key = hashing("sha1", iterator, key) } var block int hFinal := hashing("sha1", key, createUInt32LEBuffer(block, 4)) cbRequiredKeyLength := int(header.KeySize) / 8 cbHash := sha1.Size buf1 := bytes.Repeat([]byte{0x36}, 64) buf1 = append(standardXORBytes(hFinal, buf1[:cbHash]), buf1[cbHash:]...) x1 := hashing("sha1", buf1) buf2 := bytes.Repeat([]byte{0x5c}, 64) buf2 = append(standardXORBytes(hFinal, buf2[:cbHash]), buf2[cbHash:]...) x2 := hashing("sha1", buf2) x3 := append(x1, x2...) keyDerived := x3[:cbRequiredKeyLength] return keyDerived, err } // standardXORBytes perform XOR operations for two bytes slice. func standardXORBytes(a, b []byte) []byte { r := make([][2]byte, len(a)) for i, e := range a { r[i] = [2]byte{e, b[i]} } buf := make([]byte, len(a)) for p, q := range r { buf[p] = q[0] ^ q[1] } return buf } // encrypt provides a function to encrypt given value with AES cryptographic // algorithm. func (e *encryption) encrypt(input []byte) []byte { inputBytes := len(input) if pad := inputBytes % e.BlockSize; pad != 0 { inputBytes += e.BlockSize - pad } var output, chunk []byte encryptedChunk := make([]byte, e.BlockSize) for i := 0; i < inputBytes; i += e.BlockSize { if i+e.BlockSize <= len(input) { chunk = input[i : i+e.BlockSize] } else { chunk = input[i:] } chunk = append(chunk, make([]byte, e.BlockSize-len(chunk))...) c, _ := aes.NewCipher(e.EncryptedKeyValue) c.Encrypt(encryptedChunk, chunk) output = append(output, encryptedChunk...) } return output } // standardKeyEncryption encrypt convert the password to an encryption key. func (e *encryption) standardKeyEncryption(password string) ([]byte, error) { if len(password) == 0 || len(password) > MaxFieldLength { return nil, ErrPasswordLengthInvalid } var storage cfb storage.writeUint16(0x0003) storage.writeUint16(0x0002) storage.writeUint32(0x24) storage.writeUint32(0xA4) storage.writeUint32(0x24) storage.writeUint32(0x00) storage.writeUint32(0x660E) storage.writeUint32(0x8004) storage.writeUint32(0x80) storage.writeUint32(0x18) storage.writeUint64(0x00) providerName := "Microsoft Enhanced RSA and AES Cryptographic Provider (Prototype)" storage.writeStrings(providerName) storage.writeUint16(0x00) storage.writeUint32(0x10) keyDataSaltValue, _ := randomBytes(16) verifierHashInput, _ := randomBytes(16) e.SaltValue = keyDataSaltValue e.EncryptedKeyValue, _ = standardConvertPasswdToKey( StandardEncryptionHeader{KeySize: e.KeyBits}, StandardEncryptionVerifier{Salt: e.SaltValue}, &Options{Password: password}) verifierHashInputKey := hashing("sha1", verifierHashInput) e.EncryptedVerifierHashInput = e.encrypt(verifierHashInput) e.EncryptedVerifierHashValue = e.encrypt(verifierHashInputKey) storage.writeBytes(e.SaltValue) storage.writeBytes(e.EncryptedVerifierHashInput) storage.writeUint32(0x14) storage.writeBytes(e.EncryptedVerifierHashValue) storage.position = 0 return storage.stream, nil } // ECMA-376 Agile Encryption // agileDecrypt decrypt the CFB file format with ECMA-376 agile encryption. // Support cryptographic algorithm: MD4, MD5, RIPEMD-160, SHA1, SHA256, // SHA384 and SHA512. func agileDecrypt(encryptionInfoBuf, encryptedPackageBuf []byte, opt *Options) (packageBuf []byte, err error) { var encryptionInfo Encryption if encryptionInfo, err = parseEncryptionInfo(encryptionInfoBuf[8:]); err != nil { return } // Convert the password into an encryption key. key, err := convertPasswdToKey(opt.Password, blockKey, encryptionInfo) if err != nil { return } // Use the key to decrypt the package key. encryptedKey := encryptionInfo.KeyEncryptors.KeyEncryptor[0].EncryptedKey saltValue, err := base64.StdEncoding.DecodeString(encryptedKey.SaltValue) if err != nil { return } encryptedKeyValue, err := base64.StdEncoding.DecodeString(encryptedKey.EncryptedKeyValue) if err != nil { return } packageKey, _ := decrypt(key, saltValue, encryptedKeyValue) // Use the package key to decrypt the package. return decryptPackage(packageKey, encryptedPackageBuf, encryptionInfo) } // convertPasswdToKey convert the password into an encryption key. func convertPasswdToKey(passwd string, blockKey []byte, encryption Encryption) (key []byte, err error) { var b bytes.Buffer saltValue, err := base64.StdEncoding.DecodeString(encryption.KeyEncryptors.KeyEncryptor[0].EncryptedKey.SaltValue) if err != nil { return } b.Write(saltValue) encoder := unicode.UTF16(unicode.LittleEndian, unicode.IgnoreBOM).NewEncoder() passwordBuffer, err := encoder.Bytes([]byte(passwd)) if err != nil { return } b.Write(passwordBuffer) // Generate the initial hash. key = hashing(encryption.KeyData.HashAlgorithm, b.Bytes()) // Now regenerate until spin count. for i := 0; i < encryption.KeyEncryptors.KeyEncryptor[0].EncryptedKey.SpinCount; i++ { iterator := createUInt32LEBuffer(i, 4) key = hashing(encryption.KeyData.HashAlgorithm, iterator, key) } // Now generate the final hash. key = hashing(encryption.KeyData.HashAlgorithm, key, blockKey) // Truncate or pad as needed to get to length of keyBits. keyBytes := encryption.KeyEncryptors.KeyEncryptor[0].EncryptedKey.KeyBits / 8 if len(key) < keyBytes { tmp := make([]byte, 0x36) key = append(key, tmp...) } else if len(key) > keyBytes { key = key[:keyBytes] } return } // hashing data by specified hash algorithm. func hashing(hashAlgorithm string, buffer ...[]byte) (key []byte) { hashMap := map[string]hash.Hash{ "md4": md4.New(), "md5": md5.New(), "ripemd-160": ripemd160.New(), "sha1": sha1.New(), "sha256": sha256.New(), "sha384": sha512.New384(), "sha512": sha512.New(), } handler, ok := hashMap[strings.ToLower(hashAlgorithm)] if !ok { return key } for _, buf := range buffer { _, _ = handler.Write(buf) } key = handler.Sum(nil) return key } // createUInt32LEBuffer create buffer with little endian 32-bit unsigned // integer. func createUInt32LEBuffer(value int, bufferSize int) []byte { buf := make([]byte, bufferSize) binary.LittleEndian.PutUint32(buf, uint32(value)) return buf } // parseEncryptionInfo parse the encryption info XML into an object. func parseEncryptionInfo(encryptionInfo []byte) (encryption Encryption, err error) { err = xml.Unmarshal(encryptionInfo, &encryption) return } // decrypt provides a function to decrypt input by given cipher algorithm, // cipher chaining, key and initialization vector. func decrypt(key, iv, input []byte) (packageKey []byte, err error) { block, err := aes.NewCipher(key) if err != nil { return input, err } cipher.NewCBCDecrypter(block, iv).CryptBlocks(input, input) return input, nil } // decryptPackage decrypt package by given packageKey and encryption // info. func decryptPackage(packageKey, input []byte, encryption Encryption) (outputChunks []byte, err error) { encryptedKey, offset := encryption.KeyData, packageOffset var i, start, end int var iv, outputChunk []byte for end < len(input) { start = end end = start + packageEncryptionChunkSize if end > len(input) { end = len(input) } // Grab the next chunk var inputChunk []byte if (end + offset) < len(input) { inputChunk = input[start+offset : end+offset] } else { inputChunk = input[start+offset : end] } // Pad the chunk if it is not an integer multiple of the block size remainder := len(inputChunk) % encryptedKey.BlockSize if remainder != 0 { inputChunk = append(inputChunk, make([]byte, encryptedKey.BlockSize-remainder)...) } // Create the initialization vector iv, err = createIV(i, encryption) if err != nil { return } // Decrypt the chunk and add it to the array outputChunk, err = decrypt(packageKey, iv, inputChunk) if err != nil { return } outputChunks = append(outputChunks, outputChunk...) i++ } return } // createIV create an initialization vector (IV). func createIV(blockKey interface{}, encryption Encryption) ([]byte, error) { encryptedKey := encryption.KeyData // Create the block key from the current index var blockKeyBuf []byte if reflect.TypeOf(blockKey).Kind() == reflect.Int { blockKeyBuf = createUInt32LEBuffer(blockKey.(int), 4) } else { blockKeyBuf = blockKey.([]byte) } saltValue, err := base64.StdEncoding.DecodeString(encryptedKey.SaltValue) if err != nil { return nil, err } // Create the initialization vector by hashing the salt with the block key. // Truncate or pad as needed to meet the block size. iv := hashing(encryptedKey.HashAlgorithm, append(saltValue, blockKeyBuf...)) if len(iv) < encryptedKey.BlockSize { tmp := make([]byte, 0x36) iv = append(iv, tmp...) } else if len(iv) > encryptedKey.BlockSize { iv = iv[:encryptedKey.BlockSize] } return iv, nil } // randomBytes returns securely generated random bytes. It will return an // error if the system's secure random number generator fails to function // correctly, in which case the caller should not continue. func randomBytes(n int) ([]byte, error) { b := make([]byte, n) _, err := rand.Read(b) return b, err } // ISO Write Protection Method // genISOPasswdHash implements the ISO password hashing algorithm by given // plaintext password, name of the cryptographic hash algorithm, salt value // and spin count. func genISOPasswdHash(passwd, hashAlgorithm, salt string, spinCount int) (hashValue, saltValue string, err error) { if len(passwd) < 1 || len(passwd) > MaxFieldLength { err = ErrPasswordLengthInvalid return } algorithmName, ok := map[string]string{ "MD4": "md4", "MD5": "md5", "SHA-1": "sha1", "SHA-256": "sha256", "SHA-384": "sha384", "SHA-512": "sha512", }[hashAlgorithm] if !ok { err = ErrUnsupportedHashAlgorithm return } var b bytes.Buffer s, _ := randomBytes(16) if salt != "" { if s, err = base64.StdEncoding.DecodeString(salt); err != nil { return } } b.Write(s) encoder := unicode.UTF16(unicode.LittleEndian, unicode.IgnoreBOM).NewEncoder() passwordBuffer, _ := encoder.Bytes([]byte(passwd)) b.Write(passwordBuffer) // Generate the initial hash. key := hashing(algorithmName, b.Bytes()) // Now regenerate until spin count. for i := 0; i < spinCount; i++ { iterator := createUInt32LEBuffer(i, 4) key = hashing(algorithmName, key, iterator) } hashValue, saltValue = base64.StdEncoding.EncodeToString(key), base64.StdEncoding.EncodeToString(s) return } // Compound File Binary Implements // cfb structure is used for the compound file binary (CFB) file format writer. type cfb struct { stream []byte position int } // writeBytes write bytes in the stream by a given value with an offset. func (c *cfb) writeBytes(value []byte) { pos := c.position for i := 0; i < len(value); i++ { for j := len(c.stream); j <= i+pos; j++ { c.stream = append(c.stream, 0) } c.stream[i+pos] = value[i] } c.position = pos + len(value) } // writeUint16 write an uint16 data type bytes in the stream by a given value // with an offset. func (c *cfb) writeUint16(value int) { buf := make([]byte, 2) binary.LittleEndian.PutUint16(buf, uint16(value)) c.writeBytes(buf) } // writeUint32 write an uint32 data type bytes in the stream by a given value // with an offset. func (c *cfb) writeUint32(value int) { buf := make([]byte, 4) binary.LittleEndian.PutUint32(buf, uint32(value)) c.writeBytes(buf) } // writeUint64 write an uint64 data type bytes in the stream by a given value // with an offset. func (c *cfb) writeUint64(value int) { buf := make([]byte, 8) binary.LittleEndian.PutUint64(buf, uint64(value)) c.writeBytes(buf) } // writeBytes write strings in the stream by a given value with an offset. func (c *cfb) writeStrings(value string) { encoder := unicode.UTF16(unicode.LittleEndian, unicode.IgnoreBOM).NewEncoder() buffer, err := encoder.Bytes([]byte(value)) if err != nil { return } c.writeBytes(buffer) } // writeVersionStream provides a function to write compound file version // stream. func (c *cfb) writeVersionStream() []byte { var storage cfb storage.writeUint32(0x3c) storage.writeStrings("Microsoft.Container.DataSpaces") storage.writeUint32(0x01) storage.writeUint32(0x01) storage.writeUint32(0x01) return storage.stream } // writeDataSpaceMapStream provides a function to write compound file // DataSpaceMap stream. func (c *cfb) writeDataSpaceMapStream() []byte { var storage cfb storage.writeUint32(0x08) storage.writeUint32(0x01) storage.writeUint32(0x68) storage.writeUint32(0x01) storage.writeUint32(0x00) storage.writeUint32(0x20) storage.writeStrings("EncryptedPackage") storage.writeUint32(0x32) storage.writeStrings("StrongEncryptionDataSpace") storage.writeUint16(0x00) return storage.stream } // writeStrongEncryptionDataSpaceStream provides a function to write compound // file StrongEncryptionDataSpace stream. func (c *cfb) writeStrongEncryptionDataSpaceStream() []byte { var storage cfb storage.writeUint32(0x08) storage.writeUint32(0x01) storage.writeUint32(0x32) storage.writeStrings("StrongEncryptionTransform") storage.writeUint16(0x00) return storage.stream } // writePrimaryStream provides a function to write compound file Primary // stream. func (c *cfb) writePrimaryStream() []byte { var storage cfb storage.writeUint32(0x6C) storage.writeUint32(0x01) storage.writeUint32(0x4C) storage.writeStrings("{FF9A3F03-56EF-4613-BDD5-5A41C1D07246}") storage.writeUint32(0x4E) storage.writeUint16(0x00) storage.writeUint32(0x01) storage.writeUint32(0x01) storage.writeUint32(0x01) storage.writeStrings("AES128") storage.writeUint32(0x00) storage.writeUint32(0x04) return storage.stream } // writeFileStream provides a function to write encrypted package in compound // file by a given buffer and the short sector allocation table. func (c *cfb) writeFileStream(encryptionInfoBuffer []byte, SSAT []int) ([]byte, []int) { var ( storage cfb miniProperties int stream = make([]byte, 0x100) ) if encryptionInfoBuffer != nil { copy(stream, encryptionInfoBuffer) } storage.writeBytes(stream) streamBlocks := len(stream) / 64 if len(stream)%64 > 0 { streamBlocks++ } for i := 1; i < streamBlocks; i++ { SSAT = append(SSAT, i) } SSAT = append(SSAT, -2) miniProperties += streamBlocks versionStream := make([]byte, 0x80) version := c.writeVersionStream() copy(versionStream, version) storage.writeBytes(versionStream) versionBlocks := len(versionStream) / 64 if len(versionStream)%64 > 0 { versionBlocks++ } for i := 1; i < versionBlocks; i++ { SSAT = append(SSAT, i+miniProperties) } SSAT = append(SSAT, -2) miniProperties += versionBlocks dataSpaceMap := make([]byte, 0x80) dataStream := c.writeDataSpaceMapStream() copy(dataSpaceMap, dataStream) storage.writeBytes(dataSpaceMap) dataSpaceMapBlocks := len(dataSpaceMap) / 64 if len(dataSpaceMap)%64 > 0 { dataSpaceMapBlocks++ } for i := 1; i < dataSpaceMapBlocks; i++ { SSAT = append(SSAT, i+miniProperties) } SSAT = append(SSAT, -2) miniProperties += dataSpaceMapBlocks dataSpaceStream := c.writeStrongEncryptionDataSpaceStream() storage.writeBytes(dataSpaceStream) dataSpaceStreamBlocks := len(dataSpaceStream) / 64 if len(dataSpaceStream)%64 > 0 { dataSpaceStreamBlocks++ } for i := 1; i < dataSpaceStreamBlocks; i++ { SSAT = append(SSAT, i+miniProperties) } SSAT = append(SSAT, -2) miniProperties += dataSpaceStreamBlocks primaryStream := make([]byte, 0x1C0) primary := c.writePrimaryStream() copy(primaryStream, primary) storage.writeBytes(primaryStream) primaryBlocks := len(primary) / 64 if len(primary)%64 > 0 { primaryBlocks++ } for i := 1; i < primaryBlocks; i++ { SSAT = append(SSAT, i+miniProperties) } SSAT = append(SSAT, -2) if len(SSAT) < 128 { for i := len(SSAT); i < 128; i++ { SSAT = append(SSAT, -1) } } storage.position = 0 return storage.stream, SSAT } // writeRootEntry provides a function to write compound file root directory // entry. The first entry in the first sector of the directory chain // (also referred to as the first element of the directory array, or stream // ID #0) is known as the root directory entry, and it is reserved for two // purposes. First, it provides a root parent for all objects that are // stationed at the root of the compound file. Second, its function is // overloaded to store the size and starting sector for the mini stream. func (c *cfb) writeRootEntry(customSectID int) []byte { storage := cfb{stream: make([]byte, 128)} storage.writeStrings("Root Entry") storage.position = 0x40 storage.writeUint16(0x16) storage.writeBytes([]byte{5, 0}) storage.writeUint32(-1) storage.writeUint32(-1) storage.writeUint32(1) storage.position = 0x64 storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(customSectID) storage.writeUint32(0x340) return storage.stream } // writeEncryptionInfo provides a function to write compound file // writeEncryptionInfo stream. The writeEncryptionInfo stream contains // detailed information that is used to initialize the cryptography used to // encrypt the EncryptedPackage stream. func (c *cfb) writeEncryptionInfo() []byte { storage := cfb{stream: make([]byte, 128)} storage.writeStrings("EncryptionInfo") storage.position = 0x40 storage.writeUint16(0x1E) storage.writeBytes([]byte{2, 1}) storage.writeUint32(0x03) storage.writeUint32(0x02) storage.writeUint32(-1) storage.position = 0x64 storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(0xF8) return storage.stream } // writeEncryptedPackage provides a function to write compound file // writeEncryptedPackage stream. The writeEncryptedPackage stream is an // encrypted stream of bytes containing the entire ECMA-376 source file in // compressed form. func (c *cfb) writeEncryptedPackage(propertyCount, size int) []byte { storage := cfb{stream: make([]byte, 128)} storage.writeStrings("EncryptedPackage") storage.position = 0x40 storage.writeUint16(0x22) storage.writeBytes([]byte{2, 0}) storage.writeUint32(-1) storage.writeUint32(-1) storage.writeUint32(-1) storage.position = 0x64 storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(propertyCount) storage.writeUint32(size) return storage.stream } // writeDataSpaces provides a function to write compound file writeDataSpaces // stream. The data spaces structure consists of a set of interrelated // storages and streams in an OLE compound file. func (c *cfb) writeDataSpaces() []byte { storage := cfb{stream: make([]byte, 128)} storage.writeUint16(0x06) storage.position = 0x40 storage.writeUint16(0x18) storage.writeBytes([]byte{1, 0}) storage.writeUint32(-1) storage.writeUint32(-1) storage.writeUint32(5) storage.position = 0x64 storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(0) return storage.stream } // writeVersion provides a function to write compound file version. The // writeVersion structure specifies the version of a product or feature. It // contains a major and a minor version number. func (c *cfb) writeVersion() []byte { storage := cfb{stream: make([]byte, 128)} storage.writeStrings("Version") storage.position = 0x40 storage.writeUint16(0x10) storage.writeBytes([]byte{2, 1}) storage.writeUint32(-1) storage.writeUint32(-1) storage.writeUint32(-1) storage.position = 0x64 storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(4) storage.writeUint32(76) return storage.stream } // writeDataSpaceMap provides a function to write compound file // writeDataSpaceMap stream. The writeDataSpaceMap structure associates // protected content with data space definitions. The data space definition, // in turn, describes the series of transforms that MUST be applied to that // protected content to restore it to its original form. By using a map to // associate data space definitions with content, a single data space // definition can be used to define the transforms applied to more than one // piece of protected content. However, a given piece of protected content can // be referenced only by a single data space definition. func (c *cfb) writeDataSpaceMap() []byte { storage := cfb{stream: make([]byte, 128)} storage.writeStrings("DataSpaceMap") storage.position = 0x40 storage.writeUint16(0x1A) storage.writeBytes([]byte{2, 1}) storage.writeUint32(0x04) storage.writeUint32(0x06) storage.writeUint32(-1) storage.position = 0x64 storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(6) storage.writeUint32(112) return storage.stream } // writeDataSpaceInfo provides a function to write compound file // writeDataSpaceInfo storage. The writeDataSpaceInfo is a storage containing // the data space definitions used in the file. This storage must contain one // or more streams, each of which contains a DataSpaceDefinition structure. // The storage must contain exactly one stream for each DataSpaceMapEntry // structure in the DataSpaceMap stream. The name of each stream must be equal // to the DataSpaceName field of exactly one DataSpaceMapEntry structure // contained in the DataSpaceMap stream. func (c *cfb) writeDataSpaceInfo() []byte { storage := cfb{stream: make([]byte, 128)} storage.writeStrings("DataSpaceInfo") storage.position = 0x40 storage.writeUint16(0x1C) storage.writeBytes([]byte{1, 1}) storage.writeUint32(-1) storage.writeUint32(8) storage.writeUint32(7) storage.position = 0x64 storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(0) return storage.stream } // writeStrongEncryptionDataSpace provides a function to write compound file // writeStrongEncryptionDataSpace stream. func (c *cfb) writeStrongEncryptionDataSpace() []byte { storage := cfb{stream: make([]byte, 128)} storage.writeStrings("StrongEncryptionDataSpace") storage.position = 0x40 storage.writeUint16(0x34) storage.writeBytes([]byte{2, 1}) storage.writeUint32(-1) storage.writeUint32(-1) storage.writeUint32(-1) storage.position = 0x64 storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(8) storage.writeUint32(64) return storage.stream } // writeTransformInfo provides a function to write compound file // writeTransformInfo storage. writeTransformInfo is a storage containing // definitions for the transforms used in the data space definitions stored in // the DataSpaceInfo storage. The stream contains zero or more definitions for // the possible transforms that can be applied to the data in content // streams. func (c *cfb) writeTransformInfo() []byte { storage := cfb{stream: make([]byte, 128)} storage.writeStrings("TransformInfo") storage.position = 0x40 storage.writeUint16(0x1C) storage.writeBytes([]byte{1, 0}) storage.writeUint32(-1) storage.writeUint32(-1) storage.writeUint32(9) storage.position = 0x64 storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(0) return storage.stream } // writeStrongEncryptionTransform provides a function to write compound file // writeStrongEncryptionTransform storage. func (c *cfb) writeStrongEncryptionTransform() []byte { storage := cfb{stream: make([]byte, 128)} storage.writeStrings("StrongEncryptionTransform") storage.position = 0x40 storage.writeUint16(0x34) storage.writeBytes([]byte{1}) storage.writeBytes([]byte{1}) storage.writeUint32(-1) storage.writeUint32(-1) storage.writeUint32(0x0A) storage.position = 0x64 storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(0) return storage.stream } // writePrimary provides a function to write compound file writePrimary stream. func (c *cfb) writePrimary() []byte { storage := cfb{stream: make([]byte, 128)} storage.writeUint16(0x06) storage.writeStrings("Primary") storage.position = 0x40 storage.writeUint16(0x12) storage.writeBytes([]byte{2, 1}) storage.writeUint32(-1) storage.writeUint32(-1) storage.writeUint32(-1) storage.position = 0x64 storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(9) storage.writeUint32(208) return storage.stream } // writeNoneDir provides a function to write compound file writeNoneDir stream. func (c *cfb) writeNoneDir() []byte { storage := cfb{stream: make([]byte, 128)} storage.position = 0x40 storage.writeUint16(0x00) storage.writeUint16(0x00) storage.writeUint32(-1) storage.writeUint32(-1) storage.writeUint32(-1) return storage.stream } // writeDirectoryEntry provides a function to write compound file directory // entries. The directory entry array is an array of directory entries that // are grouped into a directory sector. Each storage object or stream object // within a compound file is represented by a single directory entry. The // space for the directory sectors that are holding the array is allocated // from the FAT. func (c *cfb) writeDirectoryEntry(propertyCount, customSectID, size int) []byte { var storage cfb if size < 0 { size = 0 } for _, entry := range [][]byte{ c.writeRootEntry(customSectID), c.writeEncryptionInfo(), c.writeEncryptedPackage(propertyCount, size), c.writeDataSpaces(), c.writeVersion(), c.writeDataSpaceMap(), c.writeDataSpaceInfo(), c.writeStrongEncryptionDataSpace(), c.writeTransformInfo(), c.writeStrongEncryptionTransform(), c.writePrimary(), c.writeNoneDir(), } { storage.writeBytes(entry) } return storage.stream } // writeMSAT provides a function to write compound file master sector allocation // table. func (c *cfb) writeMSAT(MSATBlocks, SATBlocks int, MSAT []int) []int { if MSATBlocks > 0 { cnt, MSATIdx := MSATBlocks*128+109, 0 for i := 0; i < cnt; i++ { if i < SATBlocks { bufferSize := i - 109 if bufferSize > 0 && bufferSize%0x80 == 0 { MSATIdx++ MSAT = append(MSAT, MSATIdx) } MSAT = append(MSAT, i+MSATBlocks) continue } MSAT = append(MSAT, -1) } return MSAT } for i := 0; i < 109; i++ { if i < SATBlocks { MSAT = append(MSAT, i) continue } MSAT = append(MSAT, -1) } return MSAT } // writeSAT provides a function to write compound file sector allocation // table. func (c *cfb) writeSAT(MSATBlocks, SATBlocks, SSATBlocks, directoryBlocks, fileBlocks, streamBlocks int, SAT []int) (int, []int) { var blocks int if SATBlocks > 0 { for i := 1; i <= MSATBlocks; i++ { SAT = append(SAT, -4) } blocks = MSATBlocks for i := 1; i <= SATBlocks; i++ { SAT = append(SAT, -3) } blocks += SATBlocks for i := 1; i < SSATBlocks; i++ { SAT = append(SAT, i) } SAT = append(SAT, -2) blocks += SSATBlocks for i := 1; i < directoryBlocks; i++ { SAT = append(SAT, i+blocks) } SAT = append(SAT, -2) blocks += directoryBlocks for i := 1; i < fileBlocks; i++ { SAT = append(SAT, i+blocks) } SAT = append(SAT, -2) blocks += fileBlocks for i := 1; i < streamBlocks; i++ { SAT = append(SAT, i+blocks) } SAT = append(SAT, -2) } return blocks, SAT } // Writer provides a function to create compound file with given info stream // and package stream. // // MSAT - The master sector allocation table // SSAT - The short sector allocation table // SAT - The sector allocation table func (c *cfb) Writer(encryptionInfoBuffer, encryptedPackage []byte) []byte { var ( storage cfb MSAT, SAT, SSAT []int directoryBlocks, fileBlocks, SSATBlocks = 3, 2, 1 size = int(math.Max(float64(len(encryptedPackage)), float64(packageEncryptionChunkSize))) streamBlocks = len(encryptedPackage) / 0x200 ) if len(encryptedPackage)%0x200 > 0 { streamBlocks++ } propertyBlocks := directoryBlocks + fileBlocks + SSATBlocks blockSize := (streamBlocks + propertyBlocks) * 4 SATBlocks := blockSize / 0x200 if blockSize%0x200 > 0 { SATBlocks++ } MSATBlocks, blocksChanged := 0, true for blocksChanged { var SATCap, MSATCap int blocksChanged = false blockSize = (streamBlocks + propertyBlocks + SATBlocks + MSATBlocks) * 4 SATCap = blockSize / 0x200 if blockSize%0x200 > 0 { SATCap++ } if SATCap > SATBlocks { SATBlocks, blocksChanged = SATCap, true continue } if SATBlocks > 109 { blockRemains := (SATBlocks - 109) * 4 blockBuffer := blockRemains % 0x200 MSATCap = blockRemains / 0x200 if blockBuffer > 0 { MSATCap++ } if blockBuffer+(4*MSATCap) > 0x200 { MSATCap++ } if MSATCap > MSATBlocks { MSATBlocks, blocksChanged = MSATCap, true } } } MSAT = c.writeMSAT(MSATBlocks, SATBlocks, MSAT) blocks, SAT := c.writeSAT(MSATBlocks, SATBlocks, SSATBlocks, directoryBlocks, fileBlocks, streamBlocks, SAT) for i := 0; i < 8; i++ { storage.writeBytes([]byte{oleIdentifier[i]}) } storage.writeBytes(make([]byte, 16)) storage.writeUint16(0x003E) storage.writeUint16(0x0003) storage.writeUint16(-2) storage.writeUint16(9) storage.writeUint32(6) storage.writeUint32(0) storage.writeUint32(0) storage.writeUint32(SATBlocks) storage.writeUint32(MSATBlocks + SATBlocks + SSATBlocks) storage.writeUint32(0) storage.writeUint32(0x00001000) storage.writeUint32(SATBlocks + MSATBlocks) storage.writeUint32(SSATBlocks) if MSATBlocks > 0 { storage.writeUint32(0) storage.writeUint32(MSATBlocks) } else { storage.writeUint32(-2) storage.writeUint32(0) } for _, block := range MSAT { storage.writeUint32(block) } for i := 0; i < SATBlocks*128; i++ { if i < len(SAT) { storage.writeUint32(SAT[i]) continue } storage.writeUint32(-1) } fileStream, SSATStream := c.writeFileStream(encryptionInfoBuffer, SSAT) for _, block := range SSATStream { storage.writeUint32(block) } directoryEntry := c.writeDirectoryEntry(blocks, blocks-fileBlocks, size) storage.writeBytes(directoryEntry) storage.writeBytes(fileStream) storage.writeBytes(encryptedPackage) return storage.stream }