Send APIs (#979)

* send work

* fix sql proj file

* update

* updates

* access id

* delete job

* fix delete job

* local send storage

* update sprocs for null checks

src/Core/Enums/SendType.cs

@@ -0,0 +1,8 @@
+namespace Bit.Core.Enums
+{
+    public enum SendType : byte
+    {
+        Text = 0,
+        File = 1
+    }
+}

src/Core/GlobalSettings.cs

@@ -29,7 +29,8 @@ namespace Bit.Core
         public virtual ConnectionStringSettings Storage { get; set; } = new ConnectionStringSettings();
         public virtual ConnectionStringSettings Events { get; set; } = new ConnectionStringSettings();
         public virtual NotificationsSettings Notifications { get; set; } = new NotificationsSettings();
-        public virtual AttachmentSettings Attachment { get; set; } = new AttachmentSettings();
+        public virtual FileStorageSettings Attachment { get; set; } = new FileStorageSettings();
+        public virtual FileStorageSettings Send { get; set; } = new FileStorageSettings();
         public virtual IdentityServerSettings IdentityServer { get; set; } = new IdentityServerSettings();
         public virtual DataProtectionSettings DataProtection { get; set; } = new DataProtectionSettings();
         public virtual DocumentDbSettings DocumentDb { get; set; } = new DocumentDbSettings();
@@ -101,7 +102,7 @@ namespace Bit.Core
             }
         }
 
-        public class AttachmentSettings
+        public class FileStorageSettings
         {
             private string _connectionString;
 

src/Core/Models/Api/Request/SendAccessRequestModel.cs

@@ -0,0 +1,10 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Bit.Core.Models.Api
+{
+    public class SendAccessRequestModel
+    {
+        [StringLength(300)]
+        public string Password { get; set; }
+    }
+}

src/Core/Models/Api/Request/SendRequestModel.cs

@@ -0,0 +1,94 @@
+using System;
+using Bit.Core.Utilities;
+using Bit.Core.Models.Table;
+using Bit.Core.Enums;
+using Newtonsoft.Json;
+using Bit.Core.Models.Data;
+using System.ComponentModel.DataAnnotations;
+using Bit.Core.Services;
+
+namespace Bit.Core.Models.Api
+{
+    public class SendRequestModel
+    {
+        public SendType Type { get; set; }
+        [EncryptedString]
+        [EncryptedStringLength(1000)]
+        public string Name { get; set; }
+        [EncryptedString]
+        [EncryptedStringLength(1000)]
+        public string Notes { get; set; }
+        [Required]
+        [EncryptedString]
+        [EncryptedStringLength(1000)]
+        public string Key { get; set; }
+        public int? MaxAccessCount { get; set; }
+        public DateTime? ExpirationDate { get; set; }
+        [Required]
+        public DateTime? DeletionDate { get; set; }
+        public SendFileModel File { get; set; }
+        public SendTextModel Text { get; set; }
+        [StringLength(1000)]
+        public string Password { get; set; }
+        [Required]
+        public bool? Disabled { get; set; }
+
+        public Send ToSend(Guid userId, ISendService sendService)
+        {
+            var send = new Send
+            {
+                Type = Type,
+                UserId = (Guid?)userId
+            };
+            ToSend(send, sendService);
+            return send;
+        }
+
+        public (Send, SendFileData) ToSend(Guid userId, string fileName, ISendService sendService)
+        {
+            var send = ToSendBase(new Send
+            {
+                Type = Type,
+                UserId = (Guid?)userId
+            }, sendService);
+            var data = new SendFileData(this, fileName);
+            return (send, data);
+        }
+
+        public Send ToSend(Send existingSend, ISendService sendService)
+        {
+            existingSend = ToSendBase(existingSend, sendService);
+            switch (existingSend.Type)
+            {
+                case SendType.File:
+                    var fileData = JsonConvert.DeserializeObject<SendFileData>(existingSend.Data);
+                    fileData.Name = Name;
+                    fileData.Notes = Notes;
+                    existingSend.Data = JsonConvert.SerializeObject(fileData,
+                        new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore });
+                    break;
+                case SendType.Text:
+                    existingSend.Data = JsonConvert.SerializeObject(new SendTextData(this),
+                        new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore });
+                    break;
+                default:
+                    throw new ArgumentException("Unsupported type: " + nameof(Type) + ".");
+            }
+            return existingSend;
+        }
+
+        private Send ToSendBase(Send existingSend, ISendService sendService)
+        {
+            existingSend.Key = Key;
+            existingSend.ExpirationDate = ExpirationDate;
+            existingSend.DeletionDate = DeletionDate.Value;
+            existingSend.MaxAccessCount = MaxAccessCount;
+            if (!string.IsNullOrWhiteSpace(Password))
+            {
+                existingSend.Password = sendService.HashPassword(Password);
+            }
+            existingSend.Disabled = Disabled.GetValueOrDefault();
+            return existingSend;
+        }
+    }
+}

