Web.cs

using System;
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Reflection;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;

namespace SamFirm
{
  internal class Web
  {
    public static string JSessionID = string.Empty;
    public static CookieContainer CookieContainer = new CookieContainer();
    public static string EncryptedNonce = string.Empty;
    public static byte[] DecryptedNonce = null;
    public static string Nonce => DecryptedNonce == null ? string.Empty : Encoding.ASCII.GetString(DecryptedNonce);
    public static string Auth = string.Empty;
    public static string AuthHeaderWithNonce => $"FUS nonce=\"{EncryptedNonce}\", signature=\"{Auth}\", nc=\"\", type=\"\", realm=\"\", newauth=\"1\"";
    public static string AuthHeaderNoNonce => $"FUS nonce=\"{EncryptedNonce}\", signature=\"{Auth}\", nc=\"\", type=\"\", realm=\"\", newauth=\"1\"";
    public static Form1 form;

    public static int GenerateNonce()
    {
      HttpWebRequest wr = KiesRequest.Create("https://neofussvr.sslcs.cdngc.net/NF_SmartDownloadGenerateNonce.do");
      wr.Method = "POST";
      string authv = $"FUS nonce=\"\", signature=\"\", nc=\"\", type=\"\", realm=\"\", newauth=\"1\"";
      wr.Headers["Authorization"] = authv;
      wr.ContentLength = 0L;
      using (HttpWebResponse responseFus = (HttpWebResponse)wr.GetResponseFUS())
      {
        if (responseFus == null)
          return 901;
        int statusCode = (int)responseFus.StatusCode;
        return statusCode;
      }
    }

    public static int DownloadBinaryInform(string xml, out string xmlresponse)
    {
      return Web.XMLFUSRequest("https://neofussvr.sslcs.cdngc.net/NF_SmartDownloadBinaryInform.do", xml, out xmlresponse);
    }

    public static int DownloadBinaryInit(string xml, out string xmlresponse)
    {
      return Web.XMLFUSRequest("https://neofussvr.sslcs.cdngc.net/NF_SmartDownloadBinaryInitForMass.do", xml, out xmlresponse);
    }

    private static int XMLFUSRequest(string URL, string xml, out string xmlresponse)
    {
      xmlresponse = (string)null;
      HttpWebRequest wr = KiesRequest.Create(URL);
      wr.Method = "POST";
      wr.Headers["Authorization"] = AuthHeaderNoNonce;
      byte[] bytes = Encoding.ASCII.GetBytes(Regex.Replace(xml, "\\r\\n?|\\n|\\t", string.Empty));
      wr.ContentLength = (long)bytes.Length;
      using (Stream requestStream = wr.GetRequestStream())
        requestStream.Write(bytes, 0, bytes.Length);
      using (HttpWebResponse responseFus = (HttpWebResponse)wr.GetResponseFUS())
      {
        if (responseFus == null)
          return 901;
        if (responseFus.StatusCode == HttpStatusCode.OK)
        {
          try
          {
            xmlresponse = new StreamReader(responseFus.GetResponseStream()).ReadToEnd();
          }
          catch (Exception ex)
          {
            return 900;
          }
        }
        return (int)responseFus.StatusCode;
      }
    }

    public static void SetReconnect()
    {
      if (!Utility.run_by_cmd)
      {
        if (!Web.form.PauseDownload)
          Utility.ReconnectDownload = true;
        Web.form.PauseDownload = true;
      }
      else
        Utility.ReconnectDownload = true;
    }

