304 lines
9.1 KiB
C#
304 lines
9.1 KiB
C#
// (c) Copyright Ascensio System SIA 2010-2022
|
|
//
|
|
// This program is a free software product.
|
|
// You can redistribute it and/or modify it under the terms
|
|
// of the GNU Affero General Public License (AGPL) version 3 as published by the Free Software
|
|
// Foundation. In accordance with Section 7(a) of the GNU AGPL its Section 15 shall be amended
|
|
// to the effect that Ascensio System SIA expressly excludes the warranty of non-infringement of
|
|
// any third-party rights.
|
|
//
|
|
// This program is distributed WITHOUT ANY WARRANTY, without even the implied warranty
|
|
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For details, see
|
|
// the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
|
|
//
|
|
// You can contact Ascensio System SIA at Lubanas st. 125a-25, Riga, Latvia, EU, LV-1021.
|
|
//
|
|
// The interactive user interfaces in modified source and object code versions of the Program must
|
|
// display Appropriate Legal Notices, as required under Section 5 of the GNU AGPL version 3.
|
|
//
|
|
// Pursuant to Section 7(b) of the License you must retain the original Product logo when
|
|
// distributing the program. Pursuant to Section 7(e) we decline to grant you any rights under
|
|
// trademark law for use of our trademarks.
|
|
//
|
|
// All the Product's GUI elements, including illustrations and icon sets, as well as technical writing
|
|
// content are licensed under the terms of the Creative Commons Attribution-ShareAlike 4.0
|
|
// International. See the License terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
|
|
|
|
namespace ASC.ActiveDirectory.Base.Expressions;
|
|
public class Expression : ICloneable
|
|
{
|
|
private readonly Op _op;
|
|
private bool _negative;
|
|
private readonly string _attributeName;
|
|
private readonly string _attributeValue;
|
|
|
|
private const string EQUIAL = "=";
|
|
private const string APPROXIMATELY_EQUIAL = "~=";
|
|
private const string GREATER = ">";
|
|
private const string GREATER_OR_EQUAL = ">=";
|
|
private const string LESS = "<";
|
|
private const string LESS_OR_EQUAL = "<=";
|
|
|
|
internal Expression()
|
|
{
|
|
}
|
|
|
|
public string Name
|
|
{
|
|
get { return _attributeName; }
|
|
}
|
|
|
|
public string Value
|
|
{
|
|
get { return _attributeValue; }
|
|
}
|
|
|
|
public Op Operation
|
|
{
|
|
get { return _op; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// To specify unary operations
|
|
/// </summary>
|
|
/// <param name="op">Operator</param>
|
|
/// <param name="attrbuteName">Attribute name</param>
|
|
public Expression(string attrbuteName, Op op)
|
|
{
|
|
if (op != Op.Exists && op != Op.NotExists)
|
|
{
|
|
throw new ArgumentException("op");
|
|
}
|
|
|
|
if (string.IsNullOrEmpty(attrbuteName))
|
|
{
|
|
throw new ArgumentException("attrbuteName");
|
|
}
|
|
|
|
_op = op;
|
|
_attributeName = attrbuteName;
|
|
_attributeValue = "*";
|
|
}
|
|
|
|
/// <summary>
|
|
/// To specify binary operations
|
|
/// </summary>
|
|
/// <param name="op">Operator</param>
|
|
/// <param name="attrbuteName">Attribute name</param>
|
|
/// <param name="attrbuteValue">Attribute value</param>
|
|
public Expression(string attrbuteName, Op op, string attrbuteValue)
|
|
{
|
|
if (op == Op.Exists || op == Op.NotExists)
|
|
{
|
|
throw new ArgumentException("op");
|
|
}
|
|
|
|
if (string.IsNullOrEmpty(attrbuteName))
|
|
{
|
|
throw new ArgumentException("attrbuteName");
|
|
}
|
|
|
|
_op = op;
|
|
_attributeName = attrbuteName;
|
|
_attributeValue = attrbuteValue;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Expression as a string
|
|
/// </summary>
|
|
/// <returns>Expression string</returns>
|
|
public override string ToString()
|
|
{
|
|
string sop;
|
|
switch (_op)
|
|
{
|
|
case Op.NotExists:
|
|
case Op.Exists:
|
|
case Op.Equal:
|
|
case Op.NotEqual:
|
|
sop = EQUIAL;
|
|
break;
|
|
case Op.Greater:
|
|
sop = GREATER;
|
|
break;
|
|
case Op.GreaterOrEqual:
|
|
sop = GREATER_OR_EQUAL;
|
|
break;
|
|
case Op.Less:
|
|
sop = LESS;
|
|
break;
|
|
case Op.LessOrEqual:
|
|
sop = LESS_OR_EQUAL;
|
|
break;
|
|
default:
|
|
throw new ArgumentOutOfRangeException();
|
|
}
|
|
|
|
var expressionString = "({0}{1}{2}{3})";
|
|
expressionString = string.Format(expressionString,
|
|
//positive or negative
|
|
(((int)_op & 0x010000) == 0x010000 || _negative) ? "!" : "", _attributeName, sop,
|
|
EscapeLdapSearchFilter(_attributeValue));
|
|
|
|
return expressionString;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Escapes the LDAP search filter to prevent LDAP injection attacks.
|
|
/// </summary>
|
|
/// <param name="searchFilter">The search filter.</param>
|
|
/// <see cref="https://blogs.oracle.com/shankar/entry/what_is_ldap_injection" />
|
|
/// <see cref="http://msdn.microsoft.com/en-us/library/aa746475.aspx" />
|
|
/// <returns>The escaped search filter.</returns>
|
|
private static string EscapeLdapSearchFilter(string searchFilter)
|
|
{
|
|
var escape = new StringBuilder(); // If using JDK >= 1.5 consider using StringBuilder
|
|
foreach (var current in searchFilter)
|
|
{
|
|
switch (current)
|
|
{
|
|
case '\\':
|
|
escape.Append(@"\5c");
|
|
break;
|
|
case '*':
|
|
escape.Append(@"\2a");
|
|
break;
|
|
case '(':
|
|
escape.Append(@"\28");
|
|
break;
|
|
case ')':
|
|
escape.Append(@"\29");
|
|
break;
|
|
case '\u0000':
|
|
escape.Append(@"\00");
|
|
break;
|
|
case '/':
|
|
escape.Append(@"\2f");
|
|
break;
|
|
default:
|
|
escape.Append(current);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return escape.ToString();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Negation
|
|
/// </summary>
|
|
/// <returns>Self</returns>
|
|
public Expression Negative()
|
|
{
|
|
_negative = !_negative;
|
|
return this;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Existence
|
|
/// </summary>
|
|
/// <param name="attrbuteName"></param>
|
|
/// <returns>New Expression</returns>
|
|
public static Expression Exists(string attrbuteName)
|
|
{
|
|
return new Expression(attrbuteName, Op.Exists);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Non-Existence
|
|
/// </summary>
|
|
/// <param name="attrbuteName"></param>
|
|
/// <returns>New Expression</returns>
|
|
public static Expression NotExists(string attrbuteName)
|
|
{
|
|
return new Expression(attrbuteName, Op.NotExists);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Equality
|
|
/// </summary>
|
|
/// <param name="attrbuteName"></param>
|
|
/// <param name="attrbuteValue"></param>
|
|
/// <returns>New Expression</returns>
|
|
public static Expression Equal(string attrbuteName, string attrbuteValue)
|
|
{
|
|
return new Expression(attrbuteName, Op.Equal, attrbuteValue);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Not equality
|
|
/// </summary>
|
|
/// <param name="attrbuteName"></param>
|
|
/// <param name="attrbuteValue"></param>
|
|
/// <returns></returns>
|
|
public static Expression NotEqual(string attrbuteName, string attrbuteValue)
|
|
{
|
|
return new Expression(attrbuteName, Op.NotEqual, attrbuteValue);
|
|
}
|
|
|
|
public static Expression Parse(string origin)
|
|
{
|
|
string spliter = null;
|
|
var op = Op.Equal;
|
|
|
|
var index = origin.IndexOf(EQUIAL, StringComparison.Ordinal);
|
|
|
|
if (index > -1)
|
|
{
|
|
spliter = EQUIAL;
|
|
op = Op.Equal;
|
|
}
|
|
else if ((index = origin.IndexOf(GREATER, StringComparison.Ordinal)) > -1)
|
|
{
|
|
spliter = GREATER;
|
|
op = Op.Greater;
|
|
}
|
|
else if ((index = origin.IndexOf(GREATER_OR_EQUAL, StringComparison.Ordinal)) > -1)
|
|
{
|
|
spliter = GREATER_OR_EQUAL;
|
|
op = Op.GreaterOrEqual;
|
|
}
|
|
else if ((index = origin.IndexOf(LESS, StringComparison.Ordinal)) > -1)
|
|
{
|
|
spliter = LESS;
|
|
op = Op.Less;
|
|
}
|
|
else if ((index = origin.IndexOf(LESS_OR_EQUAL, StringComparison.Ordinal)) > -1)
|
|
{
|
|
spliter = LESS_OR_EQUAL;
|
|
op = Op.LessOrEqual;
|
|
}
|
|
else if ((index = origin.IndexOf(APPROXIMATELY_EQUIAL, StringComparison.Ordinal)) > -1)
|
|
{
|
|
spliter = APPROXIMATELY_EQUIAL;
|
|
op = Op.Exists;
|
|
}
|
|
|
|
if (string.IsNullOrEmpty(spliter))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var attributeName = origin.Substring(0, index);
|
|
var attributeValue = origin.Substring(index + 1);
|
|
|
|
if (string.IsNullOrEmpty(attributeName) || string.IsNullOrEmpty(attributeValue))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return new Expression(attributeName, op, attributeValue);
|
|
}
|
|
|
|
#region ICloneable Members
|
|
/// <summary>
|
|
/// ICloneable implemetation
|
|
/// </summary>
|
|
/// <returns>Clone object</returns>
|
|
public object Clone()
|
|
{
|
|
return MemberwiseClone();
|
|
}
|
|
|
|
#endregion
|
|
} |