src/Core/Models/Api/Response/SendAccessResponseModel.cs

@@ -0,0 +1,49 @@
+using System;
+using Bit.Core.Enums;
+using Bit.Core.Models.Data;
+using Bit.Core.Models.Table;
+using Bit.Core.Utilities;
+using Newtonsoft.Json;
+
+namespace Bit.Core.Models.Api
+{
+    public class SendAccessResponseModel : ResponseModel
+    {
+        public SendAccessResponseModel(Send send, GlobalSettings globalSettings)
+            : base("send-access")
+        {
+            if (send == null)
+            {
+                throw new ArgumentNullException(nameof(send));
+            }
+
+            Id = CoreHelpers.Base64UrlEncode(send.Id.ToByteArray());
+            Type = send.Type;
+
+            SendData sendData;
+            switch (send.Type)
+            {
+                case SendType.File:
+                    var fileData = JsonConvert.DeserializeObject<SendFileData>(send.Data);
+                    sendData = fileData;
+                    File = new SendFileModel(fileData, globalSettings);
+                    break;
+                case SendType.Text:
+                    var textData = JsonConvert.DeserializeObject<SendTextData>(send.Data);
+                    sendData = textData;
+                    Text = new SendTextModel(textData);
+                    break;
+                default:
+                    throw new ArgumentException("Unsupported " + nameof(Type) + ".");
+            }
+
+            Name = sendData.Name;
+        }
+
+        public string Id { get; set; }
+        public SendType Type { get; set; }
+        public string Name { get; set; }
+        public SendFileModel File { get; set; }
+        public SendTextModel Text { get; set; }
+    }
+}

src/Core/Models/Api/Response/SendResponseModel.cs

@@ -0,0 +1,69 @@
+using System;
+using Bit.Core.Enums;
+using Bit.Core.Models.Data;
+using Bit.Core.Models.Table;
+using Bit.Core.Utilities;
+using Newtonsoft.Json;
+
+namespace Bit.Core.Models.Api
+{
+    public class SendResponseModel : ResponseModel
+    {
+        public SendResponseModel(Send send, GlobalSettings globalSettings)
+            : base("send")
+        {
+            if (send == null)
+            {
+                throw new ArgumentNullException(nameof(send));
+            }
+
+            Id = send.Id.ToString();
+            AccessId = CoreHelpers.Base64UrlEncode(send.Id.ToByteArray());
+            Type = send.Type;
+            Key = send.Key;
+            MaxAccessCount = send.MaxAccessCount;
+            AccessCount = send.AccessCount;
+            RevisionDate = send.RevisionDate;
+            ExpirationDate = send.ExpirationDate;
+            DeletionDate = send.DeletionDate;
+            Password = send.Password;
+            Disabled = send.Disabled;
+
+            SendData sendData;
+            switch (send.Type)
+            {
+                case SendType.File:
+                    var fileData = JsonConvert.DeserializeObject<SendFileData>(send.Data);
+                    sendData = fileData;
+                    File = new SendFileModel(fileData, globalSettings);
+                    break;
+                case SendType.Text:
+                    var textData = JsonConvert.DeserializeObject<SendTextData>(send.Data);
+                    sendData = textData;
+                    Text = new SendTextModel(textData);
+                    break;
+                default:
+                    throw new ArgumentException("Unsupported " + nameof(Type) + ".");
+            }
+
+            Name = sendData.Name;
+            Notes = sendData.Notes;
+        }
+
+        public string Id { get; set; }
+        public string AccessId { get; set; }
+        public SendType Type { get; set; }
+        public string Name { get; set; }
+        public string Notes { get; set; }
+        public SendFileModel File { get; set; }
+        public SendTextModel Text { get; set; }
+        public string Key { get; set; }
+        public int? MaxAccessCount { get; set; }
+        public int AccessCount { get; set; }
+        public string Password { get; set; }
+        public bool Disabled { get; set; }
+        public DateTime RevisionDate { get; set; }
+        public DateTime? ExpirationDate { get; set; }
+        public DateTime DeletionDate { get; set; }
+    }
+}

