// TODO: Rather return a session object or something like that
// Returns the encryption key
internal static byte[] Authenticate(string passphrase, HttpCookies cookies, string tld, RestClient rest)
{
// Fetch key derivation parameters and some other stuff
var info = GetAuthInfo(cookies, tld, rest);
// Decryption key
var key = Util.ComputeKey(passphrase, info.Salt, info.IterationCount);
// Verify that the key is correct
// AuthInfo.EncryptionCheck contains some encrypted JSON that could be
// decrypted and parsed to check if the passphrase is correct. We have
// to rely here on the encrypted JSON simply not parsing correctly and
// producing some sort of error.
var decrypted = Util.Decrypt(info.EncryptionCheck, key).ToUtf8();
// TODO: See if ToUtf8 could throw something
JToken parsed = null;
try
{
parsed = JToken.Parse(decrypted);
}
catch (JsonException)
{
}
// This would be null in case of JSON exception or if Parse returned null (would it?)
if (parsed == null)
{
throw new BadCredentialsException("Passphrase is incorrect");
}
return(key);
}
public void Execute()
{
var cookie = new HttpCookies();
cookie["name"] = "Mosh";
Console.WriteLine(cookie["name"]);
}
internal static void LogOut(HttpCookies cookies, string tld, RestClient rest)
{
var response = rest.Get(LogoutUrl(tld), Headers, cookies);
if (!response.IsSuccessful)
{
throw MakeErrorOnFailedRequest(response);
}
}
public HttpRequest()
{
Protocol = DEFAULT_HTTP_PROTOCOL;
GET = new HttpRequestParams();
POST = new HttpRequestParams();
FILES = new HttpFormFiles();
Headers = new HttpRequestHeaders();
Cookies = new HttpCookies();
}
internal static AuthInfo GetAuthInfo(HttpCookies cookies, string tld, RestClient rest)
{
var info = GetWrapped <R.AuthInfo>(AuthInfoUrl(tld), cookies, rest);
if (info.KdfMethod != "PBKDF2_AES")
{
throw new UnsupportedFeatureException($"KDF method '{info.KdfMethod}' is not supported");
}
return(new AuthInfo(info.Iterations, info.Salt.ToBytes(), info.Passphrase.Decode64()));
}
//
// PUT
//
public RestResponse <string> Put(string endpoint,
HttpHeaders headers = null,
HttpCookies cookies = null)
{
return(MakeRequest <string>(endpoint,
HttpMethod.Put,
null,
headers ?? NoHeaders,
cookies ?? NoCookies,
MaxRedirects));
}
//
// POST form
//
public RestResponse <string> PostForm(string endpoint,
PostParameters parameters,
HttpHeaders headers = null,
HttpCookies cookies = null)
{
return(MakeRequest <string>(endpoint,
HttpMethod.Post,
ToFormContent(parameters),
headers ?? NoHeaders,
cookies ?? NoCookies,
MaxRedirects));
}
public RestResponse <byte[]> GetBinary(string endpoint,
HttpHeaders headers = null,
HttpCookies cookies = null,
int maxRedirects = MaxRedirects)
{
return(MakeRequest <byte[]>(endpoint,
HttpMethod.Get,
null,
headers ?? NoHeaders,
cookies ?? NoCookies,
maxRedirects));
}
//
// POST raw
//
public RestResponse <string> PostRaw(string endpoint,
string content,
HttpHeaders headers = null,
HttpCookies cookies = null)
{
return(MakeRequest <string>(endpoint,
HttpMethod.Post,
new StringContent(content),
headers ?? NoHeaders,
cookies ?? NoCookies,
MaxRedirects));
}
public RestResponse <string, T> PostForm <T>(string endpoint,
PostParameters parameters,
HttpHeaders headers = null,
HttpCookies cookies = null)
{
return(MakeRequest <string, T>(endpoint,
HttpMethod.Post,
ToFormContent(parameters),
headers ?? NoHeaders,
cookies ?? NoCookies,
MaxRedirects,
JsonConvert.DeserializeObject <T>));
}
public RestResponse <string, T> Get <T>(string endpoint,
HttpHeaders headers = null,
HttpCookies cookies = null,
int maxRedirects = MaxRedirects)
{
return(MakeRequest <string, T>(endpoint,
HttpMethod.Get,
null,
headers ?? NoHeaders,
cookies ?? NoCookies,
maxRedirects,
JsonConvert.DeserializeObject <T>));
}
public HttpResponse(HttpResponseStatus status, string contentType = DEFAULT_CONTENT_TYPE, string charset = DEFAULT_CHARSET)
{
try
{
Encoding = Encoding.GetEncoding(charset);
}
catch { Encoding = Encoding.UTF8; }
Cookies = new HttpCookies();
Headers = new HttpResponseHeaders();
Headers[HttpResponseHeaders.Date] = DateTime.Now.ToUniversalTime().ToString("r");
Headers[HttpResponseHeaders.ContentType] = string.Format("{0}; charset={1}", contentType, charset);
Status = status;
}
internal static T GetWrapped <T>(string url, HttpCookies cookies, RestClient rest)
{
// GET
var response = rest.Get <R.ResponseEnvelope <T> >(url, Headers, cookies);
if (!response.IsSuccessful)
{
throw MakeErrorOnFailedRequest(response);
}
// Check operation status
var envelope = response.Data;
if (envelope.Operation.Result.Status != "success")
{
throw MakeInvalidResponseError("operation failed");
}
return(envelope.Payload);
}
internal static R.Vault DownloadVault(HttpCookies cookies, string tld, RestClient rest)
{
return(GetWrapped <R.Vault>(VaultUrl(tld), cookies, rest));
}
internal HttpResponse(HttpCookies cookies)
{
this.Cookies = cookies;
}
/// <summary>
/// 分析request 头部
/// </summary>
/// <param name="buffer"></param>
/// <param name="httpMessage"></param>
/// <returns></returns>
public static bool Analysis(byte[] buffer, out HttpMessage httpMessage)
{
httpMessage = null;
var bufferSpan = buffer.AsSpan();
var count = bufferSpan.Length;
var index = bufferSpan.IndexOf(_dEnterBytes);
if (index == count - 4)
{
httpMessage = new HttpMessage();
httpMessage.HeaderStr = Encoding.UTF8.GetString(buffer);
httpMessage.Position = count;
}
else
{
if (index > 0)
{
httpMessage = new HttpMessage();
httpMessage.HeaderStr = Encoding.UTF8.GetString(bufferSpan.Slice(0, index + 4).ToArray());
httpMessage.Position = index + 4;
}
if (httpMessage == null)
{
return(false);
}
}
//分析requestHeader
var rows = httpMessage.HeaderStr.Split(ConstHelper.ENTER, StringSplitOptions.RemoveEmptyEntries);
var arr = rows[0].Split(ConstHelper.SPACE);
httpMessage.Method = arr[0];
httpMessage.RelativeUrl = arr[1];
httpMessage.Protocal = arr[2];
if (httpMessage.RelativeUrl.Contains(ConstHelper.QUESTIONMARK))
{
var qarr = httpMessage.RelativeUrl.Split(ConstHelper.QUESTIONMARK);
httpMessage.Url = qarr[0];
httpMessage.Query = GetRequestQuerys(qarr[1]);
}
else
{
httpMessage.Url = httpMessage.RelativeUrl;
}
var uarr = httpMessage.Url.Split(ConstHelper.SLASH);
if (long.TryParse(uarr[uarr.Length - 1], out long id))
{
httpMessage.Url = StringHelper.Substring(httpMessage.Url, 0, httpMessage.Url.LastIndexOf(ConstHelper.SLASH));
httpMessage.Query.Add(ConstHelper.ID, id.ToString());
}
var lastRows = rows.AsSpan().Slice(1).ToArray();
httpMessage.Headers = GetRequestHeaders(lastRows);
//cookies
var cookiesStr = string.Empty;
if (httpMessage.Headers.TryGetValue(RequestHeaderType.Cookie.GetDescription(), out cookiesStr))
{
httpMessage.Cookies = HttpCookies.Parse(cookiesStr);
}
//post数据分析
if (httpMessage.Method == ConstHelper.POST)
{
string contentTypeStr = string.Empty;
if (httpMessage.Headers.TryGetValue(RequestHeaderType.ContentType.GetDescription(), out contentTypeStr))
{
//form-data
if (contentTypeStr.IndexOf(ConstHelper.FORMENCTYPE2) > -1)
{
httpMessage.IsFormData = true;
httpMessage.Boundary = "--" + Regex.Split(contentTypeStr, ConstHelper.SEMICOLON)[1].Replace(ConstHelper.BOUNDARY, "");
}
}
string contentLengthStr = string.Empty;
if (httpMessage.Headers.TryGetValue(RequestHeaderType.ContentLength.GetDescription(), out contentLengthStr))
{
int cl = 0;
if (int.TryParse(contentLengthStr, out cl))
{
httpMessage.ContentLength = cl;
}
}
}
return(true);
}
public byte[] GetResponseBytes(Uri RequestUri, eHttpMethod method, byte[] postbytes)
{
if (uri == null || !uri.Equals(RequestUri))
{
this.uri = RequestUri;
}
if (socket == null)
{
socket = new TcpSocket();
}
if (method != eHttpMethod.GET && method != eHttpMethod.POST)
{
throw new Exception("Unsupport Method");
}
if (!uri.IsAbsoluteUri)
{
throw new Exception("Absolute Uri is required");
}
if (uri.Scheme != "http")
{
throw new Exception("Unsupport protocol");
}
var request = new HttpRequest();
request.Method = method;
request.uri = this.uri.PathAndQuery;
request.headers[eHttpRequestHeader.Host] = this.uri.Host;
request.headers[eHttpRequestHeader.Connection] = "keep-alive";
request.Cookies = this.Cookies;
//request.headers[eHttpRequestHeader.AcceptEncoding] = "gzip;q=1.0";
if (request.Method == eHttpMethod.POST)
{
if (postbytes == null)
{
throw new ArgumentNullException("postbytes cannot be null");
}
request.headers[eHttpRequestHeader.ContentLength] = postbytes.Length.ToString();
request.headers[eHttpRequestHeader.ContentType] = "application/x-www-form-urlencoded; charset=UTF-8";
request.Write(postbytes);
}
var data = request.GetAll();
try
{
if(!connected)
{
socket.Connect(Dns.GetHostAddresses(uri.DnsSafeHost)[0], this.uri.Port);
connected = true;
}
socket.Send(data);
var response = new HttpResponse(Cookies);
while (!response.IsComplete)
{
while (socket.IsDataAvailable())
{
byte[] buffer = new byte[8 * 1024];
socket.Receive(buffer);
response.Read(buffer);
}
}
this.Cookies = response.Cookies;
if (response.headers.Connection == eConnectionType.Close)
{
socket = null;
}
return response.GetContent();
}
catch(Exception e)
{
Log.Log.Default.Error(e);
}
return new byte[] { };
}
