def FromLS(self,input_line):
input_line = input_line.strip()
line.current = input_line
if str(input_line).startswith("!"):
return None
KeyChains = []
self.KeyChains_Objects = []
self.Dict = {}
self.Dict["Booleans"] = {}
while Lookahead(line.current) == "Boolean":
boolean_name, boolean_value = SetBool(line.current,self)
self.Dict["Booleans"][boolean_name] = boolean_value
while line.current:
EnsureIdentifier(line.current,"KEYCHAIN")
KC = KeyChain()
kc = {}
kc["Keys"] = []
KeyChainType = ParseEnum(line.current)
kc["Type"] = KeyChainType
KC.Type = KeychainType[KeyChainType]
if kc.get("Type") == "CUSTOM" and Lookahead(line.current) == "Literal":
kc["CustomType"] = ParseLiteral(line.current)
# kc["Mode"] = ParseEnum(line.current)
KC_Mode = ParseEnum(line.current)
kc["Mode"] = KC_Mode
KC.Mode = KeychainMode[KC_Mode]
while line.current and line.current.startswith("KEYCHAIN") == False:
k = {}
Key_Object = Key()
EnsureIdentifier(line.current,"KEY")
first = ParseLiteral(line.current)
if CheckIdentifier(line.current,"KEY") or CheckIdentifier(line.current,"KEYCHAIN") or not line.current:
Key_Object.LeftTerm = "<SOURCE>"
Key_Object.Comparer = Comparer["Contains"]
Key_Object.RightTerm = first
k["LeftTerm"] = "<SOURCE>"
k["Comparer"] = "Contains"
k["RightTerm"] = first
else:
Key_Object.LeftTerm = first
k["LeftTerm"] = first
Comparer__ = ParseEnum(line.current)
k["Comparer"] = Comparer__
Key_Object.Comparer = Comparer[Comparer__]
if Key_Object.Comparer.value != "Exists" and Key_Object.Comparer.value != "DoesNotExist":
RightTerm__ = ParseLiteral(line.current)
k["RightTerm"] = RightTerm__
Key_Object.RightTerm = RightTerm__
KC.Keys.append(Key_Object)
kc["Keys"].append(k)
self.KeyChains_Objects.append(KC)
KeyChains.append(kc)
self.Dict["KeyChains"] = KeyChains
def FromLS(self, line: LineParser) -> None:
if str(line.current).startswith("!"):
return None
self.group = ParseEnum(line)
if self.group == UtilityGroup.List:
self.list_name = ParseLiteral(line)
self.list_action = ParseEnum(line)
if self.list_action == ListAction.Join:
self.Separator = ParseLiteral(line)
elif self.list_action == ListAction.Sort:
while Lookahead(line) == "Boolean":
boolean_name, boolean_value = SetBool(line, self)
elif self.list_action == ListAction.Map or \
self.list_action == ListAction.Zip or \
self.list_action == ListAction.Concat:
self.SecondListName = ParseLiteral(line)
elif self.list_action == ListAction.Add:
self.ListItem = ParseLiteral(line)
self.ListIndex = ParseLiteral(line)
elif self.list_action == ListAction.Remove:
self.ListIndex = ParseLiteral(line)
elif self.list_action == ListAction.RemoveValues:
self.ListElementComparer = ParseEnum(line)
self.ListComparisonTerm = ParseLiteral(line)
else:
pass
elif self.group == UtilityGroup.Variable:
self.VarName = ParseLiteral(line)
self.var_action = ParseEnum(line)
if self.var_action == VarAction.Split:
self.SplitSeparator = ParseLiteral(line)
elif self.group == UtilityGroup.Conversion:
self.ConversionFrom = ParseEnum(line)
self.ConversionTo = ParseEnum(line)
self.InputString = ParseLiteral(line)
elif self.group == UtilityGroup.File:
self.FilePath = ParseLiteral(line)
self.file_action = ParseEnum(line)
if self.file_action in [
FileAction.Write, FileAction.WriteLines, FileAction.Append,
FileAction.AppendLines, FileAction.Copy, FileAction.Move
]:
self.InputString = ParseLiteral(line)
elif self.group == UtilityGroup.Folder:
self.FolderPath = ParseLiteral(line)
self.folder_action = ParseEnum(line)
# Try to parse the arrow, otherwise just return the block as is with default var name and var / cap choice
if not ParseToken(line, "Arrow", False, True):
return self.Dict
# Parse the VAR / CAP
varType = ParseToken(line, "Parameter", True, True)
if str(varType.upper()) == "VAR" or str(varType.upper()) == "CAP":
if str(varType.upper()) == "CAP":
self.Dict["IsCapture"] = True
self.isCapture = True
# Parse the variable/capture name
VariableName = ParseToken(line, "Literal", True, True)
self.VariableName = VariableName
def FromLS(self, input_line):
input_line = input_line.strip()
line.current = input_line
MultipartContents = []
CustomHeaders = {}
CustomCookies = {}
ResponseType = "String"
if str(input_line).startswith("!"):
return None
self.Dict = {}
Method = ParseEnum(line.current)
self.Dict["Method"] = Method
self.Method = Method
Url = ParseLiteral(line.current)
self.Dict["Url"] = Url
self.Url = Url
self.Dict["Booleans"] = {}
while Lookahead(line.current) == "Boolean":
boolean_name, boolean_value = SetBool(line.current, self)
self.Dict["Booleans"][boolean_name] = boolean_value
while len(str(
line.current)) != 0 and line.current.startswith("->") == False:
parsed = ParseToken(line.current, "Parameter", True, True).upper()
if parsed == "MULTIPART":
self.Dict["RequestType"] = "Multipart"
elif parsed == "BASICAUTH":
self.Dict["RequestType"] = "BasicAuth"
elif parsed == "STANDARD":
self.Dict["RequestType"] = "Standard"
self.RequestType = RequestType.Standard
elif parsed == "RAW":
self.Dict["RequestType"] = "Raw"
elif parsed == "CONTENT":
PostData = ParseLiteral(line.current)
self.Dict["PostData"] = PostData
self.PostData = PostData
elif parsed == "RAWDATA":
RawData = ParseLiteral(line.current)
self.Dict["RawData"] = RawData
elif parsed == "STRINGCONTENT":
stringContentPair = ParseString(ParseLiteral(line.current),
':', 2)
MultipartContents.append({
"Type": "STRING",
"Name": stringContentPair[0],
"Value": stringContentPair[1]
})
elif parsed == "FILECONTENT":
stringContentPair = ParseString(ParseLiteral(line.current),
':', 3)
MultipartContents.append({
"Type": "FILE",
"Name": stringContentPair[0],
"Value": stringContentPair[1]
})
elif parsed == "COOKIE":
cookiePair = ParseString(ParseLiteral(line.current), ':', 2)
CustomCookies[cookiePair[0]] = cookiePair[1]
elif parsed == "HEADER":
headerPair = ParseString(ParseLiteral(line.current), ':', 2)
CustomHeaders[headerPair[0]] = headerPair[1]
self.CustomHeaders[headerPair[0]] = headerPair[1]
elif parsed == "CONTENTTYPE":
ContentType = ParseLiteral(line.current)
self.Dict["ContentType"] = ContentType
self.ContentType = ContentType
elif parsed == "USERNAME":
AuthUser = ParseLiteral(line.current)
self.Dict["AuthUser"] = AuthUser
self.AuthUser = AuthUser
elif parsed == "PASSWORD":
AuthPass = ParseLiteral(line.current)
self.Dict["AuthUser"] = AuthPass
self.AuthPass = AuthPass
elif parsed == "BOUNDARY":
MultipartBoundary = ParseLiteral(line.current)
self.Dict["MultipartBoundary"] = MultipartBoundary
elif parsed == "SECPROTO":
SecurityProtocol = ParseLiteral(line.current)
self.Dict["SecurityProtocol"] = SecurityProtocol
else:
pass
if line.current.startswith("->"):
EnsureIdentifier(line.current, "->")
outType = ParseToken(line.current, "Parameter", True, True)
if outType.upper() == "STRING":
ResponseType = "String"
elif outType.upper() == "File":
ResponseType = "FILE"
DownloadPath = ParseLiteral(line.current)
self.Dict["DownloadPath"] = DownloadPath
while Lookahead(line.current) == "Boolean":
boolean_name, boolean_value = SetBool(line.current, self)
self.Dict["Booleans"][boolean_name] = boolean_value
elif outType.upper() == "BASE64":
ResponseType = "BASE64"
OutputVariable = ParseLiteral(line.current)
self.Dict["OutputVariable"] = OutputVariable
self.Dict["CustomCookies"] = CustomCookies
self.Dict["CustomHeaders"] = CustomHeaders
def FromLS(self, line: LineParser):
if str(line.current).startswith("!"):
return None
self.Dict = {}
ParseTarget = ParseLiteral(line)
self.Dict["ParseTarget"] = ParseTarget
self.ParseTarget = ParseTarget
parse_type = ParseEnum(line)
self.Dict["parse_type"] = parse_type
self.ParseType = parse_type
if parse_type == ParseType.REGEX:
regex_pattern = ParseLiteral(line)
self.Dict["regex_pattern"] = regex_pattern
self.RegexString = regex_pattern
regex_output = ParseLiteral(line)
self.Dict["regex_output"] = regex_output
self.RegexOutput = regex_output
self.Dict["Booleans"] = {}
while Lookahead(line) == "Boolean":
boolean_name, boolean_value = SetBool(line, self)
self.Dict["Booleans"][boolean_name] = boolean_value
elif parse_type == ParseType.CSS:
CssSelector = ParseLiteral(line)
self.CssSelector = CssSelector
self.Dict["CssSelector"] = CssSelector
AttributeName = ParseLiteral(line)
self.AttributeName = AttributeName
self.Dict["AttributeName"] = AttributeName
if Lookahead(line) == "Boolean":
SetBool(line, self)
elif Lookahead(line) == "Integer":
CssElementIndex = ParseInt(line)
self.CssElementIndex = CssElementIndex
self.Dict["CssElementIndex"] = CssElementIndex
self.Dict["Booleans"] = {}
while Lookahead(line) == "Boolean":
boolean_name, boolean_value = SetBool(line, self)
self.Dict["Booleans"][boolean_name] = boolean_value
elif parse_type == ParseType.JSON:
JsonField = ParseLiteral(line)
self.Dict["JsonField"] = JsonField
self.JsonField = JsonField
self.Dict["Booleans"] = {}
while Lookahead(line) == "Boolean":
boolean_name, boolean_value = SetBool(line, self)
self.Dict["Booleans"][boolean_name] = boolean_value
elif parse_type == ParseType.LR:
LeftString = ParseLiteral(line)
self.Dict["LeftString"] = LeftString
self.LeftString = LeftString
RightString = ParseLiteral(line)
self.RightString = RightString
self.Dict["RightString"] = RightString
self.Dict["Booleans"] = {}
while Lookahead(line) == "Boolean":
boolean_name, boolean_value = SetBool(line, self)
self.Dict["Booleans"][boolean_name] = boolean_value
else:
return None
arrow = ParseToken(line, "Arrow", True, True)
var_type = ParseToken(line, "Parameter", True, True)
IsCapture = False
if str(var_type.upper()) == "VAR" or str(var_type.upper()) == "CAP":
if str(var_type.upper()) == "CAP": IsCapture = True
self.Dict["IsCapture"] = IsCapture
self.IsCapture = IsCapture
variable_name = ParseLiteral(line)
self.Dict["variable_name"] = variable_name
self.VariableName = variable_name
prefix = ParseLiteral(line)
self.Dict["prefix"] = prefix
self.Prefix = prefix
suffix = ParseLiteral(line)
self.Dict["suffix"] = suffix
self.Suffix = suffix
def FromLS(self, line: LineParser):
if str(line.current).startswith("!"):
return None
method = ParseEnum(line)
self.method = method
url = ParseLiteral(line)
self.url = url
while Lookahead(line) == "Boolean":
boolean_name, boolean_value = SetBool(line, self)
while len(str(
line.current)) != 0 and line.current.startswith("->") == False:
parsed = ParseToken(line, "Parameter", True, True).upper()
if parsed == "MULTIPART":
self.request_type = RequestType.Multipart
elif parsed == "BASICAUTH":
self.request_type = RequestType.BasicAuth
elif parsed == "STANDARD":
self.request_type = RequestType.Standard
elif parsed == "RAW":
self.request_type = RequestType.Raw
elif parsed == "CONTENT":
post_data = ParseLiteral(line)
self.post_data = post_data
elif parsed == "RAWDATA":
raw_data = ParseLiteral(line)
self.raw_data = raw_data
elif parsed == "STRINGCONTENT":
stringContentPair = ParseString(ParseLiteral(line), ':', 2)
self.multipart_contents.append(
MultipartContent(stringContentPair[0],
stringContentPair[1],
MultipartContentType.String))
elif parsed == "FILECONTENT":
fileContentTriplet = ParseString(ParseLiteral(line), ':', 3)
self.multipart_contents.append(
MultipartContent(fileContentTriplet[0],
fileContentTriplet[1],
MultipartContentType.File,
fileContentTriplet[3]))
elif parsed == "COOKIE":
cookiePair = ParseString(ParseLiteral(line), ':', 2)
self.custom_cookies[cookiePair[0]] = cookiePair[1]
elif parsed == "HEADER":
headerPair = ParseString(ParseLiteral(line), ':', 2)
self.custom_headers[headerPair[0]] = headerPair[1]
elif parsed == "CONTENTTYPE":
ContentType = ParseLiteral(line)
self.ContentType = ContentType
elif parsed == "USERNAME":
auth_user = ParseLiteral(line)
self.auth_user = auth_user
elif parsed == "PASSWORD":
auth_pass = ParseLiteral(line)
self.auth_pass = auth_pass
elif parsed == "BOUNDARY":
multipart_boundary = ParseLiteral(line)
self.multipart_boundary = multipart_boundary
elif parsed == "SECPROTO":
SecurityProtocol = ParseLiteral(line)
self.SecurityProtocol = SecurityProtocol
else:
pass
if line.current.startswith("->"):
EnsureIdentifier(line, "->")
outType = ParseToken(line, "Parameter", True, True)
if outType.upper() == "STRING":
self.response_type = ResponseType.String
elif outType.upper() == "FILE":
self.response_type = ResponseType.File
download_path = ParseLiteral(line)
self.download_path = download_path
while Lookahead(line) == "Boolean":
boolean_name, boolean_value = SetBool(line, self)
elif outType.upper() == "BASE64":
self.response_type = ResponseType.Base64String
output_variable = ParseLiteral(line)
self.output_variable = output_variable
def FromLS(self, input_line):
input_line = input_line.strip()
if str(input_line).startswith("!"):
return None
line.current = input_line
self.Dict = {}
self.Dict["IsCapture"] = False
self.Dict["VariableName"] = ""
self.Dict["InputString"] = ""
self.Dict["Booleans"] = {}
FunctionType = ParseEnum(line.current)
self.Dict["FunctionType"] = FunctionType
self.FunctionType = FunctionType
if FunctionType == Function().Constant:
pass
elif FunctionType == Function().Hash:
HashType = ParseEnum(line.current)
self.Dict["HashType"] = HashType
self.HashType = HashType
while Lookahead(line.current) == "Boolean":
boolean_name, boolean_value = SetBool(line.current, self)
self.Dict["Booleans"][boolean_name] = boolean_value
elif FunctionType == Function().HMAC:
HashType = ParseEnum(line.current)
self.Dict["HashType"] = HashType
self.HashType = HashType
HmacKey = ParseLiteral(line.current)
self.Dict["HmacKey"] = HmacKey
self.HmacKey = HmacKey
while Lookahead(line.current) == "Boolean":
boolean_name, boolean_value = SetBool(line.current, self)
self.Dict["Booleans"][boolean_name] = boolean_value
elif FunctionType == Function().Translate:
while Lookahead(line.current) == "Boolean":
boolean_name, boolean_value = SetBool(line.current, self)
self.Dict["Booleans"][boolean_name] = boolean_value
self.Dict["TranslationDictionary"] = {}
while line.current and Lookahead(line.current) == "Parameter":
EnsureIdentifier(line.current, "KEY")
k = ParseLiteral(line.current)
EnsureIdentifier(line.current, "VALUE")
v = ParseLiteral(line.current)
self.Dict["TranslationDictionary"][k] = v
elif FunctionType == Function().DateToUnixTime:
self.Dict["DateFormat"] = ParseLiteral(line.current)
elif FunctionType == Function().UnixTimeToDate:
self.Dict["DateFormat"] = ParseLiteral(line.current)
if Lookahead(line.current) != "Literal":
self.Dict["InputString"] = "yyyy-MM-dd:HH-mm-ss"
elif FunctionType == Function().Replace:
ReplaceWhat = ParseLiteral(line.current)
self.Dict["ReplaceWhat"] = ReplaceWhat
self.ReplaceWhat = ReplaceWhat
ReplaceWith = ParseLiteral(line.current)
self.Dict["ReplaceWith"] = ReplaceWith
self.ReplaceWith = ReplaceWith
if Lookahead(line.current) == "Boolean":
boolean_name, boolean_value = SetBool(line.current, self)
self.Dict["Booleans"][boolean_name] = boolean_value
elif FunctionType == Function().RegexMatch:
self.Dict["RegexMatch"] = ParseLiteral(line.current)
elif FunctionType == Function().RandomNum:
if Lookahead(line.current) == "Literal":
RandomMin = ParseLiteral(line.current)
RandomMax = ParseLiteral(line.current)
self.Dict["RandomMin"] = RandomMin
self.Dict["RandomMax"] = RandomMax
self.RandomMin = RandomMin
self.RandomMax = RandomMax
# Support for old integer definition of Min and Max
else:
RandomMin = ParseLiteral(line.current)
RandomMax = ParseLiteral(line.current)
self.Dict["RandomMin"] = RandomMin
self.Dict["RandomMax"] = RandomMax
self.RandomMin = RandomMin
self.RandomMax = RandomMax
if Lookahead(line.current) == "Boolean":
boolean_name, boolean_value = SetBool(line.current, self)
self.Dict["Booleans"][boolean_name] = boolean_value
elif FunctionType == Function().CountOccurrences:
self.Dict["StringToFind"] = ParseLiteral(line.current)
elif FunctionType == Function().CharAt:
self.Dict["CharIndex"] = ParseLiteral(line.current)
elif FunctionType == Function().Substring:
self.Dict["SubstringIndex"] = ParseLiteral(line.current)
self.Dict["SubstringLength"] = ParseLiteral(line.current)
elif FunctionType == Function().RSAEncrypt:
self.Dict["RsaN"] = ParseLiteral(line.current)
self.Dict["RsaE"] = ParseLiteral(line.current)
if Lookahead(line.current) == "Boolean":
boolean_name, boolean_value = SetBool(line.current, self)
self.Dict["Booleans"][boolean_name] = boolean_value
elif FunctionType == Function().RSAPKCS1PAD2:
self.Dict["RsaN"] = ParseLiteral(line.current)
self.Dict["RsaE"] = ParseLiteral(line.current)
elif FunctionType == Function().GetRandomUA:
if ParseToken(line.current, "Parameter", False,
False) == "BROWSER":
EnsureIdentifier(line.current, "BROWSER")
self.Dict["Booleans"]["UserAgentSpecifyBrowser"] = True
self.Dict["UserAgentBrowser"] = ParseEnum(line.current)
elif FunctionType == Function().AESDecrypt:
pass
elif FunctionType == Function().AESEncrypt:
self.Dict["AesKey"] = ParseLiteral(line.current)
self.Dict["AesIV"] = ParseLiteral(line.current)
self.Dict["AesMode"] = ParseEnum(line.current)
self.Dict["AesPadding"] = ParseEnum(line.current)
elif FunctionType == Function().PBKDF2PKCS5:
if Lookahead(line.current) == "Literal":
self.Dict["KdfSalt"] = ParseLiteral(line.current)
else:
self.Dict["KdfSaltSize"] = ParseInt(line.current)
self.Dict["KdfIterations"] = ParseInt(line.current)
self.Dict["KdfKeySize"] = ParseInt(line.current)
self.Dict["KdfAlgorithm"] = ParseEnum(line.current)
else:
pass
if Lookahead(line.current) == "Literal":
inputString = ParseLiteral(line.current)
self.InputString = inputString
self.Dict["InputString"] = inputString
# Try to parse the arrow, otherwise just return the block as is with default var name and var / cap choice
if not ParseToken(line.current, "Arrow", False, True):
return self.Dict
# Parse the VAR / CAP
varType = ParseToken(line.current, "Parameter", True, True)
if str(varType.upper()) == "VAR" or str(varType.upper()) == "CAP":
if str(varType.upper()) == "CAP":
self.Dict["IsCapture"] = True
self.isCapture = True
# Parse the variable/capture name
VariableName = ParseToken(line.current, "Literal", True, True)
self.VariableName = VariableName
self.Dict["VariableName"] = VariableName