src/Core/Models/Api/SendFileModel.cs

@@ -0,0 +1,27 @@
+using Bit.Core.Models.Data;
+using Bit.Core.Utilities;
+
+namespace Bit.Core.Models.Api
+{
+    public class SendFileModel
+    {
+        public SendFileModel() { }
+
+        public SendFileModel(SendFileData data, GlobalSettings globalSettings)
+        {
+            Id = data.Id;
+            Url = $"{globalSettings.Send.BaseUrl}/{data.Id}";
+            FileName = data.FileName;
+            Size = data.SizeString;
+            SizeName = CoreHelpers.ReadableBytesSize(data.Size);
+        }
+
+        public string Id { get; set; }
+        public string Url { get; set; }
+        [EncryptedString]
+        [EncryptedStringLength(1000)]
+        public string FileName { get; set; }
+        public string Size { get; set; }
+        public string SizeName { get; set; }
+    }
+}

src/Core/Models/Api/SendTextModel.cs

@@ -0,0 +1,21 @@
+using Bit.Core.Models.Data;
+using Bit.Core.Utilities;
+
+namespace Bit.Core.Models.Api
+{
+    public class SendTextModel
+    {
+        public SendTextModel() { }
+
+        public SendTextModel(SendTextData data)
+        {
+            Text = data.Text;
+            Hidden = data.Hidden;
+        }
+
+        [EncryptedString]
+        [EncryptedStringLength(1000)]
+        public string Text { get; set; }
+        public bool Hidden { get; set; }
+    }
+}

src/Core/Models/Data/SendData.cs

@@ -0,0 +1,18 @@
+using Bit.Core.Models.Api;
+
+namespace Bit.Core.Models.Data
+{
+    public abstract class SendData
+    {
+        public SendData() { }
+
+        public SendData(SendRequestModel send)
+        {
+            Name = send.Name;
+            Notes = send.Notes;
+        }
+
+        public string Name { get; set; }
+        public string Notes { get; set; }
+    }
+}

src/Core/Models/Data/SendFileData.cs

@@ -0,0 +1,37 @@
+using System;
+using Bit.Core.Models.Api;
+using Newtonsoft.Json;
+
+namespace Bit.Core.Models.Data
+{
+    public class SendFileData : SendData
+    {
+        private long _size;
+
+        public SendFileData() { }
+
+        public SendFileData(SendRequestModel send, string fileName)
+            : base(send)
+        {
+            FileName = fileName;
+        }
+
+        [JsonIgnore]
+        public long Size
+        {
+            get { return _size; }
+            set { _size = value; }
+        }
+
+        // We serialize Size as a string since JSON (or Javascript) doesn't support full precision for long numbers
+        [JsonProperty("Size")]
+        public string SizeString
+        {
+            get { return _size.ToString(); }
+            set { _size = Convert.ToInt64(value); }
+        }
+
+        public string Id { get; set; }
+        public string FileName { get; set; }
+    }
+}

src/Core/Models/Data/SendTextData.cs

@@ -0,0 +1,19 @@
+using Bit.Core.Models.Api;
+
+namespace Bit.Core.Models.Data
+{
+    public class SendTextData : SendData
+    {
+        public SendTextData() { }
+
+        public SendTextData(SendRequestModel send)
+            : base(send)
+        {
+            Text = send.Text.Text;
+            Hidden = send.Text.Hidden;
+        }
+
+        public string Text { get; set; }
+        public bool Hidden { get; set; }
+    }
+}

src/Core/Models/Table/Send.cs

