Beispiel #1
0
        protected byte[] DownloadCacheFile(IFileInfo target, IDocument remoteDocument, Transmission transmission, IFileSystemInfoFactory fsFactory)
        {
            if (!this.LoadCacheFile(target, remoteDocument, fsFactory))
            {
                if (target.Exists)
                {
                    target.Delete();
                }
            }

            using (var hashAlg = new SHA1Reuse()) {
                using (var filestream = target.Open(FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None))
                    using (var downloader = ContentTaskUtils.CreateDownloader()) {
                        try {
                            downloader.DownloadFile(remoteDocument, filestream, transmission, hashAlg, (byte[] checksumUpdate, long length) => this.SaveCacheFile(target, remoteDocument, checksumUpdate, length, transmission));
                            if (this.TransmissionStorage != null)
                            {
                                this.TransmissionStorage.RemoveObjectByRemoteObjectId(remoteDocument.Id);
                            }
                        } catch (Exception ex) {
                            transmission.FailedException = ex;
                            throw;
                        }
                    }

                target.Refresh();
                return(hashAlg.Hash);
            }
        }
        public void Compute1024Bytes() {
            byte[] data = new byte[1024];

            using (SHA1Managed sha1 = new SHA1Managed())
            using (SHA1Reuse reuse = new SHA1Reuse()) {
                Assert.IsTrue(reuse.ComputeHash(data).SequenceEqual(sha1.ComputeHash(data)));
            }

            using (SHA1Managed sha1 = new SHA1Managed())
            using (SHA1Reuse reuse = new SHA1Reuse()) {
                Assert.IsTrue(reuse.ComputeHash(data).SequenceEqual(sha1.ComputeHash(data)));
            }
        }
        public void ComputeArray([Values(0, 1, 2, 10, 1024, 325245)]long length) {
            byte[] data = new byte[length];

            using (SHA1Managed sha1 = new SHA1Managed())
            using (SHA1Reuse reuse = new SHA1Reuse()) {
                Assert.IsTrue(reuse.ComputeHash(data).SequenceEqual(sha1.ComputeHash(data)));
            }

            using (SHA1Managed sha1 = new SHA1Managed())
            using (SHA1Reuse reuse = new SHA1Reuse()) {
                Assert.IsTrue(reuse.ComputeHash(data).SequenceEqual(sha1.ComputeHash(data)));
            }
        }
        public void Compute1024Bytes()
        {
            byte[] data = new byte[1024];

            using (SHA1Managed sha1 = new SHA1Managed())
                using (SHA1Reuse reuse = new SHA1Reuse()) {
                    Assert.IsTrue(reuse.ComputeHash(data).SequenceEqual(sha1.ComputeHash(data)));
                }

            using (SHA1Managed sha1 = new SHA1Managed())
                using (SHA1Reuse reuse = new SHA1Reuse()) {
                    Assert.IsTrue(reuse.ComputeHash(data).SequenceEqual(sha1.ComputeHash(data)));
                }
        }
        public void ComputeArray([Values(0, 1, 2, 10, 1024, 325245)] long length)
        {
            byte[] data = new byte[length];

            using (SHA1Managed sha1 = new SHA1Managed())
                using (SHA1Reuse reuse = new SHA1Reuse()) {
                    Assert.IsTrue(reuse.ComputeHash(data).SequenceEqual(sha1.ComputeHash(data)));
                }

            using (SHA1Managed sha1 = new SHA1Managed())
                using (SHA1Reuse reuse = new SHA1Reuse()) {
                    Assert.IsTrue(reuse.ComputeHash(data).SequenceEqual(sha1.ComputeHash(data)));
                }
        }
        public void ComputeBlocksByEmptyBlockSize() {
            int dataLength = 0;
            byte[] data = new byte[dataLength];

            using (SHA1Managed sha1 = new SHA1Managed())
            using (SHA1Reuse reuse = new SHA1Reuse()) {
                for (int i = 0; i < 10; ++i) {
                    sha1.TransformBlock(data, 0, dataLength, data, 0);
                    reuse.TransformBlock(data, 0, dataLength, data, 0);
                }

                sha1.TransformFinalBlock(data, dataLength, 0);
                reuse.TransformFinalBlock(data, dataLength, 0);
                Assert.IsTrue(sha1.Hash.SequenceEqual(reuse.Hash));
            }
        }
        public void ComputeBlocksWithBlockSize([Values(1, 1024, 324734)] int dataLength)
        {
            byte[] data = new byte[dataLength];

            using (SHA1Managed sha1 = new SHA1Managed())
                using (SHA1Reuse reuse = new SHA1Reuse()) {
                    for (int i = 0; i < 10; ++i)
                    {
                        sha1.TransformBlock(data, 0, dataLength, data, 0);
                        reuse.TransformBlock(data, 0, dataLength, data, 0);
                    }

                    sha1.TransformFinalBlock(data, dataLength, 0);
                    reuse.TransformFinalBlock(data, dataLength, 0);
                    Assert.IsTrue(sha1.Hash.SequenceEqual(reuse.Hash));
                }
        }
        public void ComputeBlocksViaClone()
        {
            int dataLength = 23;

            byte[] data = new byte[dataLength];

            using (SHA1Managed sha1 = new SHA1Managed())
                using (SHA1Managed sha1_1 = new SHA1Managed())
                    using (SHA1Reuse reuse = new SHA1Reuse())
                        using (SHA1Reuse hash0 = (SHA1Reuse)reuse.Clone()) {
                            for (int i = 0; i < 100; i++)
                            {
                                sha1.TransformBlock(data, 0, dataLength, data, 0);
                                sha1_1.TransformBlock(data, 0, dataLength, data, 0);
                                reuse.TransformBlock(data, 0, dataLength, data, 0);
                                hash0.TransformBlock(data, 0, dataLength, data, 0);
                            }

                            using (var hash1 = hash0.Clone() as HashAlgorithm)
                                using (var hash2 = hash0.Clone() as HashAlgorithm)
                                    using (var hash3 = hash0.Clone() as HashAlgorithm) {
                                        sha1.TransformFinalBlock(data, dataLength, 0);
                                        reuse.TransformFinalBlock(data, dataLength, 0);
                                        hash0.TransformFinalBlock(data, dataLength, 0);
                                        Assert.That(sha1.Hash, Is.EqualTo(reuse.Hash));
                                        Assert.That(sha1.Hash, Is.EqualTo(hash0.Hash));

                                        for (int i = 0; i < 100; i++)
                                        {
                                            sha1_1.TransformBlock(data, 0, dataLength, data, 0);
                                            hash1.TransformBlock(data, 0, dataLength, data, 0);
                                            hash2.TransformBlock(data, 0, dataLength, data, 0);
                                            hash3.TransformBlock(data, 0, dataLength, data, 0);
                                        }

                                        hash1.TransformFinalBlock(data, dataLength, 0);
                                        hash2.TransformFinalBlock(data, dataLength, 0);
                                        hash3.TransformFinalBlock(data, dataLength, 0);
                                        sha1_1.TransformFinalBlock(data, dataLength, 0);
                                        Assert.That(sha1_1.Hash, Is.EqualTo(hash1.Hash));
                                        Assert.That(sha1_1.Hash, Is.EqualTo(hash2.Hash));
                                        Assert.That(sha1_1.Hash, Is.EqualTo(hash3.Hash));
                                    }
                        }
        }
        public void ComputeBlocksByEmptyBlockSize()
        {
            int dataLength = 0;

            byte[] data = new byte[dataLength];

            using (SHA1Managed sha1 = new SHA1Managed())
                using (SHA1Reuse reuse = new SHA1Reuse()) {
                    for (int i = 0; i < 10; ++i)
                    {
                        sha1.TransformBlock(data, 0, dataLength, data, 0);
                        reuse.TransformBlock(data, 0, dataLength, data, 0);
                    }

                    sha1.TransformFinalBlock(data, dataLength, 0);
                    reuse.TransformFinalBlock(data, dataLength, 0);
                    Assert.IsTrue(sha1.Hash.SequenceEqual(reuse.Hash));
                }
        }