    public static int DownloadBinary(
      string path,
      string file,
      string saveTo,
      string size,
      bool GUI = true,
      bool decryptInline = false)
    {
      long bytesTransferred = 0;
      HttpWebRequest wr = KiesRequest.Create("http://cloud-neofussvr.samsungmobile.com/NF_SmartDownloadBinaryForMass.do?file=" + path + file);
      wr.Method = "GET";
      wr.Headers["Authorization"] = AuthHeaderWithNonce;
      wr.Timeout = 25000;
      wr.ReadWriteTimeout = 25000;
      string inlineResumeMarker = saveTo + ".resume";
      if (decryptInline)
      {
        bool canResume = System.IO.File.Exists(saveTo) && System.IO.File.Exists(inlineResumeMarker);
        if (canResume)
        {
          long decryptedLength = new FileInfo(saveTo).Length;
          if (decryptedLength % 16 != 0)
          {
            Logger.WriteLog("Inline download state is incomplete. Restarting download...", false);
            System.IO.File.Delete(saveTo);
            System.IO.File.Delete(inlineResumeMarker);
          }
          else
          {
            Logger.WriteLog("Resuming inline download...", false);
            wr.AddRange(decryptedLength);
            bytesTransferred = decryptedLength;
          }
        }
        else
        {
          if (System.IO.File.Exists(saveTo))
            System.IO.File.Delete(saveTo);
          if (System.IO.File.Exists(inlineResumeMarker))
            System.IO.File.Delete(inlineResumeMarker);
        }
      }
      if (!decryptInline && System.IO.File.Exists(saveTo))
      {
        long length = new FileInfo(saveTo).Length;
        if (long.Parse(size) == length)
        {
          Logger.WriteLog("File already downloaded.", false);
          return 200;
        }
        Logger.WriteLog("File exists. Resuming download...", false);
        //wr.AddRange((int) length); // This creates an error, if download continues when file size has exceeded 2 GByte, since AddRange then adds a negative range!
        wr.AddRange(length);  // Fixed using an extension, handling range typed as long
        bytesTransferred = length;
      }
      using (HttpWebResponse responseFus = (HttpWebResponse)wr.GetResponseFUS())
      {
        if (responseFus == null)
        {
          Logger.WriteLog("Error downloading: response is null", false);
          return 901;
        }
        if (responseFus.StatusCode != HttpStatusCode.OK && responseFus.StatusCode != HttpStatusCode.PartialContent)
        {
          Logger.WriteLog("Error downloading: " + (object)(int)responseFus.StatusCode, false);
        }
        else
        {
          // A few CDNs ignore Range. Do not append a full response to a partial package.
          if (decryptInline && bytesTransferred > 0 && responseFus.StatusCode == HttpStatusCode.OK)
          {
            Logger.WriteLog("Server ignored resume request. Restarting inline download...", false);
            bytesTransferred = 0;
            System.IO.File.Delete(saveTo);
            System.IO.File.Delete(inlineResumeMarker);
          }

          long total = long.Parse(responseFus.GetResponseHeader("content-length")) + bytesTransferred;
          if (!System.IO.File.Exists(saveTo) || new FileInfo(saveTo).Length != total)
          {
            byte[] buffer = new byte[256 * 1024];
            Stopwatch sw = new Stopwatch();
            Utility.ResetSpeed(bytesTransferred);
            try
            {
              Utility.PreventDeepSleep(Utility.PDSMode.Start);
              if (decryptInline)
                System.IO.File.WriteAllText(inlineResumeMarker, "inline");
              using (FileStream output = new FileStream(saveTo, FileMode.Append, FileAccess.Write, FileShare.Read))
              using (ICryptoTransform decryptor = decryptInline ? Crypto.CreateDecryptor() : null)
              {
                if (decryptInline && decryptor == null)
                  return 3;
                byte[] pendingCipher = new byte[16];
                int pendingCount = 0;
                byte[] lastPlain = new byte[16];
                bool hasLastPlain = false;
                bool completed = true;
                int count;
                do
                {
                  Utility.PreventDeepSleep(Utility.PDSMode.Continue);
                    if (GUI)
                    {
                    if (Web.form.PauseDownload)
                    {
                      completed = false;
                      break;
                    }
                  }
                  bytesTransferred += (long)(count = responseFus.GetResponseStream().Read(buffer, 0, buffer.Length));
                  if (count > 0)
                  {
                    if (!decryptInline)
                      output.Write(buffer, 0, count);
                    else
                    {
                      int offset = 0;
                      while (offset < count)
                      {
                        int copy = Math.Min(16 - pendingCount, count - offset);
                        Buffer.BlockCopy(buffer, offset, pendingCipher, pendingCount, copy);
                        pendingCount += copy;
                        offset += copy;
                        if (pendingCount == 16)
                        {
                          byte[] plain = new byte[16];
                          decryptor.TransformBlock(pendingCipher, 0, 16, plain, 0);
                          if (hasLastPlain)
                            output.Write(lastPlain, 0, lastPlain.Length);
                          Buffer.BlockCopy(plain, 0, lastPlain, 0, lastPlain.Length);
                          hasLastPlain = true;
                          pendingCount = 0;
                        }
                      }
                    }
                    if (GUI)
                    {
                      int dlspeed = Utility.DownloadSpeed(bytesTransferred, sw);
                      if (dlspeed != -1)
                        Web.form.lbl_speed.Invoke((Delegate)((Action)(() => Web.form.lbl_speed.Text = dlspeed.ToString() + " KB/s")));
                    }
                  }
                  if (GUI)
                    Web.form.SetProgressBar(Utility.GetProgress(bytesTransferred, total), bytesTransferred);
                  else
                    CmdLine.SetProgress(Utility.GetProgress(bytesTransferred, total));
                }
                while (count > 0);
                if (decryptInline && completed)
                {
                  if (pendingCount != 0 || !hasLastPlain)
                    throw new IOException("Encrypted firmware stream ended on a partial AES block");
                  int padding = lastPlain[15];
                  if (padding < 1 || padding > 16)
                    throw new IOException("Encrypted firmware has invalid padding");
                  for (int i = 1; i <= padding; ++i)
                  {
                    if (lastPlain[16 - i] != padding)
                      throw new IOException("Encrypted firmware has invalid padding");
                  }
                  output.Write(lastPlain, 0, 16 - padding);
                  output.Flush();
                  System.IO.File.Delete(inlineResumeMarker);
                }
              }
            }
            catch (IOException ex)
            {
              if (ex.InnerException is SocketException ||
                  ex.Message.IndexOf("transport connection", StringComparison.OrdinalIgnoreCase) >= 0)
              {
                Logger.WriteLog("Error: Connection interrupted. Resuming download...", false);
                Web.SetReconnect();
                return -1;
              }
              Logger.WriteLog("Error: Can't access output file " + saveTo, false);
              if (GUI)
                Web.form.PauseDownload = true;
              Logger.WriteLog(ex.ToString(), false);
              return -1;
            }
            catch (WebException ex)
            {
              Logger.WriteLog("Error: Connection interrupted", false);
              Web.SetReconnect();
            }
            finally
            {
              Utility.PreventDeepSleep(Utility.PDSMode.Stop);
              if (GUI)
                Web.form.lbl_speed.Invoke((Delegate)((Action)(() => Web.form.lbl_speed.Text = "0 KB/s")));
            }
          }
        }
        return (int)responseFus.StatusCode;
      }
    }
  }