@@ -0,0 +1,29 @@
+using System;
+using Bit.Core.Enums;
+using Bit.Core.Utilities;
+
+namespace Bit.Core.Models.Table
+{
+    public class Send : ITableObject<Guid>
+    {
+        public Guid Id { get; set; }
+        public Guid? UserId { get; set; }
+        public Guid? OrganizationId { get; set; }
+        public SendType Type { get; set; }
+        public string Data { get; set; }
+        public string Key { get; set; }
+        public string Password { get; set; }
+        public int? MaxAccessCount { get; set; }
+        public int AccessCount { get; set; }
+        public DateTime CreationDate { get; internal set; } = DateTime.UtcNow;
+        public DateTime RevisionDate { get; internal set; } = DateTime.UtcNow;
+        public DateTime? ExpirationDate { get; set; }
+        public DateTime DeletionDate { get; set; }
+        public bool Disabled { get; set; }
+
+        public void SetNewId()
+        {
+            Id = CoreHelpers.GenerateComb();
+        }
+    }
+}

src/Core/Repositories/ISendRepository.cs

@@ -0,0 +1,13 @@
+using System;
+using Bit.Core.Models.Table;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+
+namespace Bit.Core.Repositories
+{
+    public interface ISendRepository : IRepository<Send, Guid>
+    {
+        Task<ICollection<Send>> GetManyByUserIdAsync(Guid userId);
+        Task<ICollection<Send>> GetManyByDeletionDateAsync(DateTime deletionDateBefore);
+    }
+}

src/Core/Repositories/SqlServer/SendRepository.cs

@@ -0,0 +1,48 @@
+using System;
+using Bit.Core.Models.Table;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+using System.Data;
+using System.Data.SqlClient;
+using Dapper;
+using System.Linq;
+
+namespace Bit.Core.Repositories.SqlServer
+{
+    public class SendRepository : Repository<Send, Guid>, ISendRepository
+    {
+        public SendRepository(GlobalSettings globalSettings)
+            : this(globalSettings.SqlServer.ConnectionString, globalSettings.SqlServer.ReadOnlyConnectionString)
+        { }
+
+        public SendRepository(string connectionString, string readOnlyConnectionString)
+            : base(connectionString, readOnlyConnectionString)
+        { }
+
+        public async Task<ICollection<Send>> GetManyByUserIdAsync(Guid userId)
+        {
+            using (var connection = new SqlConnection(ConnectionString))
+            {
+                var results = await connection.QueryAsync<Send>(
+                    $"[{Schema}].[Send_ReadByUserId]",
+                    new { UserId = userId },
+                    commandType: CommandType.StoredProcedure);
+
+                return results.ToList();
+            }
+        }
+
+        public async Task<ICollection<Send>> GetManyByDeletionDateAsync(DateTime deletionDateBefore)
+        {
+            using (var connection = new SqlConnection(ConnectionString))
+            {
+                var results = await connection.QueryAsync<Send>(
+                    $"[{Schema}].[Send_ReadByDeletionDateBefore]",
+                    new { DeletionDate = deletionDateBefore },
+                    commandType: CommandType.StoredProcedure);
+
+                return results.ToList();
+            }
+        }
+    }
+}

src/Core/Services/ISendService.cs

@@ -0,0 +1,17 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using Bit.Core.Models.Data;
+using Bit.Core.Models.Table;
+
+namespace Bit.Core.Services
+{
+    public interface ISendService
+    {
+        Task DeleteSendAsync(Send send);
+        Task SaveSendAsync(Send send);
+        Task CreateSendAsync(Send send, SendFileData data, Stream stream, long requestLength);
+        Task<(Send, bool, bool)> AccessAsync(Guid sendId, string password);
+        string HashPassword(string password);
+    }
+}

src/Core/Services/ISendStorageService.cs

@@ -0,0 +1,15 @@
+using Bit.Core.Models.Table;
+using System;
+using System.IO;
+using System.Threading.Tasks;
+
+namespace Bit.Core.Services
+{
+    public interface ISendFileStorageService
+    {
+        Task UploadNewFileAsync(Stream stream, Send send, string fileId);
+        Task DeleteFileAsync(string fileId);
+        Task DeleteFilesForOrganizationAsync(Guid organizationId);
+        Task DeleteFilesForUserAsync(Guid userId);
+    }
+}

