public void FullyQualifiedDomainNameVsIndividualLabels() { var idn = new IdnMapping(); // ASCII only code points Assert.Equal("\u0061\u0062\u0063", idn.GetAscii("\u0061\u0062\u0063")); // non-ASCII only code points Assert.Equal("xn--d9juau41awczczp", idn.GetAscii("\u305D\u306E\u30B9\u30D4\u30FC\u30C9\u3067")); // ASCII and non-ASCII code points Assert.Equal("xn--de-jg4avhby1noc0d", idn.GetAscii("\u30D1\u30D5\u30A3\u30FC\u0064\u0065\u30EB\u30F3\u30D0")); // Fully Qualified Domain Name Assert.Equal("abc.xn--d9juau41awczczp.xn--de-jg4avhby1noc0d", idn.GetAscii("\u0061\u0062\u0063.\u305D\u306E\u30B9\u30D4\u30FC\u30C9\u3067.\u30D1\u30D5\u30A3\u30FC\u0064\u0065\u30EB\u30F3\u30D0")); }
public void UseStd3AsciiRules_NonLDH_ASCII_Codepoint() { var idnStd3False = new IdnMapping { UseStd3AsciiRules = false }; string unicode = "\u0030\u002D\u0045\u007A"; Assert.Equal(unicode, idnStd3False.GetAscii(unicode), ignoreCase: true); }
[InlineData("\u002D\u0062\u002D", true)] // Leading and trailing hyphen minus public void UseStd3AsciiRules_ChangesGetAsciiBehavior(string unicode, bool containsInvalidHyphen) { var idnStd3False = new IdnMapping { UseStd3AsciiRules = false }; var idnStd3True = new IdnMapping { UseStd3AsciiRules = true }; if (containsInvalidHyphen && !s_isWindows) { // ICU always fails on leading/trailing hyphens regardless of the Std3 rules option. Assert.Throws<ArgumentException>("unicode", () => idnStd3False.GetAscii(unicode)); } else { Assert.Equal(unicode, idnStd3False.GetAscii(unicode)); } Assert.Throws<ArgumentException>("unicode", () => idnStd3True.GetAscii(unicode)); }
[InlineData("\u002D\u0062\u002D", true)] // Leading and trailing hyphen minus public void UseStd3AsciiRules_ChangesGetAsciiBehavior(string unicode, bool containsInvalidHyphen) { var idnStd3False = new IdnMapping { UseStd3AsciiRules = false }; var idnStd3True = new IdnMapping { UseStd3AsciiRules = true }; if (containsInvalidHyphen && !s_isWindows) { // ICU always fails on leading/trailing hyphens regardless of the Std3 rules option. Assert.Throws<ArgumentException>("unicode", () => idnStd3False.GetAscii(unicode)); } else { Assert.Equal(unicode, idnStd3False.GetAscii(unicode)); } ArgumentException ae = Assert.Throws<ArgumentException>(() => idnStd3True.GetAscii(unicode)); // sometimes the desktop returns "Unicode" instead of "unicode" for the parameter name. Assert.Equal("unicode", ae.ParamName, ignoreCase: true); }
public void EmbeddedNulls() { var idn = new IdnMapping(); Assert.Throws<ArgumentException>(() => idn.GetAscii("\u0101\u0000")); Assert.Throws<ArgumentException>(() => idn.GetAscii("\u0101\u0000", 0)); Assert.Throws<ArgumentException>(() => idn.GetAscii("\u0101\u0000", 0, 2)); Assert.Throws<ArgumentException>(() => idn.GetAscii("\u0101\u0000\u0101")); Assert.Throws<ArgumentException>(() => idn.GetAscii("\u0101\u0000\u0101", 0)); Assert.Throws<ArgumentException>(() => idn.GetAscii("\u0101\u0000\u0101", 0, 3)); Assert.Throws<ArgumentException>(() => idn.GetAscii("\u0101\u0000\u0101\u0000")); Assert.Throws<ArgumentException>(() => idn.GetAscii("\u0101\u0000\u0101\u0000", 0)); Assert.Throws<ArgumentException>(() => idn.GetAscii("\u0101\u0000\u0101\u0000", 0, 4)); Assert.Throws<ArgumentException>(() => idn.GetUnicode("abc\u0000", 0, 4)); Assert.Throws<ArgumentException>(() => idn.GetUnicode("ab\u0000c", 0, 4)); }
public void GetAscii_Invalid() { foreach (var entry in Factory.GetDataset()) { if (!entry.GetASCIIResult.Success) { var map = new IdnMapping(); Assert.Throws<ArgumentException>(() => map.GetAscii(entry.Source)); } } }
public static void GetUnicode_Invalid(IdnMapping idnMapping, string ascii, int index, int count, Type exceptionType) { if (ascii == null || index + count == ascii.Length) { if (ascii == null || index == 0) { Assert.Throws(exceptionType, () => idnMapping.GetUnicode(ascii)); } Assert.Throws(exceptionType, () => idnMapping.GetUnicode(ascii, index)); } Assert.Throws(exceptionType, () => idnMapping.GetAscii(ascii, index, count)); }
public void GetAscii_Success() { foreach (var entry in Factory.GetDataset()) { if (entry.GetASCIIResult.Success) { var map = new IdnMapping(); var asciiResult = map.GetAscii(entry.Source); Assert.Equal(entry.GetASCIIResult.Value, asciiResult, StringComparer.OrdinalIgnoreCase); } } }
public static void GetAsciiThrows() { IdnMapping idnMapping = new IdnMapping(); Assert.Throws<ArgumentNullException>("unicode", () => idnMapping.GetAscii(null, -5)); Assert.Throws<ArgumentNullException>("unicode", () => idnMapping.GetAscii(null, -5, -10)); Assert.Throws<ArgumentOutOfRangeException>("index", () => idnMapping.GetAscii("abc", -5, -10)); Assert.Throws<ArgumentOutOfRangeException>("count", () => idnMapping.GetAscii("abc", 10, -10)); Assert.Throws<ArgumentOutOfRangeException>("byteIndex", () => idnMapping.GetAscii("abc", 4, 99)); Assert.Throws<ArgumentOutOfRangeException>("unicode", () => idnMapping.GetAscii("abc", 2, 2)); Assert.Throws<ArgumentException>("unicode", () => idnMapping.GetAscii("abc", 3, 0)); }
private string DomainMapper(Match match) { // IdnMapping class with default property values. IdnMapping idn = new IdnMapping(); string domainName = match.Groups[2].Value; try { domainName = idn.GetAscii(domainName); } catch (ArgumentException) { invalid = true; } return match.Groups[1].Value + domainName; }
/// <summary> /// Creates a valid ASCII domain name out of a Unicode one. /// </summary> /// <param name="match">Used by the Regex class.</param> /// <returns>A valid domain, if one can be generated.</returns> private string DomainMapper(Match match) { // IdnMapping class with default property values. IdnMapping idn = new IdnMapping(); string domainName = match.Groups[2].Value; try { domainName = idn.GetAscii(domainName); } catch (ArgumentException) { IsEmailValid = true; // This causes ValidateEmail to fail. } return(match.Groups[1].Value + domainName); }
public bool IsValidEmail(string Email) { if (string.IsNullOrWhiteSpace(Email)) { return(false); } try { // Normalize the domain Email = Regex.Replace(Email, @"(@)(.+)$", DomainMapper, RegexOptions.None, TimeSpan.FromMilliseconds(200)); // Examines the domain part of the email and normalizes it. string DomainMapper(Match match) { // Use IdnMapping class to convert Unicode domain names. var idn = new IdnMapping(); // Pull out and process domain name (throws ArgumentException on invalid) var domainName = idn.GetAscii(match.Groups[2].Value); return(match.Groups[1].Value + domainName); } } catch (RegexMatchTimeoutException e) { return(false); } catch (ArgumentException e) { return(false); } try { return(Regex.IsMatch(Email, @"^(?("")("".+?(?<!\\)""@)|(([0-9a-z]((\.(?!\.))|[-!#\$%&'\*\+/=\?\^`\{\}\|~\w])*)(?<=[0-9a-z])@))" + @"(?(\[)(\[(\d{1,3}\.){3}\d{1,3}\])|(([0-9a-z][-0-9a-z]*[0-9a-z]*\.)+[a-z0-9][\-a-z0-9]{0,22}[a-z0-9]))$", RegexOptions.IgnoreCase, TimeSpan.FromMilliseconds(250))); } catch (RegexMatchTimeoutException) { return(false); } }
/// <summary> /// Needed to support chinese character support /// </summary> /// <param name="match"></param> /// <returns></returns> private static string DomainMapper(Match match) { // IdnMapping class with default property values. var idn = new IdnMapping(); var domainName = match.Groups[2].Value; try { domainName = idn.GetAscii(domainName); } catch (ArgumentException) { _invalid = true; } return(match.Groups[1].Value + domainName); }
public static ValidationResponse Email(string email) { if (string.IsNullOrWhiteSpace(email)) { return(ValidationResponse.Empty); } try { email = Regex.Replace(email, @"(@)(.+)$", DomainMapper, RegexOptions.None, TimeSpan.FromMilliseconds(200)); string DomainMapper(Match match) { var idn = new IdnMapping(); var domainName = idn.GetAscii(match.Groups[2].Value); return(match.Groups[1].Value + domainName); } } catch (RegexMatchTimeoutException) { return(ValidationResponse.Invalid); } catch (ArgumentException) { return(ValidationResponse.Invalid); } try { var regex = @"^(?("")("".+?(?<!\\)""@)|(([0-9a-z]((\.(?!\.))|[-!#\$%&'\*\+/=\?\^`\{\}\|~\w])*)(?<=[0-9a-z])@))(?(\[)(\[(\d{1,3}\.){3}\d{1,3}\])|(([0-9a-z][-0-9a-z]*[0-9a-z]*\.)+[a-z0-9][\-a-z0-9]{0,22}[a-z0-9]))$"; if (Regex.IsMatch(email, regex, RegexOptions.IgnoreCase, TimeSpan.FromMilliseconds(250))) { return(ValidationResponse.Valid); } else { return(ValidationResponse.Invalid); } } catch (RegexMatchTimeoutException) { return(ValidationResponse.Invalid); } }
public void SimpleValidationTests() { var idn = new IdnMapping(); Assert.Equal("xn--yda", idn.GetAscii("\u0101")); Assert.Equal("xn--yda", idn.GetAscii("\u0101", 0)); Assert.Equal("xn--yda", idn.GetAscii("\u0101", 0, 1)); Assert.Equal("xn--aa-cla", idn.GetAscii("\u0101\u0061\u0041")); Assert.Equal("xn--ab-dla", idn.GetAscii("\u0061\u0101\u0062")); Assert.Equal("xn--ab-ela", idn.GetAscii("\u0061\u0062\u0101")); }
internal List <IISBindingOption> GetBindings() { if (_iisClient.Version.Major == 0) { _log.Warning("IIS not found. Skipping scan."); return(new List <IISBindingOption>()); } // Get all bindings matched together with their respective sites _log.Debug("Scanning IIS site bindings for hosts"); var siteBindings = _iisClient.WebSites. SelectMany(site => site.Bindings, (site, binding) => new { site, binding }). Where(sb => !string.IsNullOrWhiteSpace(sb.binding.Host)). ToList(); // Option: hide http bindings when there are already https equivalents var https = siteBindings.Where(sb => sb.binding.Protocol == "https" || sb.site.Bindings.Any(other => other.Protocol == "https" && string.Equals(sb.binding.Host, other.Host, StringComparison.InvariantCultureIgnoreCase))).ToList(); var targets = siteBindings. Select(sb => new { host = sb.binding.Host.ToLower(), sb.site, sb.binding, https = https.Contains(sb) }). Select(sbi => new IISBindingOption { SiteId = sbi.site.Id, HostUnicode = sbi.host, HostPunycode = _idnMapping.GetAscii(sbi.host), Port = sbi.binding.Port, Protocol = sbi.binding.Protocol, Https = sbi.https }). DistinctBy(t => t.HostUnicode + t.SiteId). OrderBy(t => t.HostUnicode). ToList(); return(targets); }
public Boolean ValidarEmail(string email) { if (string.IsNullOrWhiteSpace(email)) { return(false); } try { // normaliza el dominio email = Regex.Replace(email, @"(@)(.+)$", DomainMapper, RegexOptions.None, TimeSpan.FromMilliseconds(200)); // Examina el dominio y lo normaliza string DomainMapper(Match match) { // Utilice la clase IdnMapping para convertir nombres de dominio Unicode var idn = new IdnMapping(); // Extrae y procesa el nombre del dominio var domainName = idn.GetAscii(match.Groups[2].Value); return(match.Groups[1].Value + domainName); } } catch (RegexMatchTimeoutException e) { return(false); } catch (ArgumentException e) { return(false); } try { return(Regex.IsMatch(email, @"^(?("")("".+?(?<!\\)""@)|(([0-9a-z]((\.(?!\.))|[-!#\$%&'\*\+/=\?\^`\{\}\|~\w])*)(?<=[0-9a-z])@))" + @"(?(\[)(\[(\d{1,3}\.){3}\d{1,3}\])|(([0-9a-z][-0-9a-z]*[0-9a-z]*\.)+[a-z0-9][\-a-z0-9]{0,22}[a-z0-9]))$", RegexOptions.IgnoreCase, TimeSpan.FromMilliseconds(250))); } catch (RegexMatchTimeoutException) { return(false); } }
public static void Main() { /* * Define a domain name consisting of the labels: GREEK SMALL LETTER * PI (U+03C0); IDEOGRAPHIC FULL STOP (U+3002); GREEK SMALL LETTER * THETA (U+03B8); FULLWIDTH FULL STOP (U+FF0E); and "com". */ string name = "\u03C0\u3002\u03B8\uFF0Ecom"; string international; string nonInternational; string msg1 = "the original non-internationalized \ndomain name:"; string msg2 = "Allow unassigned characters?: {0}"; string msg3 = "Use non-internationalized rules?: {0}"; string msg4 = "Convert the non-internationalized domain name to international format..."; string msg5 = "Display the encoded domain name:\n\"{0}\""; string msg6 = "the encoded domain name:"; string msg7 = "Convert the internationalized domain name to non-international format..."; string msg8 = "the reconstituted non-internationalized \ndomain name:"; string msg9 = "Visually compare the code points of the reconstituted string to the " + "original.\n" + "Note that the reconstituted string contains standard label " + "separators (U+002e)."; // ---------------------------------------------------------------------------- CodePoints(name, msg1); // ---------------------------------------------------------------------------- IdnMapping idn = new IdnMapping(); Console.WriteLine(msg2, idn.AllowUnassigned); Console.WriteLine(msg3, idn.UseStd3AsciiRules); Console.WriteLine(); // ---------------------------------------------------------------------------- Console.WriteLine(msg4); international = idn.GetAscii(name, 0, name.Length); Console.WriteLine(msg5, international); Console.WriteLine(); CodePoints(international, msg6); // ---------------------------------------------------------------------------- Console.WriteLine(msg7); nonInternational = idn.GetUnicode(international, 0, international.Length); CodePoints(nonInternational, msg8); Console.WriteLine(msg9); }
public static bool IsValidEmail(string email) { if (string.IsNullOrWhiteSpace(email)) { return(false); } try { // Normalizar el dominio email = Regex.Replace(email, @"(@)(.+)$", DomainMapper, RegexOptions.None, TimeSpan.FromMilliseconds(200)); // Examina la parte del dominio del correo electrónico y la normaliza. string DomainMapper(Match match) { // Utilice la clase IdnMapping para convertir nombres de dominio Unicode. var idn = new IdnMapping(); // Extraiga y procese el nombre de dominio (arroja ArgumentException en inválido) string domainName = idn.GetAscii(match.Groups[2].Value); return(match.Groups[1].Value + domainName); } } catch (RegexMatchTimeoutException e) { return(false); } catch (ArgumentException e) { return(false); } try { return(Regex.IsMatch(email, @"^[^@\s]+@[^@\s]+\.[^@\s]+$", RegexOptions.IgnoreCase, TimeSpan.FromMilliseconds(250))); } catch (RegexMatchTimeoutException) { return(false); } }
public static bool IsValidEmail(string email) { if (string.IsNullOrWhiteSpace(email)) { return(false); } try { // Normalize the domain email = Regex.Replace(email, @"(@)(.+)$", DomainMapper, RegexOptions.None, TimeSpan.FromMilliseconds(200)); // Examines the domain part of the email and normalizes it. string DomainMapper(Match match) { // Use IdnMapping class to convert Unicode domain names. var idn = new IdnMapping(); // Pull out and process domain name (throws ArgumentException on invalid) string domainName = idn.GetAscii(match.Groups[2].Value); return(match.Groups[1].Value + domainName); } } catch (RegexMatchTimeoutException) { return(false); } catch (ArgumentException) { return(false); } try { return(Regex.IsMatch(email, @"^[^@\s]+@[^@\s]+\.[^@\s]+$", RegexOptions.IgnoreCase, TimeSpan.FromMilliseconds(250))); } catch (RegexMatchTimeoutException) { return(false); } }
/// <summary> /// Проверка корректности электронной почты. /// </summary> /// <param name="email">Электронаня почта.</param> /// <returns>Если электронная почта введена корректно - true, в противном случае вернёт false.</returns> public static bool IsValidEmail(string email) { if (string.IsNullOrWhiteSpace(email)) { return(false); } try { // Нормализация домена. email = Regex.Replace(email, @"(@)(.+)$", DomainMapper, RegexOptions.None, TimeSpan.FromMilliseconds(200)); // Изучает домен электронной почты и нормализует её. string DomainMapper(Match match) { var idn = new IdnMapping(); // Вытащить и обработать доменное имя (создает недопустимое ArgumentException) var domainName = idn.GetAscii(match.Groups[2].Value); return(match.Groups[1].Value + domainName); } } catch (RegexMatchTimeoutException e) { return(false); } catch (ArgumentException e) { return(false); } try { return(Regex.IsMatch(email, @"^(?("")("".+?(?<!\\)""@)|(([0-9a-z]((\.(?!\.))|[-!#\$%&'\*\+/=\?\^`\{\}\|~\w])*)(?<=[0-9a-z])@))" + @"(?(\[)(\[(\d{1,3}\.){3}\d{1,3}\])|(([0-9a-z][-0-9a-z]*[0-9a-z]*\.)+[a-z0-9][\-a-z0-9]{0,22}[a-z0-9]))$", RegexOptions.IgnoreCase, TimeSpan.FromMilliseconds(250))); } catch (RegexMatchTimeoutException) { return(false); } }
public bool IsValidEmail(string input) { if (input.IsNullOrEmptyOrWhiteSpace()) { return(false); } _isValid = true; string replaced; try { replaced = _emailPrimaryRegex.Replace(input, DomainMapper); } catch (RegexMatchTimeoutException) { return(false); } if (!_isValid) { return(false); } try { return(_emailSecondaryRegex.IsMatch(replaced)); } catch (RegexMatchTimeoutException) { return(false); } string DomainMapper(Match match) { var domainName = match.Groups[2].Value; try { domainName = _idn.GetAscii(domainName); } catch (ArgumentException) { _isValid = false; } return(match.Groups[1].Value + domainName); } }
private string DomainMapper(Match match) { // IDNMAPPING CLASS WITH DEFAULT PROPERTY VALUES IdnMapping idn = new IdnMapping(); string domainName = match.Groups[2].Value; try { domainName = idn.GetAscii(domainName); } catch (ArgumentException) { inValid = true; } return(match.Groups[1].Value + domainName); }
/// <summary> /// Generates a URL with optional scheme, host and path. Example: "http://thiel.com/chauncey_simonis" /// </summary> /// <param name="host">Optional host name to use. Example: "example.com"</param> /// <param name="path">Optional path to use: Example: "/clotilde.swift".</param> /// <param name="scheme">Optional scheme. Example: "https". Default is "http".</param> /// <returns>A URL with optional scheme, host and path</returns> /// <remarks>The implementation does not check if any of the values make sense, e.g. if the given scheme /// even exists.</remarks> /// <exception cref="ArgumentOutOfRangeException">If scheme or host is an empty string.</exception> public static string Url(string host = null, string path = null, string scheme = "http") { var idn = new IdnMapping(); host = host ?? idn.GetAscii(DomainName()); var percentEncodedUserName = Uri.EscapeDataString(UserName()); path = path ?? $"/{percentEncodedUserName}"; if (string.IsNullOrWhiteSpace(scheme)) { throw new ArgumentOutOfRangeException(nameof(scheme), "Must not be empty string or white spaces only."); } if (string.IsNullOrWhiteSpace(host)) { throw new ArgumentOutOfRangeException(nameof(host), "Must not be empty string or white spaces only."); } return($"{scheme}://{host}{path}"); }
public void GetAscii_Success() { Assert.All(Factory.GetDataset().Where(e => e.ASCIIResult.Success), entry => { try { var map = new IdnMapping(); var asciiResult = map.GetAscii(entry.Source); Assert.Equal(entry.ASCIIResult.Value, asciiResult, StringComparer.OrdinalIgnoreCase); } catch (ArgumentException) { string actualCodePoints = GetCodePoints(entry.Source); string expectedCodePoints = GetCodePoints(entry.ASCIIResult.Value); throw new Exception($"Expected IdnMapping.GetAscii(\"{actualCodePoints}\" to return \"{expectedCodePoints}\"."); } }); }
/// <summary> /// /// </summary> /// <param name="match"></param> /// <returns></returns> private string DomainMapper(Match match) { // IdnMapping class with default property values. IdnMapping idn = new IdnMapping(); string domainName = match.Groups[2].Value; try { domainName = idn.GetAscii(domainName); } catch (Exception e) { LogUtil.Log(e.Message + Environment.NewLine + e.StackTrace); throw e; } return(match.Groups[1].Value + domainName); }
private void ButtonGo_Click(object sender, EventArgs e) { // This code section extracts the protocol, host section and extension of the string that is // entered in the address control // A more sophisticated verification is recommended to make this adapt for all possible erroneous input Regex r = new Regex(@"(?<proto>\w+)://(?<host>[\w.]+)/*(?<ext>\S*)", RegexOptions.Compiled); string proto = r.Match(this.textBoxAddress.Text).Result("${proto}"); string host = r.Match(this.textBoxAddress.Text).Result("${host}"); string ext = r.Match(this.textBoxAddress.Text).Result("${ext}"); // Convert the entered IDN host name to Punycode IdnMapping mapping = new IdnMapping(); string puny = mapping.GetAscii(host); // Assemble the URL and navigate to the specified site this.textBoxPunycode.Text = proto + "://" + puny + "/" + ext; this.webBrowser1.Navigate(this.textBoxPunycode.Text); }
private string DomainMapper(System.Text.RegularExpressions.Match match) { logger.Log(LogLevel.Debug, "Trace:: RegexUtilities.DomainMapper(match: " + match + ")"); // IdnMapping class with default property values. var idn = new IdnMapping(); string domainName = match.Groups[2].Value; try { domainName = idn.GetAscii(domainName); } catch (ArgumentException) { invalid = true; } return(match.Groups[1].Value + domainName); }
string DomainMapper(Match match) { bool invalid = false; // IdnMapping class with default property values. IdnMapping idn = new IdnMapping(); string domainName = match.Groups[2].Value; try { domainName = idn.GetAscii(domainName); } catch (ArgumentException) { invalid = true; } return(match.Groups[1].Value + domainName); }
private string DomainMapper(Match match) // Resolves unicode domain names when sending an email { // IdnMapping class with default property values. IdnMapping idn = new IdnMapping(); string domainName = match.Groups[2].Value; try { domainName = idn.GetAscii(domainName); } catch (ArgumentException ae) { // The email is invalid so throw exception // WHY? throw ae; } return(match.Groups[1].Value + domainName); }
public PendingAuthorization BeginRegistrationAndValidation(CertRequestConfig requestConfig, string identifierAlias, string challengeType = "http-01", string domain = null) { //if no alternative domain specified, use the primary domains as the subject if (domain == null) { domain = requestConfig.PrimaryDomain; } // if (GetIdentifier(identifierAlias) == null) //if an identifier exists for the same dns in vault, remove it to avoid confusion this.DeleteIdentifierByDNS(domain); // ACME service requires international domain names in ascii mode, regiser the new // identifier with Lets Encrypt var authState = ACMESharpUtils.NewIdentifier(identifierAlias, idnMapping.GetAscii(domain)); var identifier = this.GetIdentifier(identifierAlias, reloadVaultConfig: true); //FIXME: when validating subsequent SAN names in parallel request mode, the identifier is null? if (identifier != null && identifier.Authorization != null && identifier.Authorization.IsPending()) { ACMESharpUtils.CompleteChallenge(identifier.Alias, challengeType, Handler: "manual", Regenerate: true, Repeat: true); //get challenge info ReloadVaultConfig(); identifier = GetIdentifier(identifierAlias); var challengeInfo = identifier.Challenges.FirstOrDefault(c => c.Value.Type == challengeType).Value; //identifier challenege specification is now ready for use to prepare and answer for LetsEncrypt to check return(new PendingAuthorization() { Challenge = GetAuthorizeChallengeItemFromAuthChallenge(challengeInfo), Identifier = GetDomainIdentifierItemFromIdentifierInfo(identifier), TempFilePath = "", ExtensionlessConfigCheckedOK = false }); } else { //identifier is null or already valid (previously authorized) return(new PendingAuthorization() { Challenge = null, Identifier = GetDomainIdentifierItemFromIdentifierInfo(identifier), TempFilePath = "", ExtensionlessConfigCheckedOK = false }); } }
private bool IsValidEmail() { var email = Value; if (string.IsNullOrWhiteSpace(email)) { return(false); } try { email = Regex.Replace(email, @"(@)(.+)$", DomainMapper, RegexOptions.None, TimeSpan.FromMilliseconds(200)); string DomainMapper(Match match) { var idn = new IdnMapping(); var domainName = idn.GetAscii(match.Groups[2].Value); return(match.Groups[1].Value + domainName); } } catch (RegexMatchTimeoutException e) { return(false); } catch (ArgumentException e) { return(false); } try { return(Regex.IsMatch(email, @"^(?("")("".+?(?<!\\)""@)|(([0-9a-z]((\.(?!\.))|[-!#\$%&'\*\+/=\?\^`\{\}\|~\w])*)(?<=[0-9a-z])@))" + @"(?(\[)(\[(\d{1,3}\.){3}\d{1,3}\])|(([0-9a-z][-0-9a-z]*[0-9a-z]*\.)+[a-z0-9][\-a-z0-9]{0,22}[a-z0-9]))$", RegexOptions.IgnoreCase, TimeSpan.FromMilliseconds(250))); } catch (RegexMatchTimeoutException) { return(false); } }
/* * public static bool VerifyRegNr(string regNr) * { * regNr = System.Text.RegularExpressions.Regex.Match * }*/ public static bool VerifyEmail(string email) { if (string.IsNullOrWhiteSpace(email)) { return(false); } try { // Normaliserr domänen email = System.Text.RegularExpressions.Regex.Replace(email, @"(@)(.+)$", DomainMapper, RegexOptions.None, TimeSpan.FromMilliseconds(200)); // Undersöker domändelen av e-postmeddelandet och normaliserar det string DomainMapper(Match match) { // Använd IdnMapping-klassen för att konvertera Unicode-domännamn. var idn = new IdnMapping(); // Dra ut och bearbeta domännamn(kastar ArgumentException på ogiltigt) string domainName = idn.GetAscii(match.Groups[2].Value); return(match.Groups[1].Value + domainName); } } catch (RegexMatchTimeoutException e) { return(false); } catch (ArgumentException e) { return(false); } try { return(System.Text.RegularExpressions.Regex.IsMatch(email, @"^[^@\s]+@[^@\s]+\.[^@\s]+$", RegexOptions.IgnoreCase, TimeSpan.FromMilliseconds(250))); } catch (RegexMatchTimeoutException) { return(false); } }
/// <summary> /// Assists in domain mapping. /// </summary> /// <param name="match"> /// The match. /// </param> /// <returns> /// The <see cref="string"/>. /// </returns> private string DomainMapper(Match match) { // IdnMapping class with default property values. var idn = new IdnMapping(); var domainName = match.Groups[2].Value; try { domainName = idn.GetAscii(domainName); } catch (ArgumentException) { MultiLogHelper.Debug <EmailValidationHelper>("Invalid email address"); this.invalid = true; } return(match.Groups[1].Value + domainName); }
public static bool IsIPv4AddressOrFQDN(this string value, string propertyName, out string address, bool allowEmptyString = false, bool throwExceptionOnMiss = false) { if (!String.IsNullOrEmpty(value)) { IPAddress ip; if (NetworkAddressTest.IsIPv4Address(value, out ip)) { address = ip.ToString(); return(true); } else if (NetworkAddressTest.IsFqdn(value)) { IdnMapping idn = new IdnMapping(); address = idn.GetAscii(value.Trim()); return(true); } else { address = null; throw new FormatException($"{propertyName} must be a valid IPv4 or FQDN, {value} was provided."); } } else { address = null; if (allowEmptyString) { return(true); } else { if (throwExceptionOnMiss) { throw new ArgumentNullException($"The value for {propertyName} was null or empty and not a valid FQDN or IPv4 address."); } else { return(false); } } } }
// Inspired by: http://stackoverflow.com/questions/3275242/how-do-you-remove-invalid-characters-when-creating-a-friendly-url-ie-how-do-you public static string Slugify(string text) { IdnMapping idnMapping = new IdnMapping(); text = idnMapping.GetAscii(text); text = RemoveAccent(text).ToLower(); // Remove all invalid characters. text = Regex.Replace(text, @"[^a-z0-9\s-]", ""); // Convert multiple spaces into one space text = Regex.Replace(text, @"\s+", " ").Trim(); // Replace spaces by underscores. text = Regex.Replace(text, @"\s", "_"); return(text); }
[ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotWindowsNanoServer))] // https://github.com/dotnet/runtime/issues/22409 public void GetAscii_Invalid() { Assert.All(Factory.GetDataset().Where(entry => !entry.ASCIIResult.Success), entry => { try { var map = new IdnMapping() { UseStd3AsciiRules = true }; AssertExtensions.Throws <ArgumentException>("unicode", () => map.GetAscii(entry.Source)); } catch (ThrowsException) { string codePoints = GetCodePoints(entry.Source); throw new Exception($"Expected IdnMapping.GetAscii(\"{codePoints}\") to throw an ArgumentException. Line Number: {entry.LineNumber}"); } }); }
private string GetHost(bool allowUnicode) { string domain = host; // Downgrade Unicode domain names if (!allowUnicode && !MimeBasePart.IsAscii(domain, true)) { IdnMapping mapping = new IdnMapping(); try { domain = mapping.GetAscii(domain); } catch (ArgumentException argEx) { throw new SmtpException(SR.GetString(SR.SmtpInvalidHostName, Address), argEx); } } return(domain); }
public string DomainMapper(Match match) { // IdnMapping class with default property values. IdnMapping idn = new IdnMapping(); string domainName; try { domainName = match.Groups[2].Value; domainName = idn.GetAscii(domainName); return(match.Groups[1].Value + domainName); } catch { isValid = false; return(null); } }
protected AbstractDnsRecord(string name, DnsRecordType type, long timeToLive, DnsRecordClass dnsClass = DnsRecordClass.IN) { if (TimeToLive < 0) { throw new ArgumentException($"timeToLive: {timeToLive} (expected: >= 0)"); } TimeToLive = timeToLive; if (string.IsNullOrWhiteSpace(name)) { throw new ArgumentNullException(nameof(name)); } Name = AppendTrailingDot(idn.GetAscii(name)); Type = type ?? throw new ArgumentNullException(nameof(type)); DnsClass = dnsClass; }
public void IllegalChars(bool useStd3AsciiRules) { var idn = new IdnMapping(); idn.UseStd3AsciiRules = useStd3AsciiRules; string testString; for (int i = 0; i <= 0x1F; i++) { testString = "abc" + new string((char)i, 1) + "def"; Assert.Throws<ArgumentException>(() => idn.GetAscii(testString)); Assert.Throws<ArgumentException>(() => idn.GetUnicode(testString)); } testString = "abc" + new string((char)0x7F, 1) + "def"; Assert.Throws<ArgumentException>(() => idn.GetAscii(testString)); Assert.Throws<ArgumentException>(() => idn.GetUnicode(testString)); }
public void SurrogatePairsSeparatedByAsciiAndNonAscii() { var idn = new IdnMapping(); Assert.Equal("xn--a-nha4529qfag", idn.GetAscii("\uD800\uDF00\u0101\uD800\uDF01\u0061\uD800\uDF02")); }
public void SurrogatePairsSeparatedByNonAscii() { var idn = new IdnMapping(); Assert.Equal("xn--yda263v6b6kfag", idn.GetAscii("\uD800\uDF00\u0101\uD800\uDF01\u305D\uD800\uDF02")); }
public void SurrogatePairsSeparatedByAscii() { var idn = new IdnMapping(); Assert.Equal("xn--ab-ic6nfag", idn.GetAscii("\uD800\uDF00\u0061\uD800\uDF01\u0042\uD800\uDF02")); }
public void SurrogatePairsConsecutive() { var idn = new IdnMapping(); Assert.Equal("xn--097ccd", idn.GetAscii("\uD800\uDF00\uD800\uDF01\uD800\uDF02")); }
public void EmbeddedDomainNameConversion() { var idn = new IdnMapping(); Assert.Equal("abc.xn--d9juau41awczczp.xn--de-jg4avhby1noc0d", idn.GetAscii("\u0061\u0062\u0063.\u305D\u306E\u30B9\u30D4\u30FC\u30C9\u3067.\u30D1\u30D5\u30A3\u30FC\u0064\u0065\u30EB\u30F3\u30D0", 0)); Assert.Equal("abc.xn--d9juau41awczczp", idn.GetAscii("\u0061\u0062\u0063.\u305D\u306E\u30B9\u30D4\u30FC\u30C9\u3067.\u30D1\u30D5\u30A3\u30FC\u0064\u0065\u30EB\u30F3\u30D0", 0, 11)); Assert.Equal("abc.xn--d9juau41awczczp.", idn.GetAscii("\u0061\u0062\u0063.\u305D\u306E\u30B9\u30D4\u30FC\u30C9\u3067.\u30D1\u30D5\u30A3\u30FC\u0064\u0065\u30EB\u30F3\u30D0", 0, 12)); Assert.Equal("abc.xn--d9juau41awczczp.xn--de-jg4avhby1noc0d", idn.GetAscii("\u0061\u0062\u0063.\u305D\u306E\u30B9\u30D4\u30FC\u30C9\u3067.\u30D1\u30D5\u30A3\u30FC\u0064\u0065\u30EB\u30F3\u30D0", 0, 21)); Assert.Throws<ArgumentException>(() => idn.GetAscii("\u0061\u0062\u0063.\u305D\u306E\u30B9\u30D4\u30FC\u30C9\u3067.\u30D1\u30D5\u30A3\u30FC\u0064\u0065\u30EB\u30F3\u30D0", 3)); Assert.Throws<ArgumentException>(() => idn.GetAscii("\u0061\u0062\u0063.\u305D\u306E\u30B9\u30D4\u30FC\u30C9\u3067.\u30D1\u30D5\u30A3\u30FC\u0064\u0065\u30EB\u30F3\u30D0", 3, 8)); Assert.Throws<ArgumentException>(() => idn.GetAscii("\u0061\u0062\u0063.\u305D\u306E\u30B9\u30D4\u30FC\u30C9\u3067.\u30D1\u30D5\u30A3\u30FC\u0064\u0065\u30EB\u30F3\u30D0", 3, 9)); Assert.Equal("xn--d9juau41awczczp.xn--de-jg4avhby1noc0d", idn.GetAscii("\u0061\u0062\u0063.\u305D\u306E\u30B9\u30D4\u30FC\u30C9\u3067.\u30D1\u30D5\u30A3\u30FC\u0064\u0065\u30EB\u30F3\u30D0", 4)); Assert.Equal("xn--d9juau41awczczp", idn.GetAscii("\u0061\u0062\u0063.\u305D\u306E\u30B9\u30D4\u30FC\u30C9\u3067.\u30D1\u30D5\u30A3\u30FC\u0064\u0065\u30EB\u30F3\u30D0", 4, 7)); Assert.Equal("xn--d9juau41awczczp.", idn.GetAscii("\u0061\u0062\u0063.\u305D\u306E\u30B9\u30D4\u30FC\u30C9\u3067.\u30D1\u30D5\u30A3\u30FC\u0064\u0065\u30EB\u30F3\u30D0", 4, 8)); Assert.Equal("xn--d9juau41awczczp.xn--de-jg4avhby1noc0d", idn.GetAscii("\u0061\u0062\u0063.\u305D\u306E\u30B9\u30D4\u30FC\u30C9\u3067.\u30D1\u30D5\u30A3\u30FC\u0064\u0065\u30EB\u30F3\u30D0", 4, 17)); Assert.Throws<ArgumentException>(() => idn.GetAscii("\u0061\u0062\u0063.\u305D\u306E\u30B9\u30D4\u30FC\u30C9\u3067.\u30D1\u30D5\u30A3\u30FC\u0064\u0065\u30EB\u30F3\u30D0", 11)); Assert.Throws<ArgumentException>(() => idn.GetAscii("\u0061\u0062\u0063.\u305D\u306E\u30B9\u30D4\u30FC\u30C9\u3067.\u30D1\u30D5\u30A3\u30FC\u0064\u0065\u30EB\u30F3\u30D0", 11, 10)); Assert.Equal("xn--de-jg4avhby1noc0d", idn.GetAscii("\u0061\u0062\u0063.\u305D\u306E\u30B9\u30D4\u30FC\u30C9\u3067.\u30D1\u30D5\u30A3\u30FC\u0064\u0065\u30EB\u30F3\u30D0", 12)); Assert.Equal("xn--de-jg4avhby1noc0d", idn.GetAscii("\u0061\u0062\u0063.\u305D\u306E\u30B9\u30D4\u30FC\u30C9\u3067.\u30D1\u30D5\u30A3\u30FC\u0064\u0065\u30EB\u30F3\u30D0", 12, 9)); }
public static void GetAscii_Invalid(IdnMapping idnMapping, string unicode, int index, int count, Type exceptionType) { if (unicode == null || index + count == unicode.Length) { if (unicode == null || index == 0) { Assert.Throws(exceptionType, () => idnMapping.GetAscii(unicode)); } Assert.Throws(exceptionType, () => idnMapping.GetAscii(unicode, index)); } Assert.Throws(exceptionType, () => idnMapping.GetAscii(unicode, index, count)); }