Beispiel #10
0
        public void ComputeBlocksViaReuse()
        {
            int dataLength = 23;

            byte[] data = new byte[dataLength];

            using (SHA1Managed sha1 = new SHA1Managed())
                using (SHA1Reuse reuse = new SHA1Reuse()) {
                    SHA1Reuse hash0 = (SHA1Reuse)reuse.Clone();
                    sha1.TransformBlock(data, 0, dataLength, data, 0);
                    reuse.TransformBlock(data, 0, dataLength, data, 0);
                    hash0.TransformBlock(data, 0, dataLength, data, 0);

                    SHA1Reuse hash1 = (SHA1Reuse)reuse.Clone();
                    sha1.TransformBlock(data, 0, dataLength, data, 0);
                    reuse.TransformBlock(data, 0, dataLength, data, 0);
                    hash0.TransformBlock(data, 0, dataLength, data, 0);
                    hash1.TransformBlock(data, 0, dataLength, data, 0);

                    SHA1Reuse hash2 = (SHA1Reuse)reuse.Clone();
                    sha1.TransformBlock(data, 0, dataLength, data, 0);
                    reuse.TransformBlock(data, 0, dataLength, data, 0);
                    hash0.TransformBlock(data, 0, dataLength, data, 0);
                    hash1.TransformBlock(data, 0, dataLength, data, 0);
                    hash2.TransformBlock(data, 0, dataLength, data, 0);

                    SHA1Reuse hash3 = (SHA1Reuse)reuse.Clone();
                    sha1.TransformFinalBlock(data, dataLength, 0);
                    reuse.TransformFinalBlock(data, dataLength, 0);
                    hash0.TransformFinalBlock(data, dataLength, 0);
                    hash1.TransformFinalBlock(data, dataLength, 0);
                    hash2.TransformFinalBlock(data, dataLength, 0);
                    hash3.TransformFinalBlock(data, dataLength, 0);

                    Assert.IsTrue(sha1.Hash.SequenceEqual(reuse.Hash));
                    Assert.IsTrue(sha1.Hash.SequenceEqual(hash0.Hash));
                    Assert.IsTrue(sha1.Hash.SequenceEqual(hash1.Hash));
                    Assert.IsTrue(sha1.Hash.SequenceEqual(hash2.Hash));
                    Assert.IsTrue(sha1.Hash.SequenceEqual(hash3.Hash));
                }
        }