src/Core/Services/Implementations/AzureSendFileStorageService.cs

@@ -0,0 +1,66 @@
+using System.Threading.Tasks;
+using Microsoft.Azure.Storage;
+using Microsoft.Azure.Storage.Blob;
+using System.IO;
+using System;
+using Bit.Core.Models.Table;
+
+namespace Bit.Core.Services
+{
+    public class AzureSendFileStorageService : ISendFileStorageService
+    {
+        private const string FilesContainerName = "sendfiles";
+
+        private readonly CloudBlobClient _blobClient;
+        private CloudBlobContainer _sendFilesContainer;
+
+        public AzureSendFileStorageService(
+            GlobalSettings globalSettings)
+        {
+            var storageAccount = CloudStorageAccount.Parse(globalSettings.Send.ConnectionString);
+            _blobClient = storageAccount.CreateCloudBlobClient();
+        }
+
+        public async Task UploadNewFileAsync(Stream stream, Send send, string fileId)
+        {
+            await InitAsync();
+            var blob = _sendFilesContainer.GetBlockBlobReference(fileId);
+            if (send.UserId.HasValue)
+            {
+                blob.Metadata.Add("userId", send.UserId.Value.ToString());
+            }
+            else
+            {
+                blob.Metadata.Add("organizationId", send.OrganizationId.Value.ToString());
+            }
+            blob.Properties.ContentDisposition = $"attachment; filename=\"{fileId}\"";
+            await blob.UploadFromStreamAsync(stream);
+        }
+
+        public async Task DeleteFileAsync(string fileId)
+        {
+            await InitAsync();
+            var blob = _sendFilesContainer.GetBlockBlobReference(fileId);
+            await blob.DeleteIfExistsAsync();
+        }
+
+        public async Task DeleteFilesForOrganizationAsync(Guid organizationId)
+        {
+            await InitAsync();
+        }
+
+        public async Task DeleteFilesForUserAsync(Guid userId)
+        {
+            await InitAsync();
+        }
+
+        private async Task InitAsync()
+        {
+            if (_sendFilesContainer == null)
+            {
+                _sendFilesContainer = _blobClient.GetContainerReference(FilesContainerName);
+                await _sendFilesContainer.CreateIfNotExistsAsync(BlobContainerPublicAccessType.Blob, null, null);
+            }
+        }
+    }
+}

src/Core/Services/Implementations/LocalSendStorageService.cs

@@ -0,0 +1,62 @@
+using System.Threading.Tasks;
+using System.IO;
+using System;
+using Bit.Core.Models.Table;
+
+namespace Bit.Core.Services
+{
+    public class LocalSendStorageService : ISendFileStorageService
+    {
+        private readonly string _baseDirPath;
+
+        public LocalSendStorageService(
+            GlobalSettings globalSettings)
+        {
+            _baseDirPath = globalSettings.Send.BaseDirectory;
+        }
+
+        public async Task UploadNewFileAsync(Stream stream, Send send, string fileId)
+        {
+            await InitAsync();
+            using (var fs = File.Create($"{_baseDirPath}/{fileId}"))
+            {
+                stream.Seek(0, SeekOrigin.Begin);
+                await stream.CopyToAsync(fs);
+            }
+        }
+
+        public async Task DeleteFileAsync(string fileId)
+        {
+            await InitAsync();
+            DeleteFileIfExists($"{_baseDirPath}/{fileId}");
+        }
+
+        public async Task DeleteFilesForOrganizationAsync(Guid organizationId)
+        {
+            await InitAsync();
+        }
+
+        public async Task DeleteFilesForUserAsync(Guid userId)
+        {
+            await InitAsync();
+        }
+
+        private void DeleteFileIfExists(string path)
+        {
+            if (File.Exists(path))
+            {
+                File.Delete(path);
+            }
+        }
+
+        private Task InitAsync()
+        {
+            if (!Directory.Exists(_baseDirPath))
+            {
+                Directory.CreateDirectory(_baseDirPath);
+            }
+
+            return Task.FromResult(0);
+        }
+    }
+}

src/Core/Services/Implementations/SendService.cs

