65cf94b76c
This allows the code to deal with files > 2 GB in size. Previous to this change a file > 2 GB would cause a JSON unmarshal error. This is a breaking change to the API. However the Go compiler will throw errors at the right places when compiling so should be easy to fix up the code.
229 lines
6.6 KiB
Go
229 lines
6.6 KiB
Go
/*
|
|
** Copyright (c) 2014 Arnaud Ysmal. All Rights Reserved.
|
|
**
|
|
** Redistribution and use in source and binary forms, with or without
|
|
** modification, are permitted provided that the following conditions
|
|
** are met:
|
|
** 1. Redistributions of source code must retain the above copyright
|
|
** notice, this list of conditions and the following disclaimer.
|
|
** 2. Redistributions in binary form must reproduce the above copyright
|
|
** notice, this list of conditions and the following disclaimer in the
|
|
** documentation and/or other materials provided with the distribution.
|
|
**
|
|
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
|
|
** OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
** DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
** FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
** SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
** HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
** LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
** OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
** SUCH DAMAGE.
|
|
*/
|
|
|
|
package dropbox
|
|
|
|
import (
|
|
"crypto/aes"
|
|
"crypto/cipher"
|
|
"crypto/rand"
|
|
"io"
|
|
"os"
|
|
)
|
|
|
|
// GenerateKey generates a key by reading length bytes from /dev/random
|
|
func GenerateKey(length int) ([]byte, error) {
|
|
var err error
|
|
var fd io.Reader
|
|
var rv []byte
|
|
|
|
if fd, err = os.Open("/dev/random"); err != nil {
|
|
return nil, err
|
|
}
|
|
rv = make([]byte, length)
|
|
_, err = io.ReadFull(fd, rv)
|
|
return rv, err
|
|
}
|
|
|
|
func newCrypter(key []byte, in io.Reader, size int, newCipher func(key []byte) (cipher.Block, error)) (io.ReadCloser, int, error) {
|
|
var block cipher.Block
|
|
var err error
|
|
|
|
if block, err = newCipher(key); err != nil {
|
|
return nil, 0, err
|
|
}
|
|
outsize := size - size%block.BlockSize() + 2*block.BlockSize()
|
|
|
|
rd, wr := io.Pipe()
|
|
go encrypt(block, in, size, wr)
|
|
return rd, outsize, nil
|
|
}
|
|
|
|
func newDecrypter(key []byte, in io.Reader, size int, newCipher func(key []byte) (cipher.Block, error)) (io.ReadCloser, error) {
|
|
var block cipher.Block
|
|
var err error
|
|
|
|
if block, err = newCipher(key); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
rd, wr := io.Pipe()
|
|
go decrypt(block, in, size, wr)
|
|
return rd, nil
|
|
}
|
|
|
|
// NewAESDecrypterReader creates and returns a new io.ReadCloser to decrypt the given io.Reader containing size bytes with the given AES key.
|
|
// The AES key should be either 16, 24, or 32 bytes to select AES-128, AES-192, or AES-256.
|
|
func NewAESDecrypterReader(key []byte, input io.Reader, size int) (io.ReadCloser, error) {
|
|
return newDecrypter(key, input, size, aes.NewCipher)
|
|
}
|
|
|
|
// NewAESCrypterReader creates and returns a new io.ReadCloser to encrypt the given io.Reader containing size bytes with the given AES key.
|
|
// The AES key should be either 16, 24, or 32 bytes to select AES-128, AES-192, or AES-256.
|
|
func NewAESCrypterReader(key []byte, input io.Reader, size int) (io.ReadCloser, int, error) {
|
|
return newCrypter(key, input, size, aes.NewCipher)
|
|
}
|
|
|
|
func encrypt(block cipher.Block, in io.Reader, size int, out io.WriteCloser) error {
|
|
var err error
|
|
var rd int
|
|
var buf []byte
|
|
var last bool
|
|
var encrypter cipher.BlockMode
|
|
|
|
defer out.Close()
|
|
|
|
buf = make([]byte, block.BlockSize())
|
|
|
|
if _, err = io.ReadFull(rand.Reader, buf); err != nil {
|
|
return err
|
|
}
|
|
encrypter = cipher.NewCBCEncrypter(block, buf)
|
|
|
|
if _, err = out.Write(buf); err != nil {
|
|
return err
|
|
}
|
|
for !last {
|
|
if rd, err = io.ReadFull(in, buf); err != nil {
|
|
if err == io.ErrUnexpectedEOF || err == io.EOF {
|
|
buf = buf[:rd]
|
|
buf = append(buf, 0x80)
|
|
for len(buf) < block.BlockSize() {
|
|
buf = append(buf, 0x00)
|
|
}
|
|
last = true
|
|
} else {
|
|
return err
|
|
}
|
|
}
|
|
encrypter.CryptBlocks(buf, buf)
|
|
if _, err = out.Write(buf); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func decrypt(block cipher.Block, in io.Reader, size int, out io.WriteCloser) error {
|
|
var err error
|
|
var buf []byte
|
|
var count int
|
|
var decrypter cipher.BlockMode
|
|
|
|
defer out.Close()
|
|
|
|
buf = make([]byte, block.BlockSize())
|
|
if _, err = io.ReadFull(in, buf); err != nil {
|
|
return err
|
|
}
|
|
decrypter = cipher.NewCBCDecrypter(block, buf)
|
|
|
|
count = (size - block.BlockSize()) / block.BlockSize()
|
|
for count > 0 && err == nil {
|
|
if _, err = io.ReadFull(in, buf); err == nil {
|
|
decrypter.CryptBlocks(buf, buf)
|
|
if count == 1 {
|
|
for count = block.BlockSize() - 1; buf[count] == 0x00; count-- {
|
|
continue
|
|
}
|
|
if buf[count] == 0x80 {
|
|
buf = buf[:count]
|
|
}
|
|
}
|
|
_, err = out.Write(buf)
|
|
}
|
|
count--
|
|
}
|
|
if err == io.EOF {
|
|
return nil
|
|
}
|
|
return err
|
|
}
|
|
|
|
// FilesPutAES uploads and encrypts size bytes from the input reader to the dst path on Dropbox.
|
|
func (db *Dropbox) FilesPutAES(key []byte, input io.ReadCloser, size int64, dst string, overwrite bool, parentRev string) (*Entry, error) {
|
|
var encreader io.ReadCloser
|
|
var outsize int
|
|
var err error
|
|
|
|
if encreader, outsize, err = NewAESCrypterReader(key, input, int(size)); err != nil {
|
|
return nil, err
|
|
}
|
|
return db.FilesPut(encreader, int64(outsize), dst, overwrite, parentRev)
|
|
}
|
|
|
|
// UploadFileAES uploads and encrypts the file located in the src path on the local disk to the dst path on Dropbox.
|
|
func (db *Dropbox) UploadFileAES(key []byte, src, dst string, overwrite bool, parentRev string) (*Entry, error) {
|
|
var err error
|
|
var fd *os.File
|
|
var fsize int64
|
|
|
|
if fd, err = os.Open(src); err != nil {
|
|
return nil, err
|
|
}
|
|
defer fd.Close()
|
|
|
|
if fi, err := fd.Stat(); err == nil {
|
|
fsize = fi.Size()
|
|
} else {
|
|
return nil, err
|
|
}
|
|
return db.FilesPutAES(key, fd, fsize, dst, overwrite, parentRev)
|
|
}
|
|
|
|
// DownloadAES downloads and decrypts the file located in the src path on Dropbox and returns a io.ReadCloser.
|
|
func (db *Dropbox) DownloadAES(key []byte, src, rev string, offset int) (io.ReadCloser, error) {
|
|
var in io.ReadCloser
|
|
var size int64
|
|
var err error
|
|
|
|
if in, size, err = db.Download(src, rev, int64(offset)); err != nil {
|
|
return nil, err
|
|
}
|
|
return NewAESDecrypterReader(key, in, int(size))
|
|
}
|
|
|
|
// DownloadToFileAES downloads and decrypts the file located in the src path on Dropbox to the dst file on the local disk.
|
|
func (db *Dropbox) DownloadToFileAES(key []byte, src, dst, rev string) error {
|
|
var input io.ReadCloser
|
|
var fd *os.File
|
|
var err error
|
|
|
|
if fd, err = os.Create(dst); err != nil {
|
|
return err
|
|
}
|
|
defer fd.Close()
|
|
|
|
if input, err = db.DownloadAES(key, src, rev, 0); err != nil {
|
|
os.Remove(dst)
|
|
return err
|
|
}
|
|
defer input.Close()
|
|
if _, err = io.Copy(fd, input); err != nil {
|
|
os.Remove(dst)
|
|
}
|
|
return err
|
|
}
|