Beispiel #11
0
        public void ComputeBlocksWithBlockSize([Values(1, 1024, 324734)]int dataLength) {
            byte[] data = new byte[dataLength];

            using (SHA1Managed sha1 = new SHA1Managed())
            using (SHA1Reuse reuse = new SHA1Reuse()) {
                for (int i = 0; i < 10; ++i) {
                    sha1.TransformBlock(data, 0, dataLength, data, 0);
                    reuse.TransformBlock(data, 0, dataLength, data, 0);
                }

                sha1.TransformFinalBlock(data, dataLength, 0);
                reuse.TransformFinalBlock(data, dataLength, 0);
                Assert.IsTrue(sha1.Hash.SequenceEqual(reuse.Hash));
            }
        }
Beispiel #12
0
        public void ComputeBlocksViaClone() {
            int dataLength = 23;
            byte[] data = new byte[dataLength];

            using (SHA1Managed sha1 = new SHA1Managed())
            using (SHA1Managed sha1_1 = new SHA1Managed())
            using (SHA1Reuse reuse = new SHA1Reuse())
            using (SHA1Reuse hash0 = (SHA1Reuse)reuse.Clone()) {
                for (int i = 0; i < 100; i++) {
                    sha1.TransformBlock(data, 0, dataLength, data, 0);
                    sha1_1.TransformBlock(data, 0, dataLength, data, 0);
                    reuse.TransformBlock(data, 0, dataLength, data, 0);
                    hash0.TransformBlock(data, 0, dataLength, data, 0);
                }

                using(var hash1 = hash0.Clone() as HashAlgorithm)
                using(var hash2 = hash0.Clone() as HashAlgorithm)
                using(var hash3 = hash0.Clone() as HashAlgorithm) {
                    sha1.TransformFinalBlock(data, dataLength, 0);
                    reuse.TransformFinalBlock(data, dataLength, 0);
                    hash0.TransformFinalBlock(data, dataLength, 0);
                    Assert.That(sha1.Hash, Is.EqualTo(reuse.Hash));
                    Assert.That(sha1.Hash, Is.EqualTo(hash0.Hash));

                    for (int i = 0; i < 100; i++) {
                        sha1_1.TransformBlock(data, 0, dataLength, data, 0);
                        hash1.TransformBlock(data, 0, dataLength, data, 0);
                        hash2.TransformBlock(data, 0, dataLength, data, 0);
                        hash3.TransformBlock(data, 0, dataLength, data, 0);
                    }

                    hash1.TransformFinalBlock(data, dataLength, 0);
                    hash2.TransformFinalBlock(data, dataLength, 0);
                    hash3.TransformFinalBlock(data, dataLength, 0);
                    sha1_1.TransformFinalBlock(data, dataLength, 0);
                    Assert.That(sha1_1.Hash, Is.EqualTo(hash1.Hash));
                    Assert.That(sha1_1.Hash, Is.EqualTo(hash2.Hash));
                    Assert.That(sha1_1.Hash, Is.EqualTo(hash3.Hash));
                }
           }
        }