@@ -0,0 +1,170 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using Bit.Core.Exceptions;
+using Bit.Core.Models.Data;
+using Bit.Core.Models.Table;
+using Bit.Core.Repositories;
+using Microsoft.AspNetCore.Identity;
+using Newtonsoft.Json;
+
+namespace Bit.Core.Services
+{
+    public class SendService : ISendService
+    {
+        private readonly ISendRepository _sendRepository;
+        private readonly IUserRepository _userRepository;
+        private readonly IUserService _userService;
+        private readonly IOrganizationRepository _organizationRepository;
+        private readonly ISendFileStorageService _sendFileStorageService;
+        private readonly IPasswordHasher<User> _passwordHasher;
+        private readonly GlobalSettings _globalSettings;
+
+        public SendService(
+            ISendRepository sendRepository,
+            IUserRepository userRepository,
+            IUserService userService,
+            IOrganizationRepository organizationRepository,
+            ISendFileStorageService sendFileStorageService,
+            IPasswordHasher<User> passwordHasher,
+            GlobalSettings globalSettings)
+        {
+            _sendRepository = sendRepository;
+            _userRepository = userRepository;
+            _userService = userService;
+            _organizationRepository = organizationRepository;
+            _sendFileStorageService = sendFileStorageService;
+            _passwordHasher = passwordHasher;
+            _globalSettings = globalSettings;
+        }
+
+        public async Task SaveSendAsync(Send send)
+        {
+            if (send.Id == default(Guid))
+            {
+                await _sendRepository.CreateAsync(send);
+            }
+            else
+            {
+                send.RevisionDate = DateTime.UtcNow;
+                await _sendRepository.UpsertAsync(send);
+            }
+        }
+
+        public async Task CreateSendAsync(Send send, SendFileData data, Stream stream, long requestLength)
+        {
+            if (send.Type != Enums.SendType.File)
+            {
+                throw new BadRequestException("Send is not of type \"file\".");
+            }
+
+            if (requestLength < 1)
+            {
+                throw new BadRequestException("No file data.");
+            }
+
+            var storageBytesRemaining = 0L;
+            if (send.UserId.HasValue)
+            {
+                var user = await _userRepository.GetByIdAsync(send.UserId.Value);
+                if (!(await _userService.CanAccessPremium(user)))
+                {
+                    throw new BadRequestException("You must have premium status to use file sends.");
+                }
+
+                if (user.Premium)
+                {
+                    storageBytesRemaining = user.StorageBytesRemaining();
+                }
+                else
+                {
+                    // Users that get access to file storage/premium from their organization get the default
+                    // 1 GB max storage.
+                    storageBytesRemaining = user.StorageBytesRemaining(
+                        _globalSettings.SelfHosted ? (short)10240 : (short)1);
+                }
+            }
+            else if (send.OrganizationId.HasValue)
+            {
+                var org = await _organizationRepository.GetByIdAsync(send.OrganizationId.Value);
+                if (!org.MaxStorageGb.HasValue)
+                {
+                    throw new BadRequestException("This organization cannot use file sends.");
+                }
+
+                storageBytesRemaining = org.StorageBytesRemaining();
+            }
+
+            if (storageBytesRemaining < requestLength)
+            {
+                throw new BadRequestException("Not enough storage available.");
+            }
+
+            var fileId = Utilities.CoreHelpers.SecureRandomString(32, upper: false, special: false);
+            await _sendFileStorageService.UploadNewFileAsync(stream, send, fileId);
+
+            try
+            {
+                data.Id = fileId;
+                data.Size = stream.Length;
+                send.Data = JsonConvert.SerializeObject(data,
+                    new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore });
+                await SaveSendAsync(send);
+            }
+            catch
+            {
+                // Clean up since this is not transactional
+                await _sendFileStorageService.DeleteFileAsync(fileId);
+                throw;
+            }
+        }
+
+        public async Task DeleteSendAsync(Send send)
+        {
+            await _sendRepository.DeleteAsync(send);
+            if (send.Type == Enums.SendType.File)
+            {
+                var data = JsonConvert.DeserializeObject<SendFileData>(send.Data);
+                await _sendFileStorageService.DeleteFileAsync(data.Id);
+            }
+        }
+
+        // Response: Send, password required, password invalid
+        public async Task<(Send, bool, bool)> AccessAsync(Guid sendId, string password)
+        {
+            var send = await _sendRepository.GetByIdAsync(sendId);
+            var now = DateTime.UtcNow;
+            if (send == null || send.MaxAccessCount.GetValueOrDefault(int.MaxValue) <= send.AccessCount ||
+                send.ExpirationDate.GetValueOrDefault(DateTime.MaxValue) < now || send.Disabled ||
+                send.DeletionDate < now)
+            {
+                return (null, false, false);
+            }
+            if (!string.IsNullOrWhiteSpace(send.Password))
+            {
+                if (string.IsNullOrWhiteSpace(password))
+                {
+                    return (null, true, false);
+                }
+                var passwordResult = _passwordHasher.VerifyHashedPassword(new User(), send.Password, password);
+                if (passwordResult == PasswordVerificationResult.SuccessRehashNeeded)
+                {
+                    send.Password = HashPassword(password);
+                }
+                if (passwordResult == PasswordVerificationResult.Failed)
+                {
+                    return (null, false, true);
+                }
+            }
+            // TODO: maybe move this to a simple ++ sproc?
+            send.AccessCount++;
+            await _sendRepository.ReplaceAsync(send);
+            return (send, false, false);
+        }
+
+        public string HashPassword(string password)
+        {
+            return _passwordHasher.HashPassword(new User(), password);
+        }
+    }
+}

