Switch to using SFTP instead of FTP for downloading vouchers.

BulkPrintingAPI/BulkPrintingAPI.csproj

     <Folder Include="wwwroot\" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="CoreFtp" Version="1.3.5" />
     <PackageReference Include="Microsoft.ApplicationInsights.AspNetCore" Version="2.0.0" />
     <PackageReference Include="Microsoft.AspNetCore" Version="1.1.2" />
     <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="1.1.2" />
     <PackageReference Include="Microsoft.Extensions.Logging.Debug" Version="1.1.2" />
     <PackageReference Include="Microsoft.VisualStudio.Web.BrowserLink" Version="1.1.2" />
     <PackageReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="1.1.1" />
+    <PackageReference Include="SSH.NET" Version="2016.0.0" />
   </ItemGroup>
   <ItemGroup>
     <DotNetCliToolReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Tools" Version="1.0.1" />

BulkPrintingAPI/Configuration/FTPOptions.cs

 
 namespace BulkPrintingAPI.Configuration
 {
-    public class FTPOptions
+    public class SFTPOptions
     {
-        public FTPOptions(IConfiguration configuration)
+        public SFTPOptions(IConfiguration configuration)
         {
             configuration.Bind(this);
         }
 
         public string Host { get; set; }
 
+        public int Port { get; set; } = 22;
+
         public string Username { get; set; }
 
         public string Password { get; set; }
+
+        public int ConnectTimeout { get; set; } = 10;
     }
 }

BulkPrintingAPI/Controllers/BatchesController.cs

         private readonly ILogger _logger;
         private readonly IMemoryCache _cache;
         private readonly DataEncryptionOptions _dataEncryptionOptions;
-        private readonly FTPOptions _ftpOptions;
+        private readonly SFTPOptions _sftpOptions;
         private readonly MAX.ClientFactory _clientFactory;
         private readonly MAXContext _context;
 
         public BatchesController(ILoggerFactory loggerFactory, IMemoryCache cache,
-            DataEncryptionOptions dataEncryptionOptions, FTPOptions ftpOptions,
+            DataEncryptionOptions dataEncryptionOptions, SFTPOptions sftpOptions,
             MAX.ClientFactory clientFactory, MAXContext context)
         {
             _logger = loggerFactory.CreateLogger(GetType().FullName);
             _cache = cache;
             _dataEncryptionOptions = dataEncryptionOptions;
-            _ftpOptions = ftpOptions;
+            _sftpOptions = sftpOptions;
             _clientFactory = clientFactory;
             _context = context;
         }
 
             if (!batch.ReadyForDownload)
             {
-                await Utils.DownloadVouchersAsync(_ftpOptions, _context, _logger, batch);
+                await Utils.DownloadVouchersAsync(_sftpOptions, _context, _logger, batch);
             }
 
             return Ok(batch);
 
             try
             {
-                await Utils.DownloadVouchersAsync(_ftpOptions, _context, _logger, orderResponse.Batch);
+                await Utils.DownloadVouchersAsync(_sftpOptions, _context, _logger, orderResponse.Batch);
             }
             catch (Exception e)
             {

BulkPrintingAPI/Controllers/Utils.cs

 using BulkPrintingAPI.Configuration;
-using CoreFtp;
 using MAX.Models;
 using Microsoft.AspNetCore.Http;
 using Microsoft.EntityFrameworkCore;
             }
         }
 