Beispiel #13
0
        public void ComputeBlocksViaReuse() {
            int dataLength = 23;
            byte[] data = new byte[dataLength];

            using (SHA1Managed sha1 = new SHA1Managed())
            using (SHA1Reuse reuse = new SHA1Reuse()) {
                SHA1Reuse hash0 = (SHA1Reuse)reuse.Clone();
                sha1.TransformBlock(data, 0, dataLength, data, 0);
                reuse.TransformBlock(data, 0, dataLength, data, 0);
                hash0.TransformBlock(data, 0, dataLength, data, 0);

                SHA1Reuse hash1 = (SHA1Reuse)reuse.Clone();
                sha1.TransformBlock(data, 0, dataLength, data, 0);
                reuse.TransformBlock(data, 0, dataLength, data, 0);
                hash0.TransformBlock(data, 0, dataLength, data, 0);
                hash1.TransformBlock(data, 0, dataLength, data, 0);

                SHA1Reuse hash2 = (SHA1Reuse)reuse.Clone();
                sha1.TransformBlock(data, 0, dataLength, data, 0);
                reuse.TransformBlock(data, 0, dataLength, data, 0);
                hash0.TransformBlock(data, 0, dataLength, data, 0);
                hash1.TransformBlock(data, 0, dataLength, data, 0);
                hash2.TransformBlock(data, 0, dataLength, data, 0);

                SHA1Reuse hash3 = (SHA1Reuse)reuse.Clone();
                sha1.TransformFinalBlock(data, dataLength, 0);
                reuse.TransformFinalBlock(data, dataLength, 0);
                hash0.TransformFinalBlock(data, dataLength, 0);
                hash1.TransformFinalBlock(data, dataLength, 0);
                hash2.TransformFinalBlock(data, dataLength, 0);
                hash3.TransformFinalBlock(data, dataLength, 0);

                Assert.IsTrue(sha1.Hash.SequenceEqual(reuse.Hash));
                Assert.IsTrue(sha1.Hash.SequenceEqual(hash0.Hash));
                Assert.IsTrue(sha1.Hash.SequenceEqual(hash1.Hash));
                Assert.IsTrue(sha1.Hash.SequenceEqual(hash2.Hash));
                Assert.IsTrue(sha1.Hash.SequenceEqual(hash3.Hash));
            }
        }
        /// <summary>
        /// Uploads the file content to the remote document.
        /// </summary>
        /// <returns>The SHA-1 hash of the uploaded file content.</returns>
        /// <param name="localFile">Local file.</param>
        /// <param name="doc">Remote document.</param>
        /// <param name="transmissionManager">Transmission manager.</param>
        /// <param name="transmissionEvent">File Transmission event.</param>
        /// <param name="mappedObject">Mapped object saved in <c>Storage</c></param>
        protected byte[] UploadFileWithPWC(IFileInfo localFile, ref IDocument doc, Transmission transmission, IMappedObject mappedObject = null) {
            byte[] checksum = null;
            var docPWC = this.LoadRemotePWCDocument(doc, ref checksum);

            using (var file = localFile.Open(FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete)) {
                if (checksum != null) {
                    // check PWC checksum for integration
                    using (var hashAlg = new SHA1Managed()) {
                        int bufsize = 8 * 1024;
                        byte[] buffer = new byte[bufsize];
                        for (long offset = 0; offset < docPWC.ContentStreamLength.GetValueOrDefault();) {
                            int readsize = bufsize;
                            if (readsize + offset > docPWC.ContentStreamLength.GetValueOrDefault()) {
                                readsize = (int)(docPWC.ContentStreamLength.GetValueOrDefault() - offset);
                            }

                            readsize = file.Read(buffer, 0, readsize);
                            hashAlg.TransformBlock(buffer, 0, readsize, buffer, 0);
                            offset += readsize;
                            if (readsize == 0) {
                                break;
                            }
                        }

                        hashAlg.TransformFinalBlock(new byte[0], 0, 0);
                        if (!hashAlg.Hash.SequenceEqual(checksum)) {
                            docPWC.DeleteContentStream();
                        }

                        file.Seek(0, SeekOrigin.Begin);
                    }
                }

                byte[] hash = null;
                var uploader = FileTransmission.ContentTaskUtils.CreateUploader(this.TransmissionStorage.ChunkSize);
                using (var hashAlg = new SHA1Reuse()) {
                    try {
                        using (var hashstream = new NonClosingHashStream(file, hashAlg, CryptoStreamMode.Read)) {
                            int bufsize = 8 * 1024;
                            byte[] buffer = new byte[bufsize];
                            for (long offset = 0; offset < docPWC.ContentStreamLength.GetValueOrDefault();) {
                                int readsize = bufsize;
                                if (readsize + offset > docPWC.ContentStreamLength.GetValueOrDefault()) {
                                    readsize = (int)(docPWC.ContentStreamLength.GetValueOrDefault() - offset);
                                }

                                readsize = hashstream.Read(buffer, 0, readsize);
                                offset += readsize;
                                if (readsize == 0) {
                                    break;
                                }
                            }
                        }

                        var document = doc;
                        uploader.UploadFile(docPWC, file, transmission, hashAlg, false, (byte[] checksumUpdate, long length) => this.SaveRemotePWCDocument(localFile, document, docPWC, checksumUpdate, transmission));
                        hash = hashAlg.Hash;
                    } catch (Exception ex) {
                        transmission.FailedException = ex;
                        throw;
                    }
                }

                this.TransmissionStorage.RemoveObjectByRemoteObjectId(doc.Id);

                var properties = new Dictionary<string, object>();
                properties.Add(PropertyIds.LastModificationDate, localFile.LastWriteTimeUtc);
                doc = this.Session.GetObject(docPWC.CheckIn(true, properties, null, string.Empty)) as IDocument;

                // Refresh is required, or DotCMIS will use cached one only
                doc.Refresh();

                transmission.Status = TransmissionStatus.FINISHED;
                return hash;
            }
        }
        protected byte[] DownloadCacheFile(IFileInfo target, IDocument remoteDocument, Transmission transmission, IFileSystemInfoFactory fsFactory) {
            if (!this.LoadCacheFile(target, remoteDocument, fsFactory)) {
                if (target.Exists) {
                    target.Delete();
                }
            }

            using (var hashAlg = new SHA1Reuse()) {
                using (var filestream = target.Open(FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None))
                using (var downloader = ContentTaskUtils.CreateDownloader()) {
                    try {
                        downloader.DownloadFile(remoteDocument, filestream, transmission, hashAlg, (byte[] checksumUpdate, long length) => this.SaveCacheFile(target, remoteDocument, checksumUpdate, length, transmission));
                        if (this.TransmissionStorage != null) {
                            this.TransmissionStorage.RemoveObjectByRemoteObjectId(remoteDocument.Id);
                        }
                    } catch (Exception ex) {
                        transmission.FailedException = ex;
                        throw;
                    }
                }

                target.Refresh();
                return hashAlg.Hash;
            }
        }
        /// <summary>
        /// Uploads the file content to the remote document.
        /// </summary>
        /// <returns>The SHA-1 hash of the uploaded file content.</returns>
        /// <param name="localFile">Local file.</param>
        /// <param name="doc">Remote document.</param>
        /// <param name="transmissionManager">Transmission manager.</param>
        /// <param name="transmissionEvent">File Transmission event.</param>
        /// <param name="mappedObject">Mapped object saved in <c>Storage</c></param>
        protected byte[] UploadFileWithPWC(IFileInfo localFile, ref IDocument doc, Transmission transmission, IMappedObject mappedObject = null)
        {
            byte[] checksum = null;
            var    docPWC   = this.LoadRemotePWCDocument(doc, ref checksum);

            using (var file = localFile.Open(FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete)) {
                if (checksum != null)
                {
                    // check PWC checksum for integration
                    using (var hashAlg = new SHA1Managed()) {
                        int    bufsize = 8 * 1024;
                        byte[] buffer  = new byte[bufsize];
                        for (long offset = 0; offset < docPWC.ContentStreamLength.GetValueOrDefault();)
                        {
                            int readsize = bufsize;
                            if (readsize + offset > docPWC.ContentStreamLength.GetValueOrDefault())
                            {
                                readsize = (int)(docPWC.ContentStreamLength.GetValueOrDefault() - offset);
                            }

                            readsize = file.Read(buffer, 0, readsize);
                            hashAlg.TransformBlock(buffer, 0, readsize, buffer, 0);
                            offset += readsize;
                            if (readsize == 0)
                            {
                                break;
                            }
                        }

                        hashAlg.TransformFinalBlock(new byte[0], 0, 0);
                        if (!hashAlg.Hash.SequenceEqual(checksum))
                        {
                            docPWC.DeleteContentStream();
                        }

                        file.Seek(0, SeekOrigin.Begin);
                    }
                }

                byte[] hash     = null;
                var    uploader = FileTransmission.ContentTaskUtils.CreateUploader(this.TransmissionStorage.ChunkSize);
                using (var hashAlg = new SHA1Reuse()) {
                    try {
                        using (var hashstream = new NonClosingHashStream(file, hashAlg, CryptoStreamMode.Read)) {
                            int    bufsize = 8 * 1024;
                            byte[] buffer  = new byte[bufsize];
                            for (long offset = 0; offset < docPWC.ContentStreamLength.GetValueOrDefault();)
                            {
                                int readsize = bufsize;
                                if (readsize + offset > docPWC.ContentStreamLength.GetValueOrDefault())
                                {
                                    readsize = (int)(docPWC.ContentStreamLength.GetValueOrDefault() - offset);
                                }

                                readsize = hashstream.Read(buffer, 0, readsize);
                                offset  += readsize;
                                if (readsize == 0)
                                {
                                    break;
                                }
                            }
                        }

                        var document = doc;
                        uploader.UploadFile(docPWC, file, transmission, hashAlg, false, (byte[] checksumUpdate, long length) => this.SaveRemotePWCDocument(localFile, document, docPWC, checksumUpdate, transmission));
                        hash = hashAlg.Hash;
                    } catch (Exception ex) {
                        transmission.FailedException = ex;
                        throw;
                    }
                }

                this.TransmissionStorage.RemoveObjectByRemoteObjectId(doc.Id);

                var properties = new Dictionary <string, object>();
                properties.Add(PropertyIds.LastModificationDate, localFile.LastWriteTimeUtc);
                doc = this.Session.GetObject(docPWC.CheckIn(true, properties, null, string.Empty)) as IDocument;

                // Refresh is required, or DotCMIS will use cached one only
                doc.Refresh();

                transmission.Status = TransmissionStatus.FINISHED;
                return(hash);
            }
        }