src/Core/Services/NoopImplementations/NoopSendFileStorageService.cs

@@ -0,0 +1,30 @@
+using System.Threading.Tasks;
+using System.IO;
+using System;
+using Bit.Core.Models.Table;
+
+namespace Bit.Core.Services
+{
+    public class NoopSendFileStorageService : ISendFileStorageService
+    {
+        public Task UploadNewFileAsync(Stream stream, Send send, string attachmentId)
+        {
+            return Task.FromResult(0);
+        }
+
+        public Task DeleteFileAsync(string fileId)
+        {
+            return Task.FromResult(0);
+        }
+
+        public Task DeleteFilesForOrganizationAsync(Guid organizationId)
+        {
+            return Task.FromResult(0);
+        }
+
+        public Task DeleteFilesForUserAsync(Guid userId)
+        {
+            return Task.FromResult(0);
+        }
+    }
+}

src/Core/Utilities/ServiceCollectionExtensions.cs

@@ -78,6 +78,7 @@ namespace Bit.Core.Utilities
                 services.AddSingleton<IPolicyRepository, SqlServerRepos.PolicyRepository>();
                 services.AddSingleton<ISsoConfigRepository, SqlServerRepos.SsoConfigRepository>();
                 services.AddSingleton<ISsoUserRepository, SqlServerRepos.SsoUserRepository>();
+                services.AddSingleton<ISendRepository, SqlServerRepos.SendRepository>();
             }
 
             if (globalSettings.SelfHosted)
@@ -113,6 +114,7 @@ namespace Bit.Core.Utilities
             services.AddSingleton<IDeviceService, DeviceService>();
             services.AddSingleton<IAppleIapService, AppleIapService>();
             services.AddSingleton<ISsoConfigService, SsoConfigService>();
+            services.AddScoped<ISendService, SendService>();
         }
 
         public static void AddDefaultServices(this IServiceCollection services, GlobalSettings globalSettings)
@@ -200,6 +202,19 @@ namespace Bit.Core.Utilities
                 services.AddSingleton<IAttachmentStorageService, NoopAttachmentStorageService>();
             }
 
+            if (CoreHelpers.SettingHasValue(globalSettings.Send.ConnectionString))
+            {
+                services.AddSingleton<ISendFileStorageService, AzureSendFileStorageService>();
+            }
+            else if (CoreHelpers.SettingHasValue(globalSettings.Send.BaseDirectory))
+            {
+                services.AddSingleton<ISendFileStorageService, LocalSendStorageService>();
+            }
+            else
+            {
+                services.AddSingleton<ISendFileStorageService, NoopSendFileStorageService>();
+            }
+
             if (globalSettings.SelfHosted)
             {
                 services.AddSingleton<IReferenceEventService, NoopReferenceEventService>();