1273 lines
40 KiB
Go
1273 lines
40 KiB
Go
// 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
|
|
}
|