  public static class Extensions
  {
    static MethodInfo httpWebRequestAddRangeHelper = typeof(WebHeaderCollection).GetMethod
                                    ("AddWithoutValidate", BindingFlags.Instance | BindingFlags.NonPublic);
    /// <summary>
    /// Adds a byte range header to a request for a specific range from the beginning or end of the requested data.
    /// </summary>
    /// <param name="request">The <see cref="System.Web.HttpWebRequest"/> to add the range specifier to.</param>
    /// <param name="start">The starting or ending point of the range.</param>
    public static void AddRange(this HttpWebRequest request, long start) { request.AddRange(start, -1L); }

    /// <summary>Adds a byte range header to the request for a specified range.</summary>
    /// <param name="request">The <see cref="System.Web.HttpWebRequest"/> to add the range specifier to.</param>
    /// <param name="start">The position at which to start sending data.</param>
    /// <param name="end">The position at which to stop sending data.</param>
    public static void AddRange(this HttpWebRequest request, long start, long end)
    {
      if (request == null) throw new ArgumentNullException("request");
      if (start < 0) throw new ArgumentOutOfRangeException("start", "Starting byte cannot be less than 0.");
      if (end < start) end = -1;

      string key = "Range";
      string val = string.Format("bytes={0}-{1}", start, end == -1 ? "" : end.ToString());

      httpWebRequestAddRangeHelper.Invoke(request.Headers, new object[] { key, val });
    }
  }
}