/// <summary>
/// Parses the server's challenge token and returns the next challenge response.
/// </summary>
/// <remarks>
/// Parses the server's challenge token and returns the next challenge response.
/// </remarks>
/// <returns>The next challenge response.</returns>
/// <param name="token">The server's challenge token.</param>
/// <param name="startIndex">The index into the token specifying where the server's challenge begins.</param>
/// <param name="length">The length of the server's challenge.</param>
/// <exception cref="System.InvalidOperationException">
/// The SASL mechanism is already authenticated.
/// </exception>
/// <exception cref="SaslException">
/// An error has occurred while parsing the server's challenge token.
/// </exception>
protected override byte[] Challenge(byte[] token, int startIndex, int length)
{
if (IsAuthenticated)
{
throw new InvalidOperationException();
}
var cred = Credentials.GetCredential(Uri, MechanismName);
var userName = encoding.GetBytes(cred.UserName);
var password = encoding.GetBytes(cred.Password);
var buffer = new byte[userName.Length + password.Length + 2];
int offset = 0;
buffer[offset++] = 0;
for (int i = 0; i < userName.Length; i++)
{
buffer[offset++] = userName[i];
}
buffer[offset++] = 0;
for (int i = 0; i < password.Length; i++)
{
buffer[offset++] = password[i];
}
IsAuthenticated = true;
return(buffer);
}
static string ReadNStringToken(ImapEngine engine, bool rfc2047, CancellationToken cancellationToken)
{
var token = engine.ReadToken(cancellationToken);
string value;
switch (token.Type)
{
case ImapTokenType.Literal:
value = engine.ReadLiteral(cancellationToken);
break;
case ImapTokenType.QString:
case ImapTokenType.Atom:
value = (string)token.Value;
break;
case ImapTokenType.Nil:
return(null);
default:
throw ImapEngine.UnexpectedToken(token, false);
}
return(rfc2047 ? Rfc2047.DecodeText(Latin1.GetBytes(value)) : value);
}
/// <summary>
/// Parses the server's challenge token and returns the next challenge response.
/// </summary>
/// <remarks>
/// Parses the server's challenge token and returns the next challenge response.
/// </remarks>
/// <returns>The next challenge response.</returns>
/// <param name="token">The server's challenge token.</param>
/// <param name="startIndex">The index into the token specifying where the server's challenge begins.</param>
/// <param name="length">The length of the server's challenge.</param>
/// <exception cref="System.InvalidOperationException">
/// The SASL mechanism is already authenticated.
/// </exception>
/// <exception cref="SaslException">
/// An error has occurred while parsing the server's challenge token.
/// </exception>
protected override byte[] Challenge(byte[] token, int startIndex, int length)
{
if (IsAuthenticated)
{
throw new InvalidOperationException();
}
var authzid = encoding.GetBytes(Credentials.Domain ?? string.Empty);
var authcid = encoding.GetBytes(Credentials.UserName);
var passwd = encoding.GetBytes(Credentials.Password);
var buffer = new byte[authzid.Length + authcid.Length + passwd.Length + 2];
int offset = 0;
for (int i = 0; i < authzid.Length; i++)
{
buffer[offset++] = authzid[i];
}
buffer[offset++] = 0;
for (int i = 0; i < authcid.Length; i++)
{
buffer[offset++] = authcid[i];
}
buffer[offset++] = 0;
for (int i = 0; i < passwd.Length; i++)
{
buffer[offset++] = passwd[i];
}
IsAuthenticated = true;
return(buffer);
}
/// <summary>
/// Parses the server's challenge token and returns the next challenge response.
/// </summary>
/// <remarks>
/// Parses the server's challenge token and returns the next challenge response.
/// </remarks>
/// <returns>The next challenge response.</returns>
/// <param name="token">The server's challenge token.</param>
/// <param name="startIndex">The index into the token specifying where the server's challenge begins.</param>
/// <param name="length">The length of the server's challenge.</param>
/// <exception cref="System.InvalidOperationException">
/// The SASL mechanism is already authenticated.
/// </exception>
/// <exception cref="System.NotSupportedException">
/// The SASL mechanism does not support SASL-IR.
/// </exception>
/// <exception cref="SaslException">
/// An error has occurred while parsing the server's challenge token.
/// </exception>
protected override byte[] Challenge(byte[] token, int startIndex, int length)
{
byte[] challenge;
if (token == null)
{
throw new NotSupportedException("LOGIN does not support SASL-IR.");
}
switch (state)
{
case LoginState.UserName:
challenge = encoding.GetBytes(Credentials.UserName);
state = LoginState.Password;
break;
case LoginState.Password:
challenge = encoding.GetBytes(Credentials.Password);
IsAuthenticated = true;
break;
default:
throw new InvalidOperationException();
}
return(challenge);
}
static byte[] EncodeReferencesHeader(ParserOptions options, FormatOptions format, Encoding charset, string field, string value)
{
var encoded = new StringBuilder();
int lineLength = field.Length + 1;
int count = 0;
foreach (var reference in MimeUtils.EnumerateReferences(value))
{
if (count > 0 && lineLength + reference.Length + 3 > format.MaxLineLength)
{
encoded.Append(format.NewLine);
encoded.Append('\t');
lineLength = 1;
count = 0;
}
else
{
encoded.Append(' ');
lineLength++;
}
encoded.Append('<').Append(reference).Append('>');
lineLength += reference.Length + 2;
count++;
}
encoded.Append(format.NewLine);
return(charset.GetBytes(encoded.ToString()));
}
public static string UrlEncode(string s, Encoding Enc)
{
if (s == null)
{
return(null);
}
if (s == string.Empty)
{
return(string.Empty);
}
bool flag = false;
int length = s.Length;
for (int i = 0; i < length; i++)
{
char c = s[i];
if (((((c < '0') || ((c < 'A') && (c > '9'))) || ((c > 'Z') && (c < 'a'))) || (c > 'z')) && !HttpEncoder.NotEncoded(c))
{
flag = true;
break;
}
}
if (!flag)
{
return(s);
}
byte[] bytes = new byte[Enc.GetMaxByteCount(s.Length)];
int count = Enc.GetBytes(s, 0, s.Length, bytes, 0);
return(Encoding.ASCII.GetString(UrlEncodeToBytes(bytes, 0, count)));
}
public byte[] Encode(Encoding encoding)
{
var builder = new StringBuilder();
builder.AppendFormat("username={0}", Quote(UserName));
builder.AppendFormat(",realm=\"{0}\"", Realm);
builder.AppendFormat(",nonce=\"{0}\"", Nonce);
builder.AppendFormat(",cnonce=\"{0}\"", CNonce);
builder.AppendFormat(",nc={0:x8}", Nc);
builder.AppendFormat(",qop=\"{0}\"", Qop);
builder.AppendFormat(",digest-uri=\"{0}\"", DigestUri);
builder.AppendFormat(",response={0}", Response);
if (MaxBuf.HasValue)
{
builder.AppendFormat(",maxbuf={0}", MaxBuf.Value);
}
if (!string.IsNullOrEmpty(Charset))
{
builder.AppendFormat(",charset={0}", Charset);
}
if (!string.IsNullOrEmpty(Algorithm))
{
builder.AppendFormat(",algorithm={0}", Algorithm);
}
if (!string.IsNullOrEmpty(Cipher))
{
builder.AppendFormat(",cipher=\"{0}\"", Cipher);
}
if (!string.IsNullOrEmpty(AuthZid))
{
builder.AppendFormat(",authzid=\"{0}\"", AuthZid);
}
return(encoding.GetBytes(builder.ToString()));
}
static void AddEnvelopeAddress(InternetAddressList list, ImapEngine engine, CancellationToken cancellationToken)
{
var values = new string[4];
ImapToken token;
int index = 0;
do {
token = engine.ReadToken (cancellationToken);
switch (token.Type) {
case ImapTokenType.Literal:
values[index] = engine.ReadLiteral (cancellationToken);
break;
case ImapTokenType.QString:
case ImapTokenType.Atom:
values[index] = (string) token.Value;
break;
case ImapTokenType.Nil:
break;
default:
throw ImapEngine.UnexpectedToken (token, false);
}
index++;
} while (index < 4);
token = engine.ReadToken (cancellationToken);
if (token.Type != ImapTokenType.CloseParen)
throw ImapEngine.UnexpectedToken (token, false);
string name = null;
if (values[0] != null) {
// Note: since the ImapEngine.ReadLiteral() uses iso-8859-1
// to convert bytes to unicode, we can undo that here:
name = Rfc2047.DecodePhrase (Latin1.GetBytes (values[0]));
}
string address = values[3] != null ? values[2] + "@" + values[3] : values[2];
DomainList route;
if (values[1] != null && DomainList.TryParse (values[1], out route))
list.Add (new MailboxAddress (name, route, address));
else
list.Add (new MailboxAddress (name, address));
}
public string ComputeHash(Encoding encoding, string password, bool client)
{
string text, a1, a2;
byte[] buf, digest;
// compute A1
text = string.Format("{0}:{1}:{2}", UserName, Realm, password);
buf = encoding.GetBytes(text);
using (var md5 = MD5.Create())
digest = md5.ComputeHash(buf);
using (var md5 = MD5.Create()) {
md5.TransformBlock(digest, 0, digest.Length, null, 0);
text = string.Format(":{0}:{1}", Nonce, CNonce);
if (!string.IsNullOrEmpty(AuthZid))
{
text += ":" + AuthZid;
}
buf = encoding.GetBytes(text);
md5.TransformFinalBlock(buf, 0, buf.Length);
a1 = HexEncode(md5.Hash);
}
// compute A2
text = client ? "AUTHENTICATE:" : ":";
text += DigestUri;
if (Qop == "auth-int" || Qop == "auth-conf")
{
text += ":00000000000000000000000000000000";
}
buf = encoding.GetBytes(text);
using (var md5 = MD5.Create())
digest = md5.ComputeHash(buf);
a2 = HexEncode(digest);
// compute KD
text = string.Format("{0}:{1}:{2:x8}:{3}:{4}:{5}", a1, Nonce, Nc, CNonce, Qop, a2);
buf = encoding.GetBytes(text);
using (var md5 = MD5.Create())
digest = md5.ComputeHash(buf);
return(HexEncode(digest));
}
public static byte[] UrlDecodeToBytes(string str, Encoding e)
{
if (str == null)
{
return(null);
}
if (e == null)
{
throw new ArgumentNullException("e");
}
return(UrlDecodeToBytes(e.GetBytes(str)));
}
/// <summary>
/// Sets the text content and the charset parameter in the Content-Type header.
/// </summary>
/// <remarks>
/// This method is similar to setting the <see cref="TextPart.Text"/> property,
/// but allows specifying a charset encoding to use. Also updates the
/// <see cref="ContentType.Charset"/> property.
/// </remarks>
/// <param name="encoding">The charset encoding.</param>
/// <param name="text">The text content.</param>
/// <exception cref="System.ArgumentNullException">
/// <para><paramref name="encoding"/> is <c>null</c>.</para>
/// <para>-or-</para>
/// <para><paramref name="text"/> is <c>null</c>.</para>
/// </exception>
public void SetText (Encoding encoding, string text)
{
if (encoding == null)
throw new ArgumentNullException (nameof (encoding));
if (text == null)
throw new ArgumentNullException (nameof (text));
ContentType.Parameters["charset"] = CharsetUtils.GetMimeCharset (encoding);
var content = new MemoryStream (encoding.GetBytes (text));
Content = new MimeContent (content);
}
public static byte[] UrlEncodeToBytes(string str, Encoding e)
{
if (str == null)
{
return(null);
}
if (str.Length == 0)
{
return(new byte[0]);
}
byte[] bytes = e.GetBytes(str);
return(UrlEncodeToBytes(bytes, 0, bytes.Length));
}
private static void WriteCharBytes(IList buf, char ch, Encoding e)
{
if (ch > '\x00ff')
{
foreach (byte num in e.GetBytes(new char[] { ch }))
{
buf.Add(num);
}
}
else
{
buf.Add((byte)ch);
}
}
/// <summary>
/// Sets the text content and the charset parameter in the Content-Type header.
/// </summary>
/// <remarks>
/// This method is similar to setting the <see cref="Text"/> property, but allows
/// specifying a charset encoding to use. Also updates the
/// <see cref="ContentType.Charset"/> property.
/// </remarks>
/// <param name="charset">The charset encoding.</param>
/// <param name="text">The text content.</param>
/// <exception cref="System.ArgumentNullException">
/// <para><paramref name="charset"/> is <c>null</c>.</para>
/// <para>-or-</para>
/// <para><paramref name="text"/> is <c>null</c>.</para>
/// </exception>
public void SetText(Encoding charset, string text)
{
if (charset == null)
{
throw new ArgumentNullException("charset");
}
if (text == null)
{
throw new ArgumentNullException("text");
}
var content = new MemoryStream(charset.GetBytes(text));
ContentObject = new ContentObject(content, ContentEncoding.Default);
ContentType.Parameters["charset"] = CharsetUtils.GetMimeCharset(charset);
}
/// <summary>
/// Sets the text content and the charset parameter in the Content-Type header.
/// </summary>
/// <remarks>
/// This method is similar to setting the <see cref="Text"/> property, but allows
/// specifying a charset encoding to use. Also updates the
/// <see cref="ContentType.Charset"/> property.
/// </remarks>
/// <param name="encoding">The charset encoding.</param>
/// <param name="text">The text content.</param>
/// <exception cref="System.ArgumentNullException">
/// <para><paramref name="encoding"/> is <c>null</c>.</para>
/// <para>-or-</para>
/// <para><paramref name="text"/> is <c>null</c>.</para>
/// </exception>
public void SetText (Encoding encoding, string text)
{
if (encoding == null)
throw new ArgumentNullException ("encoding");
if (text == null)
throw new ArgumentNullException ("text");
ContentType.Parameters["charset"] = CharsetUtils.GetMimeCharset (encoding);
var content = new MemoryStream (encoding.GetBytes (text));
ContentObject = new ContentObject (content);
}
static byte[] EncodeReferencesHeader (ParserOptions options, FormatOptions format, Encoding charset, string field, string value)
{
var encoded = new StringBuilder ();
int lineLength = field.Length + 1;
int count = 0;
foreach (var reference in MimeUtils.EnumerateReferences (value)) {
if (count > 0 && lineLength + reference.Length + 3 > format.MaxLineLength) {
encoded.Append (format.NewLine);
encoded.Append ('\t');
lineLength = 1;
count = 0;
} else {
encoded.Append (' ');
lineLength++;
}
encoded.Append ('<').Append (reference).Append ('>');
lineLength += reference.Length + 2;
count++;
}
encoded.Append (format.NewLine);
return charset.GetBytes (encoded.ToString ());
}
static byte[] EncodeDkimSignatureHeader (ParserOptions options, FormatOptions format, Encoding charset, string field, string value)
{
var encoded = new StringBuilder ();
int lineLength = field.Length + 1;
var token = new StringBuilder ();
int index = 0;
while (index < value.Length) {
while (index < value.Length && IsWhiteSpace (value[index]))
index++;
int startIndex = index;
string name;
while (index < value.Length && value[index] != '=') {
if (!IsWhiteSpace (value[index]))
token.Append (value[index]);
index++;
}
name = value.Substring (startIndex, index - startIndex);
while (index < value.Length && value[index] != ';') {
if (!IsWhiteSpace (value[index]))
token.Append (value[index]);
index++;
}
if (index < value.Length && value[index] == ';') {
token.Append (';');
index++;
}
if (lineLength + token.Length + 1 > format.MaxLineLength || name == "bh" || name == "b") {
encoded.Append (format.NewLine);
encoded.Append ('\t');
lineLength = 1;
} else {
encoded.Append (' ');
lineLength++;
}
if (token.Length > format.MaxLineLength) {
switch (name) {
case "z":
EncodeDkimHeaderList (format, encoded, ref lineLength, token.ToString (), '|');
break;
case "h":
EncodeDkimHeaderList (format, encoded, ref lineLength, token.ToString (), ':');
break;
default:
EncodeDkimLongValue (format, encoded, ref lineLength, token.ToString ());
break;
}
} else {
encoded.Append (token.ToString ());
lineLength += token.Length;
}
token.Length = 0;
}
encoded.Append (format.NewLine);
return charset.GetBytes (encoded.ToString ());
}
static byte[] EncodeReceivedHeader (ParserOptions options, FormatOptions format, Encoding charset, string field, string value)
{
var tokens = new List<ReceivedTokenValue> ();
var rawValue = charset.GetBytes (value);
var encoded = new StringBuilder ();
int lineLength = field.Length + 1;
bool date = false;
int index = 0;
int count = 0;
while (index < rawValue.Length) {
ReceivedTokenValue token = null;
int startIndex = index;
if (!ParseUtils.SkipCommentsAndWhiteSpace (rawValue, ref index, rawValue.Length, false) || index >= rawValue.Length) {
tokens.Add (new ReceivedTokenValue (startIndex, index - startIndex));
break;
}
while (index < rawValue.Length && !rawValue[index].IsWhitespace ())
index++;
var atom = charset.GetString (rawValue, startIndex, index - startIndex);
for (int i = 0; i < ReceivedTokens.Length; i++) {
if (atom == ReceivedTokens[i].Atom) {
ReceivedTokens[i].Skip (rawValue, ref index);
if (ParseUtils.SkipCommentsAndWhiteSpace (rawValue, ref index, rawValue.Length, false)) {
if (index < rawValue.Length && rawValue[index] == (byte) ';') {
date = true;
index++;
}
}
token = new ReceivedTokenValue (startIndex, index - startIndex);
break;
}
}
if (token == null) {
if (ParseUtils.SkipCommentsAndWhiteSpace (rawValue, ref index, rawValue.Length, false)) {
while (index < rawValue.Length && !rawValue[index].IsWhitespace ())
index++;
}
token = new ReceivedTokenValue (startIndex, index - startIndex);
}
tokens.Add (token);
ParseUtils.SkipWhiteSpace (rawValue, ref index, rawValue.Length);
if (date && index < rawValue.Length) {
// slurp up the date (the final token)
tokens.Add (new ReceivedTokenValue (index, rawValue.Length - index));
break;
}
}
foreach (var token in tokens) {
var text = charset.GetString (rawValue, token.StartIndex, token.Length).TrimEnd ();
if (count > 0 && lineLength + text.Length + 1 > format.MaxLineLength) {
encoded.Append (format.NewLine);
encoded.Append ('\t');
lineLength = 1;
count = 0;
} else {
encoded.Append (' ');
lineLength++;
}
lineLength += text.Length;
encoded.Append (text);
count++;
}
encoded.Append (format.NewLine);
return charset.GetBytes (encoded.ToString ());
}
static byte[] EncodeMessageIdHeader (ParserOptions options, FormatOptions format, Encoding charset, string field, string value)
{
return charset.GetBytes (" " + value + format.NewLine);
}
static byte[] EncodeReceivedHeader(ParserOptions options, FormatOptions format, Encoding charset, string field, string value)
{
var tokens = new List <ReceivedTokenValue> ();
var rawValue = charset.GetBytes(value);
var encoded = new StringBuilder();
int lineLength = field.Length + 1;
bool date = false;
int index = 0;
int count = 0;
while (index < rawValue.Length)
{
ReceivedTokenValue token = null;
int startIndex = index;
if (!ParseUtils.SkipCommentsAndWhiteSpace(rawValue, ref index, rawValue.Length, false) || index >= rawValue.Length)
{
tokens.Add(new ReceivedTokenValue(startIndex, index - startIndex));
break;
}
while (index < rawValue.Length && !rawValue[index].IsWhitespace())
{
index++;
}
var atom = charset.GetString(rawValue, startIndex, index - startIndex);
for (int i = 0; i < ReceivedTokens.Length; i++)
{
if (atom == ReceivedTokens[i].Atom)
{
ReceivedTokens[i].Skip(rawValue, ref index);
if (ParseUtils.SkipCommentsAndWhiteSpace(rawValue, ref index, rawValue.Length, false))
{
if (index < rawValue.Length && rawValue[index] == (byte)';')
{
date = true;
index++;
}
}
token = new ReceivedTokenValue(startIndex, index - startIndex);
break;
}
}
if (token == null)
{
if (ParseUtils.SkipCommentsAndWhiteSpace(rawValue, ref index, rawValue.Length, false))
{
while (index < rawValue.Length && !rawValue[index].IsWhitespace())
{
index++;
}
}
token = new ReceivedTokenValue(startIndex, index - startIndex);
}
tokens.Add(token);
ParseUtils.SkipWhiteSpace(rawValue, ref index, rawValue.Length);
if (date && index < rawValue.Length)
{
// slurp up the date (the final token)
tokens.Add(new ReceivedTokenValue(index, rawValue.Length - index));
break;
}
}
foreach (var token in tokens)
{
var text = charset.GetString(rawValue, token.StartIndex, token.Length).TrimEnd();
if (count > 0 && lineLength + text.Length + 1 > format.MaxLineLength)
{
encoded.Append(format.NewLine);
encoded.Append('\t');
lineLength = 1;
count = 0;
}
else
{
encoded.Append(' ');
lineLength++;
}
lineLength += text.Length;
encoded.Append(text);
count++;
}
encoded.Append(format.NewLine);
return(charset.GetBytes(encoded.ToString()));
}
static byte[] EncodeMessageIdHeader(ParserOptions options, FormatOptions format, Encoding charset, string field, string value)
{
return(charset.GetBytes(" " + value + format.NewLine));
}
