File to Byte[] Corrupting Files on Upload

I am trying to upload a file using Dropzone and RestSharp, however the files I am uploading keep corrupting, and I am not sure why.

The byte[] seems to be adding proceeding bytes and thus breaking the file.

Here is my code:

View (ignore username bits, I am just posting any data back to the controller for now:

<form action="/Attachments/Submit" enctype="multipart/form-data">
<input type="text" id="Username" name="Username" />
<div id="dZUpload" class="dropzone">
    <div class="dz-default dz-message"></div>
</div>
</form>
<div>
<button type="submit" id="submit-all"> upload </button>
</div>

<script type="text/javascript" src="/Content/Assets/Js/plugins/uploaders/dropzone.js"></script>

<script>
$(document)
    .ready(function() {
        Dropzone.autoDiscover = false;
        //Simple Dropzonejs 
        $("#dZUpload")
            .dropzone({
                url: "/Attachments/Submit",
                addRemoveLinks: true,
                autoProcessQueue: false,
                init: function() {
                    var submitButton = document.querySelector("#submit-all");
                    var myDropzone = this; // closure

                    this.on("sending",
                        function(file, xhr, formData) {
                            formData.append("Username", 
$("#Username").val());

                        });
                            submitButton.addEventListener("click",
                                function () {
                                    console.log("Test");
                                    myDropzone.processQueue(); 
                                });


                }
            });


    });
</script>

Controller:

    public ActionResult Submit(FormCollection form)
    {
        var x = form;

        bool isSavedSuccessfully = false;

        foreach (string fileName in Request.Files)
        {
            HttpPostedFileBase file = Request.Files[fileName];

            byte[] data = null; 
            int fileSizeInBytes = file.ContentLength;
            using (var br = new BinaryReader(file.InputStream))
            {
                data = br.ReadBytes(fileSizeInBytes);
            }

            AttachmentLogic logic = new AttachmentLogic();
            var y = logic.UploadAttachment(data, "FileName", 100000, 1, Path.GetExtension(file.FileName), "Development", DateTime.Now);

            isSavedSuccessfully = true;
        }

        return Redirect("Index");
    }

RestSharp method:

    public object WebRequest<T>(string controller, Dictionary<string, object> parameters, Method apiMethod, string action, string fileName)
    {
        RestClient client = new RestClient(Url + controller + "/");
        client.Authenticator = new NtlmAuthenticator();
        RestRequest request = new RestRequest(action, apiMethod);

        if (parameters != null && parameters.Count > 0)
        {
            foreach (var parameter in parameters)
            {
                if (parameter.Value.GetType() == typeof(byte[]))
                {
                    byte[] bytes = null;

                    BinaryFormatter bf = new BinaryFormatter();
                    using (MemoryStream ms = new MemoryStream())
                    {
                        bf.Serialize(ms, parameter.Value);
                        bytes = ms.ToArray();
                    }

                    request.AddFileBytes(parameter.Key, bytes, fileName);
                }
                else
                {
                    request.AddParameter(parameter.Key, parameter.Value);
                }
            }
        }

        object result = JsonToObject<T>(client.Execute(request).Content);

        return result;
    }

API Controller:

 [ActionName("UploadAttachment")]
    [HttpPost]
    public ApiResponse UploadAttachment()
    {
        try
        {
            AttachmentLogic logic = new AttachmentLogic();
            var httpRequest = HttpContext.Current.Request;
            AttachmentInput input = new AttachmentInput();

            var file = httpRequest.Files[0];
            input.FileName = httpRequest.Params["FileName"];
            input.FileExtension = httpRequest.Params["Extension"];
            input.Id = int.Parse(httpRequest.Params["Id"]);
            input.FileTypeId = int.Parse(httpRequest.Params["FileTypeId"]);
            input.EntityType = httpRequest.Params["EntityType"];
            input.DateFrom = DateTime.Parse(httpRequest.Params["DateFrom"]);

            int fileSizeInBytes = file.ContentLength;
            using (var br = new BinaryReader(file.InputStream))
            {
                input.File = br.ReadBytes(fileSizeInBytes);
            }

            var data = logic.UploadAttachment(input);

            return ApiResponse.Return(null);
        }
        catch (Exception ex)
        {
            return ApiResponse.Error(ex);
        }
    }

Save Logic:

    public UpdateSuccess UploadAttachment(AttachmentInput input)
    {
        UpdateSuccess response = new UpdateSuccess();

        string fileSaveLocation = AttachmentLocationResolver(input.Id, (EntityType) Enum.Parse(typeof(EntityType), input.EntityType));
        var filePath = fileSaveLocation + input.FileName + input.FileExtension;
        File.WriteAllBytes(filePath, input.File);

        return response;
    }

It's very strange, I am testing this with pngs, which seem to add 27 bytes to the beginning of the file.

Sql files, which does all sorts of weird stuff, include add a space between each char.

Xlsx files, which are recoverable by Excel.

Any idea's where I may be going wrong?

Thanks, Dan