-        public static async Task DownloadVouchersAsync(FTPOptions ftpOptions, MAXContext context,
+        public static async Task DownloadVouchersAsync(SFTPOptions sftpOptions, MAXContext context,
             ILogger logger, Batch batch)
         {
             var remoteFileName = string.Format("{0}_{1}.dat", batch.Account.Id, batch.Id);
             using (var voucherStream = new MemoryStream())
             {
-                using (var ftp = new FtpClient(new FtpClientConfiguration()
+                var connectionInfo = new Renci.SshNet.ConnectionInfo(
+                    sftpOptions.Host,
+                    sftpOptions.Port,
+                    sftpOptions.Username,
+                    new Renci.SshNet.PasswordAuthenticationMethod(sftpOptions.Username, sftpOptions.Password)
+                );
+                connectionInfo.Timeout = TimeSpan.FromSeconds(sftpOptions.ConnectTimeout);
+
+                await Task.Run(() =>
                 {
-                    Host = ftpOptions.Host,
-                    Username = ftpOptions.Username,
-                    Password = ftpOptions.Password
-                }))
-                {
-                    await ftp.LoginAsync().ConfigureAwait(false);
-                    using (var downloadStream = await ftp.OpenFileReadStreamAsync(remoteFileName)
-                        .ConfigureAwait(false))
+                    using (var sshClient = new Renci.SshNet.SftpClient(connectionInfo))
                     {
-                        await downloadStream.CopyToAsync(voucherStream).ConfigureAwait(false);
+                        sshClient.Connect();
+                        sshClient.DownloadFile(remoteFileName, voucherStream);
                     }
+                });
 
-                    voucherStream.Position = 0;
-                    using (var streamReader = new StreamReader(voucherStream))
+                voucherStream.Position = 0;
+                using (var streamReader = new StreamReader(voucherStream))
+                {
+                    while (streamReader.Peek() >= 0)
                     {
-                        while (streamReader.Peek() >= 0)
+                        var line = streamReader.ReadLine();
+                        var parts = line.Split('|');
+
+                        VoucherSanityCheck(batch, decimal.Parse(parts[4]), int.Parse(parts[5]),
+                            parts[7]);
+
+                        context.Add(new Voucher()
                         {
-                            var line = streamReader.ReadLine();
-                            var parts = line.Split('|');
-
-                            VoucherSanityCheck(batch, decimal.Parse(parts[4]), int.Parse(parts[5]),
-                                parts[7]);
-
-                            context.Add(new Voucher()
-                            {
-                                Id = int.Parse(parts[0]),
-                                ExpiryDate = DateTime.Parse(parts[1]),
-                                Serial = parts[2],
-                                EncryptedPIN = parts[3],
-                                SequenceNumber = int.Parse(parts[6]),
-                                Batch = batch
-                            });
-                        }
+                            Id = int.Parse(parts[0]),
+                            ExpiryDate = DateTime.Parse(parts[1]),
+                            Serial = parts[2],
+                            EncryptedPIN = parts[3],
+                            SequenceNumber = int.Parse(parts[6]),
+                            Batch = batch
+                        });
                     }
+                }
 
-                    batch.ReadyForDownload = true;
-                    await context.SaveChangesAsync().ConfigureAwait(false);
+                batch.ReadyForDownload = true;
+                await context.SaveChangesAsync().ConfigureAwait(false);
 
-                    try
-                    {
-                        await ftp.DeleteFileAsync(remoteFileName).ConfigureAwait(false);
-                    }
-                    catch (Exception e)
+                try
+                {
+                    await Task.Run(() =>
                     {
-                        logger.LogWarning("Failed to delete file on FTP server: {0}: {1}", remoteFileName, e.Message);
-                    }
+                        using (var sshClient = new Renci.SshNet.SftpClient(connectionInfo))
+                        {
+                            sshClient.Connect();
+                            sshClient.DeleteFile(remoteFileName);
+                        }
+                    });
+                }
+                catch (Exception e)
+                {
+                    logger.LogWarning("Failed to delete file on FTP server: {0}: {1}", remoteFileName, e.Message);
                 }
             }
         }

BulkPrintingAPI/Startup.cs

                 Configuration.GetSection("DataEncryption")));
             services.AddSingleton(new MAX.ClientFactory(
                 Configuration.GetSection("MAX")));
-            services.AddSingleton(new FTPOptions(
-                Configuration.GetSection("FTP")));
+            services.AddSingleton(new SFTPOptions(
+                Configuration.GetSection("SFTP")));
             services.AddDbContext<MAX.Models.MAXContext>(
                 options => options.UseSqlServer(
                     Configuration["Database:ConnectionString"],