public async ValueTask <SignatureCollection <TRollingHashAlgorithm, TStrongHashAlgorithm> > ReadSignatures
<TRollingHashAlgorithm, TStrongHashAlgorithm>
(SignatureOptions options,
CancellationToken ct)
where TRollingHashAlgorithm : struct, IRollingHashAlgorithm
where TStrongHashAlgorithm : IStrongHashAlgorithm
{
var signatures = new SignatureCollection <TRollingHashAlgorithm, TStrongHashAlgorithm>();
const int maxSignatures = 1 << 22;
for (int i = 0; i < maxSignatures; i++)
{
var sig = await _reader.Read
<BlockSignature <TRollingHashAlgorithm, TStrongHashAlgorithm>, SignatureOptions>
(options, ct).ConfigureAwait(false);
if (!sig.HasValue)
{
_reader.Complete();
return(signatures);
}
long start = options.BlockLength * i;
#if !NETSTANDARD2_0
signatures.TryAdd(sig.Value, (ulong)start);
#else
if (!signatures.ContainsKey(sig.Value))
{
signatures.Add(sig.Value, (ulong)start);
}
#endif
}
throw new FormatException($"too many signatures");
}
private async Task E2E(
byte[] version1,
byte[] version2,
SignatureOptions options)
{
IRdiff rdiff = new Rdiff();
var sig = new MemoryStream();
await rdiff.SignatureAsync(
oldFile : new MemoryStream(version1),
signature : sig,
options);
sig.Seek(offset: 0, SeekOrigin.Begin);
var delta = new MemoryStream();
await rdiff.DeltaAsync(
signature : sig,
newFile : new MemoryStream(version2),
delta : delta);
delta.Seek(offset: 0, SeekOrigin.Begin);
var v2 = new MemoryStream();
await rdiff.PatchAsync(
oldFile : new MemoryStream(version1),
delta : delta,
newFile : v2);
AssertHelpers.Equal(version2, v2.ToArray());
}
private static void ValidateSignatureDemo2()
{
var pwd = "123456";
var signatureParams = new Dictionary <string, string>();
var timestamp = SignatureUtils.GetTimestamp().ToString();
signatureParams.Add("merchant_name", "testaccount");
signatureParams.Add("signature_method", "SHA1");
signatureParams.Add("timestamp", timestamp);
signatureParams.Add("method", "testmethod");
signatureParams.Add("phone", "13012345678");
var signOpt = new SignatureOptions()
{
IsEncryptPwd = true,
PwdEncryptMode = EncryptMode.SHA256,
Method = SignatureMethod.SHA1
};
var signStr = $"merchant_name=testaccount&method=testmethod&phone=13012345678&signature_method=SHA1×tamp={timestamp}{CryptographyUtils.SHA256Encrypt(pwd)}";
var sign = CryptographyUtils.SHA1Encrypt(signStr);
Console.WriteLine("signature=" + sign);
var result = SignatureUtils.ValidateSignature(sign, signatureParams, pwd, "&", new SignatureValidateOptions()
{
IsCheckTimestamp = true,
TimestampError = new TimeSpan(0, 5, 0),
TimestampParamName = "timestamp",
SignatureOptions = signOpt
});
Console.WriteLine(result);
}
public DeltaWriter(
SignatureOptions options,
BlockMatcher <TRollingHashAlgorithm, TStrongHashAlgorithm> matcher,
PipeReader reader,
PipeWriter writer)
{
_blockLength = options.BlockLength;
_matcher = matcher;
_reader = reader;
_writer = writer;
}
public SignatureService(ISignatureRepository signatures,
IHttpClientFactory httpClient,
IHttpContextAccessor httpContextAccessor,
ISignatureCacheService cache,
IOptions <SignatureOptions> signatureOptions)
{
_signatures = signatures;
_httpClient = httpClient;
_httpContextAccessor = httpContextAccessor;
_cache = cache;
_signatureOptions = signatureOptions.Value;
}
public static IDictionary <string, object> InjectSignature <T>(this T data, Func <T, object> signatureComponentsSelector,
string signatureFieldKey = "signature",
SignatureOptions options = null)
{
var dataDictionary = data.AsDictionary().ToDictionary(k => k.Key, v => v.Value);
var signatureDictionary =
signatureComponentsSelector(data).AsDictionary().ToDictionary(k => k.Key, v => v.Value);
var signature = GenerateSignature(signatureDictionary, options);
dataDictionary[signatureFieldKey] = signature;
return(dataDictionary);
}
public static string GenerateSignature(IDictionary <string, object> data, SignatureOptions options = null)
{
options ??= new SignatureOptions();
var dataString = $"{string.Join(options.ConcatenationSeparator, options.SignatureDictionaryTransformerFunc?.Invoke(data) ?? data.Select(d => $"{d.Value}"))}";
var signature = options.HashingAlgorithm switch
{
HashingAlgorithm.Sha256 => dataString.Sha256(),
HashingAlgorithm.Md5 => dataString.Md5(),
_ => throw new ArgumentOutOfRangeException(nameof(options.HashingAlgorithm), options.HashingAlgorithm, null)
};
return(options.SignatureTransformerFunc?.Invoke(signature) ?? signature);
}
}
public BlockMatcher(
SignatureCollection <TRollingHashAlgorithm, TStrongHashAlgorithm> signatures,
SignatureOptions options,
TRollingHashAlgorithm rollingHashAlgorithm,
TStrongHashAlgorithm strongHashAlgorithm,
MemoryPool <byte> memoryPool)
{
_signatures = signatures;
_blockLength = options.BlockLength;
_rollingHashAlgorithm = rollingHashAlgorithm;
_strongHashAlgorithm = strongHashAlgorithm;
_strongHashOwner = memoryPool.Rent(options.StrongHashLength);
_strongHashMemory = _strongHashOwner.Memory.Slice(0, options.StrongHashLength);
}
static bool CheckSignature(SoapContext context, MessageSignature signature)
{
//
// Now verify which parts of the message were actually signed.
//
SignatureOptions actualOptions = signature.SignatureOptions;
SignatureOptions expectedOptions = SignatureOptions.IncludeSoapBody;
if (context.Security != null && context.Security.Timestamp != null &&
context.Security.Timestamp.TargetElement != null)
{
expectedOptions |= SignatureOptions.IncludeTimestamp;
}
//
// The <Action> and <To> are required addressing elements.
//
expectedOptions |= SignatureOptions.IncludeAction;
expectedOptions |= SignatureOptions.IncludeTo;
if (context.Addressing.FaultTo != null && context.Addressing.FaultTo.TargetElement != null)
{
expectedOptions |= SignatureOptions.IncludeFaultTo;
}
if (context.Addressing.From != null && context.Addressing.From.TargetElement != null)
{
expectedOptions |= SignatureOptions.IncludeFrom;
}
if (context.Addressing.MessageID != null && context.Addressing.MessageID.TargetElement != null)
{
expectedOptions |= SignatureOptions.IncludeMessageId;
}
if (context.Addressing.RelatesTo != null && context.Addressing.RelatesTo.TargetElement != null)
{
expectedOptions |= SignatureOptions.IncludeRelatesTo;
}
if (context.Addressing.ReplyTo != null && context.Addressing.ReplyTo.TargetElement != null)
{
expectedOptions |= SignatureOptions.IncludeReplyTo;
}
//
// Check if the all the expected options are the present.
//
return((expectedOptions & actualOptions) == expectedOptions);
}
public void WriteTo(Span <byte> buffer, SignatureOptions options)
{
Debug.Assert(_blockMatcher == null);
Debug.Assert(buffer.Length >= Size(options));
BinaryPrimitives.WriteInt32BigEndian(buffer, _rollingHash);
Span <byte> strongHash = stackalloc byte[options.StrongHashLength];
CombineStrongHash(
strongHash,
_eagerStrongHash0,
_eagerStrongHash1,
_eagerStrongHash2,
_eagerStrongHash3);
strongHash.CopyTo(buffer.Slice(4));
}
public SignatureWriter(
PipeReader reader,
PipeWriter writer,
SignatureOptions options,
TRollingHashAlgorithm rollingHashAlgorithm,
TStrongHashAlgorithm strongHashAlgorithm,
MemoryPool <byte> memoryPool)
{
_reader = reader;
_writer = writer;
_options = options;
_rollingHashAlgorithm = rollingHashAlgorithm;
_strongHashAlgorithm = strongHashAlgorithm;
_strongHashBuffer = memoryPool.Rent(_options.StrongHashLength);
}
public OperationStatus ReadFrom(
ReadOnlySpan <byte> span,
SignatureOptions options,
out BlockSignature <TRollingHashAlgorithm, TStrongHashAlgorithm> sig)
{
if (span.Length < Size(options))
{
sig = default;
return(OperationStatus.NeedMoreData);
}
var rollingHash = BinaryPrimitives.ReadInt32BigEndian(span);
var strongHash = span.Slice(4, options.StrongHashLength);
sig = new BlockSignature <TRollingHashAlgorithm, TStrongHashAlgorithm>
(rollingHash, strongHash);
return(OperationStatus.Done);
}
public Account(string dataFolder)
{
WebmailSettings settings;
if (dataFolder != string.Empty)
{
settings = (new WebMailSettingsCreator()).CreateWebMailSettings(dataFolder);
}
else
{
settings = (new WebMailSettingsCreator()).CreateWebMailSettings();
}
_id = -1;
_idUser = -1;
_idDomain = 0;
_defaultAccount = true;
_deleted = false;
_email = "";
_mailProtocol = settings.IncomingMailProtocol;
_mailIncHost = settings.IncomingMailServer;
_mailIncLogin = "";
_mailIncPassword = "";
_mailIncPort = settings.IncomingMailPort;
_mailOutHost = settings.OutgoingMailServer;
_mailOutLogin = "";
_mailOutPassword = "";
_mailOutPort = settings.OutgoingMailPort;
_mailOutAuthentication = settings.ReqSmtpAuth;
_friendlyName = "";
_useFriendlyName = true;
_defaultOrder = DefaultOrder.DateDesc;
_getMailAtLogin = true;
_mailMode = MailMode.LeaveMessagesOnServer;
_mailsOnServerDays = 1;
_signature = "";
_signatureType = SignatureType.Plain;
_signatureOptions = SignatureOptions.DontAddSignature;
_user = null;
_delimiter = "/";
_mailbox_size = 0;
_mailing_list = false;
_imap_quota = -1;
_namespace = "";
}
public Account(int id_account, bool def_acct, bool deleted, string email, IncomingMailProtocol mail_protocol,
string mail_inc_host, string mail_inc_login, string mail_inc_pass, int mail_inc_port, string mail_out_host,
string mail_out_login, string mail_out_pass, int mail_out_port, bool mail_out_auth, string friendly_nm,
bool use_friendly_nm, DefaultOrder def_order, bool getmail_at_login, MailMode mail_mode,
short mails_on_server_days, string signature, SignatureType signature_type, SignatureOptions signature_opt,
string delimiter, long mailbox_size, int idDomain, bool mailing_list, int imap_quota, string Namespace)
{
_id = id_account;
_defaultAccount = def_acct;
_deleted = deleted;
_email = email;
_mailProtocol = mail_protocol;
_mailIncHost = mail_inc_host;
_mailIncLogin = mail_inc_login;
_mailIncPassword = mail_inc_pass;
_mailIncPort = mail_inc_port;
_mailOutHost = mail_out_host;
_mailOutLogin = mail_out_login;
_mailOutPassword = mail_out_pass;
_mailOutPort = mail_out_port;
_mailOutAuthentication = mail_out_auth;
_friendlyName = friendly_nm;
_useFriendlyName = use_friendly_nm;
_defaultOrder = def_order;
_getMailAtLogin = getmail_at_login;
_mailMode = mail_mode;
_mailsOnServerDays = mails_on_server_days;
_signature = signature;
_signatureType = signature_type;
_signatureOptions = signature_opt;
_delimiter = delimiter;
_mailbox_size = mailbox_size;
_idDomain = idDomain;
_mailing_list = mailing_list;
_imap_quota = imap_quota;
_namespace = Namespace;
}
public static string SignedSerialize <T>(this T data, Func <T, object> signatureComponentsSelector, string signatureFieldKey = "signature", JsonSerializerSettings serializerSettings = null, SignatureOptions options = null)
{
var dataDictionary = data.AsDictionary().ToDictionary(k => k.Key, v => v.Value);
var signatureDictionary = signatureComponentsSelector(data).AsDictionary().ToDictionary(k => k.Key, v => v.Value);
var signature = GenerateSignature(signatureDictionary, options);
dataDictionary[signatureFieldKey] = signature;
dataDictionary
.Where(o => o.Value is IEnumerable && !(o.Value is string))
.ToList()
.ForEach(o => dataDictionary[o.Key] = new JRaw(o.Value.Serialize()));
var result = dataDictionary.Serialize(serializerSettings);
return(result);
}
public override void PreConfigureServices(ServiceConfigurationContext context)
{
var configuration = context.Services.GetConfiguration();
var swagger = new SwaggerOptions();
var storage = new StorageOptions();
var cors = new CorsOptions();
var jwt = new JwtOptions();
var worker = new WorkerOptions();
var signature = new SignatureOptions();
var tencentCloud = new TencentCloudOptions();
var authorize = new AuthorizeOptions();
var ftqq = new FtqqOptions();
PreConfigure <SwaggerOptions>(options =>
{
var swaggerOption = configuration.GetSection("swagger");
Configure <SwaggerOptions>(swaggerOption);
options.Version = swaggerOption.GetValue <string>(nameof(options.Version));
options.Name = swaggerOption.GetValue <string>(nameof(options.Name));
options.Title = swaggerOption.GetValue <string>(nameof(options.Title));
options.Description = swaggerOption.GetValue <string>(nameof(options.Description));
options.RoutePrefix = swaggerOption.GetValue <string>(nameof(options.RoutePrefix));
options.DocumentTitle = swaggerOption.GetValue <string>(nameof(options.DocumentTitle));
swagger = options;
});
PreConfigure <StorageOptions>(options =>
{
var storageOption = configuration.GetSection("storage");
Configure <StorageOptions>(storageOption);
options.EnableDb = storageOption.GetValue <string>(nameof(options.EnableDb));
options.ConnectionString = storageOption.GetValue <string>(options.EnableDb);
options.RedisStatus = storageOption.GetValue <bool>(nameof(options.RedisStatus));
options.RedisConnection = storageOption.GetValue <string>(nameof(options.RedisConnection));
storage = options;
});
PreConfigure <CorsOptions>(options =>
{
var corsOption = configuration.GetSection("cors");
Configure <CorsOptions>(corsOption);
options.PolicyName = corsOption.GetValue <string>(nameof(options.PolicyName));
options.Origins = corsOption.GetValue <string>(nameof(options.Origins));
cors = options;
});
PreConfigure <JwtOptions>(options =>
{
var jwtOption = configuration.GetSection("jwt");
Configure <JwtOptions>(jwtOption);
options.Issuer = jwtOption.GetValue <string>(nameof(options.Issuer));
options.Audience = jwtOption.GetValue <string>(nameof(options.Audience));
options.SigningKey = jwtOption.GetValue <string>(nameof(options.SigningKey));
jwt = options;
});
PreConfigure <WorkerOptions>(options =>
{
var workerOption = configuration.GetSection("worker");
Configure <WorkerOptions>(workerOption);
options.IsEnabled = workerOption.GetValue <bool>(nameof(options.IsEnabled));
options.Cron = workerOption.GetValue <string>(nameof(options.Cron));
worker = options;
});
//PreConfigure<TencentCloudOptions>(options =>
//{
// var tencentCloudOption = configuration.GetSection("tencentCloud");
// Configure<TencentCloudOptions>(tencentCloudOption);
// options.SecretId = tencentCloudOption.GetValue<string>(nameof(options.SecretId));
// options.SecretKey = tencentCloudOption.GetValue<string>(nameof(options.SecretKey));
// tencentCloud = options;
//});
PreConfigure <SignatureOptions>(options =>
{
var signatureOption = configuration.GetSection("signature");
options.Path = signatureOption.GetValue <string>(nameof(options.Path));
foreach (var item in signatureOption.GetSection(nameof(options.Urls)).GetChildren())
{
options.Urls.Add(item.GetValue <string>("url"), item.GetValue <string>("param"));
}
signature = options;
Configure <SignatureOptions>(item =>
{
item.Path = signature.Path;
item.Urls = signature.Urls;
});
});
PreConfigure <AuthorizeOptions>(options =>
{
var authorizeOption = configuration.GetSection("authorize");
var githubOption = authorizeOption.GetSection("github");
var giteeOption = authorizeOption.GetSection("gitee");
var alipayOption = authorizeOption.GetSection("alipay");
var dingtalkOption = authorizeOption.GetSection("dingtalk");
var microsoftOption = authorizeOption.GetSection("microsoft");
var weiboOptions = authorizeOption.GetSection("weibo");
var qqOptions = authorizeOption.GetSection("qq");
Configure <AuthorizeOptions>(authorizeOption);
Configure <GithubOptions>(githubOption);
//Configure<GiteeOptions>(giteeOption);
//Configure<AlipayOptions>(alipayOption);
//Configure<DingtalkOptions>(dingtalkOption);
//Configure<MicrosoftOptions>(microsoftOption);
//Configure<WeiboOptions>(weiboOptions);
//Configure<QQOptions>(qqOptions);
options.Github = new GithubOptions
{
ClientId = githubOption.GetValue <string>(nameof(options.Github.ClientId)),
ClientSecret = githubOption.GetValue <string>(nameof(options.Github.ClientSecret)),
RedirectUrl = githubOption.GetValue <string>(nameof(options.Github.RedirectUrl)),
Scope = githubOption.GetValue <string>(nameof(options.Github.Scope))
};
//options.Gitee = new GiteeOptions
//{
// ClientId = giteeOption.GetValue<string>(nameof(options.Gitee.ClientId)),
// ClientSecret = giteeOption.GetValue<string>(nameof(options.Gitee.ClientSecret)),
// RedirectUrl = giteeOption.GetValue<string>(nameof(options.Gitee.RedirectUrl)),
// Scope = giteeOption.GetValue<string>(nameof(options.Gitee.Scope))
//};
//options.Alipay = new AlipayOptions
//{
// AppId = alipayOption.GetValue<string>(nameof(options.Alipay.AppId)),
// RedirectUrl = alipayOption.GetValue<string>(nameof(options.Alipay.RedirectUrl)),
// Scope = alipayOption.GetValue<string>(nameof(options.Alipay.Scope)),
// PrivateKey = alipayOption.GetValue<string>(nameof(options.Alipay.PrivateKey)),
// PublicKey = alipayOption.GetValue<string>(nameof(options.Alipay.PublicKey))
//};
//options.Dingtalk = new DingtalkOptions
//{
// AppId = dingtalkOption.GetValue<string>(nameof(options.Dingtalk.AppId)),
// AppSecret = dingtalkOption.GetValue<string>(nameof(options.Dingtalk.AppSecret)),
// RedirectUrl = dingtalkOption.GetValue<string>(nameof(options.Dingtalk.RedirectUrl)),
// Scope = dingtalkOption.GetValue<string>(nameof(options.Dingtalk.Scope))
//};
//options.Microsoft = new MicrosoftOptions
//{
// ClientId = microsoftOption.GetValue<string>(nameof(options.Microsoft.ClientId)),
// ClientSecret = microsoftOption.GetValue<string>(nameof(options.Microsoft.ClientSecret)),
// RedirectUrl = microsoftOption.GetValue<string>(nameof(options.Microsoft.RedirectUrl)),
// Scope = microsoftOption.GetValue<string>(nameof(options.Microsoft.Scope))
//};
//options.Weibo = new WeiboOptions
//{
// ClientId = weiboOptions.GetValue<string>(nameof(options.Weibo.ClientId)),
// ClientSecret = weiboOptions.GetValue<string>(nameof(options.Weibo.ClientSecret)),
// RedirectUrl = weiboOptions.GetValue<string>(nameof(options.Weibo.RedirectUrl)),
// Scope = weiboOptions.GetValue<string>(nameof(options.Weibo.Scope))
//};
//options.QQ = new QQOptions
//{
// ClientId = qqOptions.GetValue<string>(nameof(options.QQ.ClientId)),
// ClientSecret = qqOptions.GetValue<string>(nameof(options.QQ.ClientSecret)),
// RedirectUrl = qqOptions.GetValue<string>(nameof(options.QQ.RedirectUrl)),
// Scope = qqOptions.GetValue<string>(nameof(options.QQ.Scope))
//};
authorize = options;
});
PreConfigure <FtqqOptions>(options =>
{
var ftqqOptions = configuration.GetSection("ftqq");
Configure <FtqqOptions>(ftqqOptions);
options.ApiUrl = ftqqOptions.GetValue <string>(nameof(options.ApiUrl));
options.Token = ftqqOptions.GetValue <string>(nameof(options.Token));
ftqq = options;
});
PreConfigure <AppOptions>(options =>
{
options.Swagger = swagger;
options.Storage = storage;
options.Cors = cors;
options.Jwt = jwt;
options.Worker = worker;
options.Signature = signature;
options.TencentCloud = tencentCloud;
options.Authorize = authorize;
options.Ftqq = ftqq;
Configure <AppOptions>(item =>
{
item.Swagger = swagger;
item.Storage = storage;
item.Cors = cors;
item.Jwt = jwt;
item.Worker = worker;
item.Signature = signature;
item.TencentCloud = tencentCloud;
item.Authorize = authorize;
item.Ftqq = ftqq;
});
});
}
public SignatureHeader(SignatureOptions options) => Options = options;
public SignatureEventHandler(IOptions <SignatureOptions> signatureOptions)
{
_signatureOptions = signatureOptions.Value;
}
/// <summary>
/// Creates and instance of values controller.
/// </summary>
/// <param name="logger"></param>
public ListenerController(ILogger <ListenerController> logger, IOptionsMonitor <SignatureOptions> signatureOptions)
{
_Logger = logger;
_SignatureOptions = signatureOptions.CurrentValue;
signatureOptions.OnChange((newOpts) => { _SignatureOptions = newOpts; });
}
public static async Task Test(
TestDirectory files,
BlockSequence blockSequence,
Mutation mutation,
SignatureOptions options,
int?blockToMutate = null)
{
var rdiff = new Rdiff(files);
var timings = new List <(TestFile, TimeSpan)>();
var timer = Stopwatch.StartNew();
blockSequence.WriteTo(files.Path(TestFile.v1));
timings.Add((TestFile.v1, timer.Elapsed));
timer.Restart();
using (var v1 = files.Read(TestFile.v1))
using (var sig = files.Write(TestFile.sig))
{
await _rdiff.SignatureAsync(v1, sig, options);
}
timings.Add((TestFile.sig, timer.Elapsed));
timer.Restart();
rdiff.Signature(TestFile.v1, TestFile.rs_sig, options);
timings.Add((TestFile.rs_sig, timer.Elapsed));
await AssertEqual(files, TestFile.rs_sig, TestFile.sig);
timer.Restart();
using (var v2 = files.Write(TestFile.v2))
using (var v1 = files.Read(TestFile.v1))
{
await mutation.WriteTo(
blockSequence.Blocks(v1),
i => i == (blockToMutate ?? i),
v2);
}
timings.Add((TestFile.v2, timer.Elapsed));
timer.Restart();
using (var sig = files.Read(TestFile.sig))
using (var v2 = files.Read(TestFile.v2))
using (var delta = files.Write(TestFile.delta))
{
await _rdiff.DeltaAsync(sig, v2, delta);
}
timings.Add((TestFile.delta, timer.Elapsed));
timer.Restart();
rdiff.Delta(TestFile.sig, TestFile.v2, TestFile.rs_delta);
timings.Add((TestFile.rs_delta, timer.Elapsed));
await AssertEqual(files, TestFile.rs_delta, TestFile.delta);
timer.Restart();
using (var delta = files.Read(TestFile.delta))
using (var v1 = files.Read(TestFile.v1))
using (var patched = files.Write(TestFile.patched))
{
await _rdiff.PatchAsync(v1, delta, patched);
}
timings.Add((TestFile.patched, timer.Elapsed));
await AssertEqual(files, TestFile.v2, TestFile.patched);
foreach (var(file, duration) in timings)
{
// Console.WriteLine($"{file}: {duration}");
}
}
public int MinSize(SignatureOptions options) => Size(options);
public int Size(SignatureOptions options) => options.StrongHashLength + 4;
public async Task AllBlocks(BlockSequence blocks, Mutation mutation, SignatureOptions options)
{
using var files = new TestDirectory(nameof(AllBlocks), blocks, mutation);
await MutationTest.Test(files, blocks, mutation, options);
}
public static bool VerifyResponse <T>(this T item, Expression <Func <T, string> > signatureFieldNameSelector, Func <T, object> fieldsSelector = null, SignatureOptions options = null)
{
var o = item;
var data = o.AsDictionary();
var receivedSignature = signatureFieldNameSelector.Compile()(item);
if (fieldsSelector == null)
{
var signatureFiledName = (PropertyInfo)((MemberExpression)signatureFieldNameSelector.Body).Member;
data.Remove(signatureFiledName.Name);
}
var signature = GenerateSignature(fieldsSelector?.Invoke(item).AsDictionary() ?? data.AsDictionary(), options);
Console.WriteLine(signature);
return(Equals(receivedSignature, signature));
}
public async Task MiddleBlock(BlockSequence blocks, Mutation mutation, SignatureOptions options)
{
using var files = new TestDirectory(nameof(MiddleBlock), blocks, mutation);
await MutationTest.Test(files, blocks, mutation, options, blockToMutate : blocks.Count / 2);
}
public Account CreateAccount(bool def_acct, bool deleted, string email, IncomingMailProtocol mail_protocol,
string mail_inc_host, string mail_inc_login, string mail_inc_pass, int mail_inc_port,
string mail_out_host, string mail_out_login, string mail_out_pass, int mail_out_port,
bool mail_out_auth, string friendly_nm, bool use_friendly_nm, DefaultOrder def_order,
bool getmail_at_login, MailMode mail_mode, short mails_on_server_days, string signature,
SignatureType signature_type, SignatureOptions signature_opt, string delimiter, long mailbox_size,
FolderSyncType inboxSyncType, bool advanced_login, int id_domain, bool mailing_list, int imap_quota, string Namespace)
{
WebmailResourceManager resMan = (new WebmailResourceManagerCreator()).CreateResourceManager();
//----- validate incoming data -----
if ((email == null) || (email.Trim().Length == 0))
{
if (advanced_login)
{
throw new WebMailException(resMan.GetString("WarningEmailFieldBlank"));
}
}
Regex r = new Regex(@"[\w!#\$%\^\{}`~&'\+-=_\.]+@[\w-\.]+");
Match m = r.Match(email);
if (!m.Success)
{
throw new WebMailException("WarningCorrectEmail");
}
if ((mail_inc_login == null) || (mail_inc_login.Trim().Length == 0))
{
if (advanced_login)
{
throw new WebMailException(resMan.GetString("WarningLoginFieldBlank"));
}
}
if (mail_inc_login.IndexOfAny(new char[] { '"', '/', '\\', '*', '?', '<', '>', '|', ':' }) >= 0)
{
throw new WebMailException(resMan.GetString("WarningCorrectLogin"));
}
if (string.IsNullOrEmpty(mail_inc_pass))
{
throw new WebMailException(resMan.GetString("WarningPassBlank"));
}
if ((mail_inc_host == null) || (mail_inc_host.Trim().Length == 0))
{
throw new WebMailException(resMan.GetString("WarningIncServerBlank"));
}
r = new Regex(@"[^(\w-\.)]+");
m = r.Match(mail_inc_host);
if (m.Success)
{
if (advanced_login)
{
throw new WebMailException(resMan.GetString("WarningCorrectIncServer"));
}
}
if ((mail_inc_port < 0) || (mail_inc_port > 65535))
{
if (advanced_login)
{
throw new WebMailException(resMan.GetString("WarningIncPortNumber"));
}
}
if ((mail_out_host == null) || (mail_out_host.Trim().Length == 0))
{
if (advanced_login)
{
throw new WebMailException(resMan.GetString("WarningOutServerBlank"));
}
}
r = new Regex(@"[^(\w-\.)]+");
m = r.Match(mail_out_host);
if (m.Success)
{
if (advanced_login)
{
throw new WebMailException(resMan.GetString("WarningCorrectOutServer"));
}
}
if ((mail_out_port < 0) || (mail_out_port > 65535))
{
if (advanced_login)
{
throw new WebMailException(resMan.GetString("WarningOutPortNumber"));
}
}
//------ end validate incoming data --------
WebmailSettings settings = (new WebMailSettingsCreator()).CreateWebMailSettings();
Account newAccount = null;
DbManagerCreator creator = new DbManagerCreator();
DbManager dbMan = creator.CreateDbManager();
try
{
dbMan.Connect();
if (settings.EnableWmServer && mail_protocol == IncomingMailProtocol.WMServer)
{
string emailDomain = EmailAddress.GetDomainFromEmail(email);
string emailUser = EmailAddress.GetAccountNameFromEmail(email);
WMServerStorage storage = new WMServerStorage(null);
string[] domains = storage.GetDomainList();
bool domainExists = false;
foreach (string domain in domains)
{
if (string.Compare(emailDomain, domain, true, CultureInfo.InvariantCulture) == 0)
{
Domain dom = Domain.GetDomain(emailDomain);
if (dom != null)
{
id_domain = dom.ID;
}
WMServerUser[] users = storage.GetUserList(emailDomain);
bool userExists = false;
bool mailingListExists = false;
foreach (WMServerUser user in users)
{
if (string.Compare(emailUser, user.Name, true, CultureInfo.InvariantCulture) == 0)
{
if (string.Compare("U", user.Type, true, CultureInfo.InvariantCulture) == 0)
{
userExists = true;
}
else
{
mailingListExists = true;
}
break;
}
}
if (!userExists && !mailing_list || !mailingListExists && mailing_list)
{
if (!mailingListExists)
{
storage.AddUser(emailDomain, emailUser, mail_inc_pass);
}
else
{
throw new WebMailException(resMan.GetString("ErrorPOP3IMAP4Auth"));
}
}
domainExists = true;
break;
}
}
if (!domainExists)
{
throw new WebMailException(resMan.GetString("ErrorDomainExist"));
}
}
if (mail_protocol == IncomingMailProtocol.WMServer)
{
delimiter = ".";
}
newAccount = dbMan.CreateAccount(_id, def_acct, deleted, email, mail_protocol, mail_inc_host,
mail_inc_login, mail_inc_pass, mail_inc_port, mail_out_host, mail_out_login, mail_out_pass,
mail_out_port, mail_out_auth, friendly_nm, use_friendly_nm, def_order, getmail_at_login,
mail_mode, mails_on_server_days, signature, signature_type, signature_opt, delimiter,
mailbox_size, id_domain, mailing_list, imap_quota, Namespace);
newAccount.UserOfAccount = this;
dbMan.DbAccount = newAccount;
FileSystem fs = new FileSystem(email, newAccount.ID, true);
if (mail_protocol != IncomingMailProtocol.WMServer)
{
fs.CreateAccount();
}
if (mail_protocol == IncomingMailProtocol.Pop3)
{
if (settings.AllowDirectMode && settings.DirectModeIsDefault)
{
inboxSyncType = FolderSyncType.DirectMode;
}
// -- this fix for gmail pop3 --
if (mail_inc_host == "pop.gmail.com")
{
inboxSyncType = FolderSyncType.AllEntireMessages;
}
// -----------------------------
if (!settings.StoreMailsInDb)
{
fs.CreateFolder(Constants.FolderNames.Inbox);
}
dbMan.CreateFolder(newAccount.ID, -1, FolderType.Inbox, Constants.FolderNames.Inbox, Constants.FolderNames.Inbox, inboxSyncType, false, 0);
if (!settings.StoreMailsInDb)
{
fs.CreateFolder(Constants.FolderNames.SentItems);
}
dbMan.CreateFolder(newAccount.ID, -1, FolderType.SentItems, Constants.FolderNames.SentItems, Constants.FolderNames.SentItems, FolderSyncType.DontSync, false, 1);
if (!settings.StoreMailsInDb)
{
fs.CreateFolder(Constants.FolderNames.Drafts);
}
dbMan.CreateFolder(newAccount.ID, -1, FolderType.Drafts, Constants.FolderNames.Drafts, Constants.FolderNames.Drafts, FolderSyncType.DontSync, false, 2);
if (!settings.StoreMailsInDb)
{
fs.CreateFolder(Constants.FolderNames.Spam);
}
dbMan.CreateFolder(newAccount.ID, -1, FolderType.Spam, Constants.FolderNames.Spam, Constants.FolderNames.Spam, FolderSyncType.DontSync, false, 3);
if (!settings.StoreMailsInDb)
{
fs.CreateFolder(Constants.FolderNames.Trash);
}
dbMan.CreateFolder(newAccount.ID, -1, FolderType.Trash, Constants.FolderNames.Trash, Constants.FolderNames.Trash, FolderSyncType.DontSync, false, 4);
}
else if (mail_protocol == IncomingMailProtocol.WMServer)
{
MailServerStorage wmServerStorage = MailServerStorageCreator.CreateMailServerStorage(newAccount);
try
{
wmServerStorage.Connect();
FolderCollection fc = wmServerStorage.GetFolders();
Folder fld = fc[FolderType.SentItems];
if (fld == null)
{
string fullPath = newAccount.Delimiter + Constants.FolderNames.SentItems;
const string name = Constants.FolderNames.SentItems;
if (!settings.StoreMailsInDb)
{
fs.CreateFolder(Constants.FolderNames.SentItems);
}
fld = new Folder(newAccount.ID, -1, fullPath, name);
wmServerStorage.CreateFolder(fld);
dbMan.CreateFolder(newAccount.ID, -1, FolderType.SentItems, name, fullPath, FolderSyncType.AllHeadersOnly, false, 1);
}
fld = fc[FolderType.Drafts];
if (fld == null)
{
string fullPath = newAccount.Delimiter + Constants.FolderNames.Drafts;
const string name = Constants.FolderNames.Drafts;
if (!settings.StoreMailsInDb)
{
fs.CreateFolder(Constants.FolderNames.Drafts);
}
fld = new Folder(newAccount.ID, -1, fullPath, name);
wmServerStorage.CreateFolder(fld);
dbMan.CreateFolder(newAccount.ID, -1, FolderType.Drafts, name, fullPath, FolderSyncType.AllHeadersOnly, false, 2);
}
fld = fc[FolderType.Spam];
if (fld == null)
{
string fullPath = newAccount.Delimiter + Constants.FolderNames.Spam;
const string name = Constants.FolderNames.Spam;
if (!settings.StoreMailsInDb)
{
fs.CreateFolder(Constants.FolderNames.Spam);
}
fld = new Folder(newAccount.ID, -1, fullPath, name);
wmServerStorage.CreateFolder(fld);
dbMan.CreateFolder(newAccount.ID, -1, FolderType.Spam, name, fullPath, FolderSyncType.AllHeadersOnly, false, 3);
}
fld = fc[FolderType.Trash];
if (fld == null)
{
string fullPath = newAccount.Delimiter + Constants.FolderNames.Trash;
const string name = Constants.FolderNames.Trash;
if (!settings.StoreMailsInDb)
{
fs.CreateFolder(Constants.FolderNames.Trash);
}
fld = new Folder(newAccount.ID, -1, fullPath, name);
wmServerStorage.CreateFolder(fld);
dbMan.CreateFolder(newAccount.ID, -1, FolderType.Trash, name, fullPath, FolderSyncType.AllHeadersOnly, false, 4);
}
fld = fc[FolderType.Quarantine];
if (fld == null)
{
string fullPath = newAccount.Delimiter + Constants.FolderNames.Quarantine;
const string name = Constants.FolderNames.Quarantine;
if (!settings.StoreMailsInDb)
{
fs.CreateFolder(Constants.FolderNames.Quarantine);
}
fld = new Folder(newAccount.ID, -1, fullPath, name);
wmServerStorage.CreateFolder(fld);
dbMan.CreateFolder(newAccount.ID, -1, FolderType.Quarantine, name, fullPath, FolderSyncType.AllHeadersOnly, false, 5);
}
dbMan.CreateFoldersTree(fc);
}
catch (Exception ex)
{
Log.WriteException(ex);
throw new WebMailException(ex);
}
}
else if (mail_protocol == IncomingMailProtocol.Imap4)
{
MailServerStorage imapStorage = MailServerStorageCreator.CreateMailServerStorage(newAccount);
try
{
imapStorage.Connect();
FolderCollection fc = imapStorage.GetFolders();
Folder fld = fc[FolderType.Inbox];
if (fld != null)
{
fld.SyncType = FolderSyncType.DirectMode;
}
// if (settings.AllowDirectMode && settings.DirectModeIsDefault)
// {
fc.ReSetSyncTypeToDirectMode();
// }
fld = fc[FolderType.Drafts];
if (fld == null)
{
if (!settings.StoreMailsInDb)
{
fs.CreateFolder(Constants.FolderNames.Drafts);
}
dbMan.CreateFolder(newAccount.ID, -1, FolderType.Drafts, Constants.FolderNames.Drafts, Constants.FolderNames.Drafts, FolderSyncType.DontSync, false, 2);
}
fld = fc[FolderType.SentItems];
if (fld == null)
{
if (!settings.StoreMailsInDb)
{
fs.CreateFolder(Constants.FolderNames.SentItems);
}
dbMan.CreateFolder(newAccount.ID, -1, FolderType.SentItems, Constants.FolderNames.SentItems, Constants.FolderNames.SentItems, FolderSyncType.DontSync, false, 1);
}
fld = fc[FolderType.Spam];
if (fld == null)
{
if (!settings.StoreMailsInDb)
{
fs.CreateFolder(Constants.FolderNames.Spam);
}
dbMan.CreateFolder(newAccount.ID, -1, FolderType.Spam, Constants.FolderNames.Spam, Constants.FolderNames.Spam, FolderSyncType.DontSync, false, 3);
}
fld = fc[FolderType.Trash];
if (fld == null && settings.Imap4DeleteLikePop3)
{
if (!settings.StoreMailsInDb)
{
fs.CreateFolder(Constants.FolderNames.Trash);
}
dbMan.CreateFolder(newAccount.ID, -1, FolderType.Trash, Constants.FolderNames.Trash, Constants.FolderNames.Trash, FolderSyncType.DontSync, false, 4);
}
newAccount.Delimiter = (fc.Count > 0) ? fc[0].ImapFolder.Delimiter : newAccount.Delimiter;
if (!settings.StoreMailsInDb)
{
fs.CreateFoldersTree(fc);
}
dbMan.CreateFoldersTree(fc);
}
catch (Exception ex)
{
Log.WriteException(ex);
throw new WebMailException(ex);
}
finally
{
imapStorage.Disconnect();
}
}
}
catch (IOException ex)
{
Log.WriteException(ex);
throw new WebMailException(ex);
}
catch (UnauthorizedAccessException ex)
{
Log.WriteException(ex);
throw new WebMailException(ex);
}
catch (WebMailException ex)
{
Log.WriteException(ex);
if (newAccount != null)
{
if (dbMan.IsConnected)
{
dbMan.DeleteAccount(newAccount.ID);
}
else
{
dbMan.Connect();
dbMan.DeleteAccount(newAccount.ID);
}
}
throw;
}
finally
{
dbMan.Disconnect();
}
return(newAccount);
}
