protected virtual string DecryptName(string name)
        {
            try
            {
                byte[] bytes = Convert.FromBase64String(name.Replace('-', '/'));
                using (var ms = new MemoryStream(bytes))
                {
                    var header = AesHeader.Read(ms);

                    var aesVersion = header.Version;
                    using (var aes = CreateAes(aesVersion))
                    {
                        var iv  = header.IV;
                        var key = FileSystem.ComputeKey(iv, aesVersion);

                        using (var tranform = aes.CreateDecryptor(key, iv))
                            using (var outputStream = new MemoryStream())
                            {
                                using (var cryptoStream = new CryptoStream(outputStream, tranform, CryptoStreamMode.Write))
                                {
                                    ms.CopyTo(cryptoStream);
                                }

                                return(Encoding.UTF8.GetString(outputStream.ToArray()));
                            }
                    }
                }
            }
            catch
            {
                return(name);
            }
        }
        protected virtual string EncryptName(string name)
        {
            var bytes = Encoding.UTF8.GetBytes(name);

            var aesVersion = FileSystem.Version;

            using (var aes = CreateAes(aesVersion))
            {
                var iv = aes.IV;

                var key = FileSystem.ComputeKey(iv, aesVersion);
                using (var tranform = aes.CreateEncryptor(key, iv))
                {
                    using (var outputStream = new MemoryStream())
                    {
                        var aesHeader = new AesHeader(aesVersion, iv);
                        aesHeader.Write(outputStream);

                        var encryptedBytes = tranform.TransformFinalBlock(bytes, 0, bytes.Length);
                        outputStream.Write(encryptedBytes, 0, encryptedBytes.Length);

                        return(Convert.ToBase64String(outputStream.ToArray()).Replace('/', '-'));
                    }
                }
            }
        }
Example #3
0
        public async Task <IFileInfo> CreateFileAsync(string name, Stream stream, long length, CancellationToken ct)
        {
            if (FileSystem.EncryptFileName)
            {
                name = EncryptName(name);
            }

            using (var aes = CreateAes(FileSystem.Version))
            {
                using (var headerStream = new MemoryStream())
                {
                    var aesHeader = new AesHeader(FileSystem.Version, aes.IV);
                    aesHeader.Write(headerStream);
                    headerStream.Seek(0, SeekOrigin.Begin);

                    var key = FileSystem.ComputeKey(aes.IV, FileSystem.Version);
                    ICryptoTransform encryptor = CreateTransform(aes, key, aes.IV, AesMode.Encrypt);
                    using (var cryptoStream = new CryptoStream(stream, encryptor, CryptoStreamMode.Read))
                        using (var concat = new StreamEnumerator(new Stream[] { headerStream, cryptoStream }, true))
                        {
                            var fileInfo = await _directoryInfo.CreateFileAsync(name, concat, length, ct).ConfigureAwait(false);

                            return(new AesFileInfo(FileSystem, fileInfo));
                        }
                }
            }
        }
        public async Task <Stream> OpenReadAsync(CancellationToken ct)
        {
            Stream stream = null;

            System.Security.Cryptography.Aes aes = null;
            ICryptoTransform decryptor           = null;

            try
            {
                stream = await _fileInfo.OpenReadAsync(ct);

                var header = await AesHeader.ReadAsync(stream, ct);

                aes = CreateAes(header.Version);
                var key = FileSystem.ComputeKey(header.IV, header.Version);
                decryptor = CreateTransform(aes, key, header.IV, AesMode.Decrypt); // disposed by CryptoStream
                return(new CryptoStream(stream, decryptor, CryptoStreamMode.Read));
            }
            catch
            {
                decryptor?.Dispose();
                stream?.Dispose();
                throw;
            }
            finally
            {
                aes?.Dispose();
            }
        }
Example #5
0
        public static AesHeader Read(Stream stream)
        {
            var versionByte = new byte[sizeof(AesVersion)];
            var iv          = new byte[16];

            stream.Read(versionByte, 0, versionByte.Length);
            stream.Read(iv, 0, iv.Length);

            var header = new AesHeader();

            header.Version = (AesVersion)versionByte[0];
            header.IV      = iv;
            return(header);
        }
Example #6
0
        public static async Task <AesHeader> ReadAsync(Stream stream, CancellationToken ct)
        {
            var versionByte = new byte[sizeof(AesVersion)];
            var iv          = new byte[16];

            await stream.ReadAsync(versionByte.AsMemory(), ct).ConfigureAwait(false);

            await stream.ReadAsync(iv.AsMemory(), ct).ConfigureAwait(false);

            var header = new AesHeader();

            header.Version = (AesVersion)versionByte[0];
            header.IV      = iv;
            return(header);
        }