def authenticate():
"""
Method to authenticate with shiftleft inspect cloud when the required tokens gets passed via
environment variables
"""
if is_authenticated():
return
sl_org = config.get("SHIFTLEFT_ORG_ID")
sl_token = config.get("SHIFTLEFT_ACCESS_TOKEN")
sl_cmd = config.get("SHIFTLEFT_INSPECT_CMD")
if sl_org and sl_token and sl_cmd:
inspect_login_args = [
sl_cmd,
"auth",
"--no-auto-update",
"--no-diagnostic",
"--org",
sl_org,
"--token",
sl_token,
]
cp = exec_tool(inspect_login_args)
if cp.returncode != 0:
LOG.warning(
"ShiftLeft Inspect authentication has failed. Please check the credentials"
)
else:
LOG.info("Successfully authenticated with inspect cloud")
def main():
# establish a wifi connection
device_id = config.get(config_file="config/device_config.json",
key="device_id")
device_name = config.get(config_file="config/device_config.json",
key="device_name")
ssid = config.get(config_file="config/device_config.json", key="ssid")
password = config.get(config_file="config/device_config.json",
key="password")
url = config.get(config_file="config/device_config.json", key="url")
if ssid in wifi.scan():
wifi.connect(ssid, password)
wifi.status()
while wifi.status():
gpio.toggle_leds()
temperature, humidity = gpio.read_sensor()
print("Temp: {0:.2f}, Humidity {1:.2f}".format(
temperature, humidity))
http.emit_sensor(url, device_id, device_name, temperature,
humidity)
sleep(60)
def format_issue(kind_id):
kind = CrashKind.get(id=kind_id)
crashes = Crash.select().where(Crash.kind_id == kind_id)
reporter_table = ""
additional = []
for c in crashes:
stack_url = config.get("external_url") + "/crash/" + str(c.id)
reporter_table += reporter_row.format(
stack_url=stack_url, **model_to_dict(c)).replace("\n", " ") + "\n"
if c.description:
additional.append(c.description)
v = {
"stack": crashes[0].stack,
"type": kind.type,
"exc_string": crashes[0].exc_string,
"reporter_table": reporter_table,
"user_count": len(crashes),
"app_name": config.get("app_name")
}
report = template.format(**v)
if additional:
for a in additional:
report += "\n> ".join([""] + a.splitlines())
report += "\n\n---\n\n"
else:
report += no_info
title = kind.type + ": " + crashes[0].exc_string
if len(title) > 400:
title = title[:400] + "..."
return title, report
def authenticate():
"""
Method to authenticate with ShiftLeft NG SAST cloud when the required tokens gets passed via
environment variables
"""
if is_authenticated():
return
sl_org = config.get("SHIFTLEFT_ORG_ID", config.get("SHIFTLEFT_ORGANIZATION_ID"))
sl_token = config.get("SHIFTLEFT_ACCESS_TOKEN")
sl_cmd = config.get("SHIFTLEFT_NGSAST_CMD")
run_uuid = config.get("run_uuid")
if sl_org and sl_token and sl_cmd and utils.check_command(sl_cmd):
inspect_login_args = [
sl_cmd,
"auth",
"--no-auto-update",
"--no-diagnostic",
"--org",
sl_org,
"--token",
sl_token,
]
cp = exec_tool("NG SAST", inspect_login_args)
if cp.returncode != 0:
LOG.warning(
"ShiftLeft NG SAST authentication has failed. Please check the credentials"
)
else:
LOG.info("Successfully authenticated with NG SAST cloud")
track({"id": run_uuid, "scan_mode": "ng-sast", "sl_org": sl_org})
def fetch_findings(app_name, version, report_fname):
"""
Fetch findings from the Inspect Cloud
"""
sl_org = config.get("SHIFTLEFT_ORG_ID")
sl_org_token = config.get("SHIFTLEFT_ORG_TOKEN")
findings_api = config.get("SHIFTLEFT_VULN_API")
findings_list = []
if sl_org and sl_org_token:
findings_api = findings_api % dict(
sl_org=sl_org, app_name=app_name, version=version)
query_obj = {
"query": {
"returnRuntimeData": False,
"orderByDirection": "VULNERABILITY_ORDER_DIRECTION_DESC",
}
}
headers = {
"Content-Type": "application/json",
"Authorization": "Bearer " + sl_org_token,
}
try:
r = requests.post(findings_api, headers=headers, json=query_obj)
if r.status_code == 200:
findings_data = r.json()
if findings_data:
findings_list += findings_data.get("vulnerabilities", [])
nextPageBookmark = findings_data.get("nextPageBookmark")
# Recurse and fetch all pages
while nextPageBookmark:
LOG.info("Retrieving findings from next page")
r = requests.post(
findings_api,
headers=headers,
json={"pageBookmark": nextPageBookmark},
)
if r.status_code == 200:
findings_data = r.json()
if findings_data:
findings_list += findings_data.get(
"vulnerabilities", [])
nextPageBookmark = findings_data.get(
"nextPageBookmark")
else:
nextPageBookmark = None
with open(report_fname, mode="w") as rp:
json.dump({"vulnerabilities": findings_list}, rp)
LOG.info("Data written to {}, {}".format(
report_fname, len(findings_list)))
return findings_list
else:
LOG.warning(
"Unable to retrieve findings from Inspect Cloud. Status {}"
.format(r.status_code))
return findings_list
except Exception as e:
logging.error(e)
else:
return findings_list
def setConfig(self, config, section="MEOS"):
self.ColorButton.setColor(
config.get(section, self.confSection + 'Color'))
self.Grosor.setValue(
config.getfloat(section, self.confSection + 'lineWidth'))
self.Linea.setCurrentValue(
config.get(section, self.confSection + 'lineStyle'))
self.Marca.setCurrentValue(
config.get(section, self.confSection + 'marker'))
def create_result(tool_name,
issue,
rules,
rule_indices,
file_path_list=None,
working_dir=None):
"""Method to convert a single issue into result schema with rules
:param tool_name: tool name
:param issue: Issues object
:param rules: List of rules
:param rule_indices: Indices of referred rules
:param file_path_list: Full file path for any manipulation
:param working_dir: Working directory
"""
WORKSPACE_PREFIX = config.get("WORKSPACE", None)
if isinstance(issue, dict):
issue = issue_from_dict(issue)
issue_dict = issue.as_dict()
rule, rule_index = create_or_find_rule(tool_name, issue_dict, rules,
rule_indices)
# Substitute workspace prefix
# Override file path prefix with workspace
filename = issue_dict["filename"]
if working_dir:
# Issue 5 fix. Convert relative to full path automatically
if not filename.startswith(working_dir):
filename = os.path.join(working_dir, filename)
if WORKSPACE_PREFIX:
filename = re.sub(r"^" + working_dir, WORKSPACE_PREFIX, filename)
physical_location = om.PhysicalLocation(
artifact_location=om.ArtifactLocation(uri=to_uri(filename)))
add_region_and_context_region(physical_location, issue_dict["line_number"],
issue_dict["code"])
issue_severity = issue_dict["issue_severity"]
issue_severity = tweak_severity(tool_name, issue_severity)
return om.Result(
rule_id=rule.id,
rule_index=rule_index,
message=om.Message(text=issue_dict["issue_text"]),
level=level_from_severity(issue_severity),
locations=[om.Location(physical_location=physical_location)],
properties={
"issue_confidence": issue_dict["issue_confidence"],
"issue_severity": issue_severity,
},
hosted_viewer_uri=config.get("hosted_viewer_uri", ""),
)
def __init__(self):
"""初始化"""
# 个人配置初始化
utils.mkdir(self.USER_PATH)
utils.mkdir(self.TEMP_PATH)
utils.mkdir(self.FACE_ID_PATH)
print(self.CONF_FILE)
if os.path.exists(self.CONF_FILE) is False:
for name in ['config.yml', '八戒.pmdl', '小白.pmdl']:
utils.cp(CUR_PATH + '/conf/' + name,
self.USER_PATH + '/' + name)
self.CONFIG_DATA = utils.load_conf(self.CONF_FILE)
# print(self.CONFIG_DATA)
# 主人初始化状态(status: 1face已确认；2名字已确认)
self.master = {
'status': 0,
'time': 0,
'face': '',
'morning': 0,
'noon': 0,
'evening': 0,
'lastask': 0
}
self.guest = {
'status': 0,
'time': 0,
'face': '',
'morning': 0,
'noon': 0,
'evening': 0,
'lastask': 0
}
# self.master.update(self.CONFIG_DATA['master'])
# print(self.master)
# 初始化语音合成
self.saying = '' # 是否正在播放
self.tts = TTS.get_engine_by_slug(config.get('tts_engine',
'baidu-tts'))
# 初始化语音识别
self.listening = '' # 是否正在收音
self.asr = ASR.get_engine_by_slug(
config.get('asr_engine', 'tencent-asr'))
# 启动摄像头人脸识别
self.camera = camera.Face(faceid_path=self.FACE_ID_PATH,
temp_path=self.TEMP_PATH)
#self.camera.get_camera_face(camera_data=self.CAMERA_DATA, callback=camera.show_camera_face_window)
self.camera.get_camera_face(camera_data=self.CAMERA_DATA,
callback=self.patrol)
def test_override():
build_break_rules = config.get("build_break_rules").copy()
golang_cmd = config.get("scan_tools_args_map").get("go")
assert list(golang_cmd.keys()) == ["source-go", "staticcheck"]
test_data_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), "data")
config.set("SAST_SCAN_SRC_DIR", test_data_dir)
config.reload()
# Test if we are able to override the whole dict
new_rules = config.get("build_break_rules")
assert build_break_rules != new_rules
# Test if we are able to override a command
golang_cmd = config.get("scan_tools_args_map").get("go")
assert golang_cmd[0] == "echo"
assert config.get("scan_type") == "credscan,java"
def user_registered(self, user):
if config.get(user, 'user'):
self.trigger('send_to_opers', '%s connecting as %s' %
(config.get(user, 'user'), user.info['nick']))
else:
self.trigger('send_to_opers', '%s connecting on port %d' %
(user.info['nick'], user.saddr[1]))
self.trigger('welcome', user)
self.trigger('welcome_version', user)
self.trigger('isupport', user)
self.run_command('lusers', user, [])
self.run_command('motd', user, [])
def find_app_name(src, repo_context):
"""
Method to retrieve the app name for inspect
:param src: Source directory
:param repo_context: Repo context
:return: App name string
"""
app_name = config.get("SHIFTLEFT_PROJECT_NAME")
if not app_name:
app_name = config.get("SHIFTLEFT_APP",
repo_context.get("repositoryName"))
if not app_name:
app_name = os.path.dirname(src)
return app_name
def is_authenticated():
"""
Method to check if we are authenticated
"""
sl_home = config.get("SHIFTLEFT_HOME")
sl_cmd = config.get("SHIFTLEFT_NGSAST_CMD")
if utils.check_command(sl_cmd):
sl_config_json = os.path.join(sl_home, "config.json")
if os.path.exists(sl_config_json):
return True
else:
sl_org = config.get("SHIFTLEFT_ORG_ID", config.get("SHIFTLEFT_ORGANIZATION_ID"))
sl_token = config.get("SHIFTLEFT_ACCESS_TOKEN")
return sl_org is not None and sl_token is not None
return False
def setup_windows():
from windows import main_window
main_window.Window()
winpath = os.path.join(config['execdir'], 'source/gui/windows')
for fn in os.listdir(winpath):
if not fn.endswith('_window.py') or fn == 'main_window.py':
continue
dir, fn = os.path.split(fn)
classname = os.path.splitext(fn)[0]
if config.get('exclude_%s' % classname, False):
logging.info('Skipping class %s', classname)
continue
logging.info('Loading class %s...', classname)
start = time.time()
codestr = "from windows import %s\n%s.Window()" % (classname,
classname)
try:
exec codestr
except Exception, e:
print 'Error loading window %s' % classname
TB()
delta = time.time() - start
logging.info(' Time = %.03s', delta)
def enable_aenea():
config = lib.config.get_config()
if config.get("aenea.enabled", False) == False:
config["aenea.enabled"] = True
lib.config.save_config()
print("<<< Aenea enabled, reload required. >>>")
print("<<< Don't forget, start the server and the client window. >>>")
def _parse_spec(self, spec):
"""Overrides the normal Text class behavior. To handle dictation of
special characters like / . _
Unfortunately, I have not found a better place to solve this.
"""
parts = re.split("\%\([a-z_0-9]+\)s", self._spec)
if len(parts) > 2:
raise Exception("SCText only supports one variable, yet.")
start = len(parts[0])
end = len(spec) - len(parts[1])
work = spec[start:end]
for text, char in specialCharacterTranslations.items():
work = work.replace(" %s " % text, char)
work = work.replace(" %s" % text, char)
work = work.replace("%s " % text, char)
work = work.replace("%s" % text, char)
spec = parts[0] + work + parts[1]
if config.get("aenea.enabled", False) == True:
return spec
events = []
for character in spec:
if character in self._specials:
typeable = self._specials[character]
else:
typeable = Keyboard.get_typeable(character)
events.extend(typeable.events(self._pause))
return events
def enable_aenea():
config = lib.config.get_config()
if config.get("aenea.enabled", False) == False:
config["aenea.enabled"] = True
lib.config.save_config()
print("<<< Aenea enabled, reload required. >>>")
print("<<< Don't forget, start the server and the client window. >>>")
def __init__(self, db_password=os.environ.get("DB_PASSWORD")):
db_config = config.get('DATABASE')
self.db_host = db_config['host']
self.db_port = int(db_config['port'])
self.db_user = db_config['user']
self.db_database = db_config['dbname']
self.db_password = str(db_password)
def _parse_spec(self, spec):
"""Overrides the normal Text class behavior. To handle dictation of
special characters like / . _
Unfortunately, I have not found a better place to solve this.
"""
parts = re.split("\%\([a-z_0-9]+\)s", self._spec)
if len(parts) > 2:
raise Exception("SCText only supports one variable, yet.")
start = len(parts[0])
end = len(spec) - len(parts[1])
work = spec[start:end]
for text, char in specialCharacterTranslations.items():
work = work.replace(" %s " % text, char)
work = work.replace(" %s" % text, char)
work = work.replace("%s " % text, char)
work = work.replace("%s" % text, char)
spec = parts[0] + work + parts[1]
if config.get("aenea.enabled", False) == True:
return spec
events = []
for character in spec:
if character in self._specials:
typeable = self._specials[character]
else:
typeable = Keyboard.get_typeable(character)
events.extend(typeable.events(self._pause))
return events
def create_review(self, pull_requests, findings, github_context,
report_summary, build_status):
repo = g.get_repo(github_context.get("repoFullname"))
for pr in pull_requests:
revisionId = github_context.get("revisionId")
summary = "| Tool | Critical | High | Medium | Low | Status |\n"
summary = summary + "| ---- | ------- | ------ | ----- | ---- | ---- |\n"
for rk, rv in report_summary.items():
summary = f'{summary}| {rv.get("tool")} | {rv.get("critical")} | {rv.get("high")} | {rv.get("medium")} | {rv.get("low")} | {rv.get("status")} |\n'
template = config.get("PR_COMMENT_TEMPLATE")
recommendation = (
"""Please review the findings from Code scanning alerts before approving this pull request. You can also configure the [build rules](https://slscan.io/en/latest/integrations/tips/#config-file) or add [suppressions](https://slscan.io/en/latest/getting-started/#suppression) to customize this bot :+1:"""
if build_status == "fail" else "Looks good :heavy_check_mark:")
body = template % dict(summary=summary,
recommendation=recommendation)
exis_reviews = pr.get_reviews()
review_comment_made = False
if exis_reviews:
for ereview in exis_reviews:
if ereview.body == body:
review_comment_made = True
# Only make one comment at any time
if not review_comment_made:
pr.create_review(commit=repo.get_commit((revisionId)),
body=body,
event="COMMENT")
if build_status == "fail":
pr.add_to_labels("security findings")
else:
pr.remove_from_labels("security findings")
def _parse_spec(self, spec):
"""Overrides the normal Text class behavior. To handle dictation of
special characters like / . _
Unfortunately, I have not found a better place to solve this.
"""
events = []
try:
parts = re.split("\%\([a-z_0-9]+\)s", self._spec)
if len(parts) > 2:
raise Exception("SCText only supports one variable, yet.")
start = len(parts[0])
end = len(spec) - len(parts[1])
words = spec[start:end]
words = lib.format.strip_dragon_info(words)
newText = ""
for word in words:
if (newText != "" and newText[-1:].isalnum() and
word[-1:].isalnum()):
word = " " + word # Adds spacing between normal words.
newText += word
spec = parts[0] + newText + parts[1]
if config.get("aenea.enabled", False) == True:
return spec
for character in spec:
if character in self._specials:
typeable = self._specials[character]
else:
typeable = Keyboard.get_typeable(character)
events.extend(typeable.events(self._pause))
except Exception as e:
print self._spec, parts
print("Error: %s" % e)
return events
def banned(self, user, channel):
ban = False
deny = config.get(user, 'chan_deny')
if deny:
for chan in deny:
if re.match(chan, channel):
ban = True
allow = config.get(user, 'chan_allow')
if allow:
for chan in allow:
if re.match(chan, channel):
ban = False
return ban
def setup_windows():
from windows import main_window
main_window.Window()
winpath = os.path.join(config['execdir'], 'source/gui/windows')
for fn in os.listdir(winpath):
if not fn.endswith('_window.py') or fn == 'main_window.py':
continue
dir, fn = os.path.split(fn)
classname = os.path.splitext(fn)[0]
if config.get('exclude_%s' % classname, False):
logging.info('Skipping class %s', classname)
continue
logging.info('Loading class %s...', classname)
start = time.time()
codestr = "from windows import %s\n%s.Window()" % (classname, classname)
try:
exec codestr
except Exception, e:
print 'Error loading window %s' % classname
TB()
delta = time.time() - start
logging.info(' Time = %.03s', delta)
def send(self, to, content):
conf = config.get('SMS')
with SMS() as sms:
sms.client.messages.create(
body=content,
from_=conf['from'],
to=to
)
def banish(self):
if not self.exists:
return
make_request(TORRC_PREFIX + self.user, "delete")
ports = []
block = get_block({"user": self.user})
ports.append((block["bind_address"], block["bind_port"]))
config.get(None, "listen").remove(block)
block = get_block({"user": self.user, "ssl": 1})
ports.append((block["bind_address"], block["bind_port"]))
config.get(None, "listen").remove(block)
config.write_config()
return ports
def send(self, to, content):
conf = config.get('EMAIL_NOTIFICATION')
with Gmail(conf['account']) as mail:
msg = MIMEText(content)
msg['Content-Type'] = conf['content_type']
msg['Subject'] = conf['title']
msg['From'] = conf['account']
msg['To'] = to
mail.server.sendmail(conf['account'], to, msg.as_string())
def list_chans(self, user, line):
if not config.get(user, 'oper') or utilities.validate(line, 2):
return
allow_chans = config.get(line[1], 'chan_allow', True) or []
deny_chans = config.get(line[1], 'chan_deny', True) or []
for chan in allow_chans:
if chan in deny_chans:
deny_chans.remove(chan)
user.srv_notice('%s : [*] Allowed channels:' % (user.info['nick']))
for chan in allow_chans:
user.srv_notice('%s : - %s' % (user.info['nick'], chan))
user.srv_notice('%s : [*] Denied channels:' % (user.info['nick']))
for chan in deny_chans:
user.srv_notice('%s : - %s' % (user.info['nick'], chan))
def get_block(where):
for listen in config.get(None, "listen"):
match = True
for key in where:
if key not in listen or listen[key] != where[key]:
match = False
break
if match:
return listen
def manage_chan(self, user, line, deny=True):
if not config.get(user, 'oper') or utilities.validate(line, 2):
return
allow_chans = Set([])
deny_chans = Set([])
blocks = []
for listen in config.get(None, 'listen'):
if 'user' in listen and listen['user'] == line[1]:
blocks.append(listen)
if not blocks:
user.srv_notice('%s: [!] User not found: %s' % (user.info['nick'], line[1]))
return
action = 'Allow'
if deny:
action = 'Deny'
user.srv_notice('%s : [*] %sing channel: %s' % (user.info['nick'], action, line[2]))
for block in blocks:
def merge(elem, chans):
if elem not in block:
return
chans.update(block[elem])
merge('chan_allow', allow_chans)
merge('chan_deny', deny_chans)
if deny:
allow_chans.discard(line[2])
deny_chans.add(line[2])
else:
allow_chans.add(line[2])
deny_chans.discard(line[2])
for block in blocks:
block['chan_allow'] = list(allow_chans)
block['chan_deny'] = list(deny_chans)
config.write_config()
def track(track_obj):
"""
Method to send a track message to the telemetry api
:param track_obj:
:return:
"""
# Check if telemetry is disabled
disable_telemetry = config.get("DISABLE_TELEMETRY", False)
if (disable_telemetry == "true" or disable_telemetry == "1"
or not config.get("TELEMETRY_URL")):
disable_telemetry = True
else:
disable_telemetry = False
if track_obj and not disable_telemetry:
try:
track_obj["tool"] = "@ShiftLeft/scan"
requests.post(config.get("TELEMETRY_URL"), json=track_obj)
except Exception:
LOG.debug("Unable to send telemetry")
def discover_packages():
"""
Simple mechanism for discoverability of the packages we build.
A discoverable package, and thus potentially buildable, will be assumed as
any directory name under the packages metadata git repository directory containing
a yaml file with the same name.
Considering the example:
versions
+-- kernel
| +-- kernel.yaml
+-- libvirt
| +-- libvirt.yaml
| +-- someother_file_or_directory
+-- not-a-package
| +-- not-following-standards.yaml
+-- file
"kernel" and "libvirt" will be discovered, "not-a-package" and "file"
will not.
"""
config = CONF.get('common')
versions_repo_url = config.get('packages_metadata_repo_url')
versions_repo_name = os.path.basename(
os.path.splitext(versions_repo_url)[0])
versions_repo_target_path = os.path.join(config.get('work_dir'),
REPOSITORIES_DIR,
versions_repo_name)
package_list = []
try:
package_list = [
package for package in os.listdir(versions_repo_target_path)
if os.path.isdir(os.path.join(versions_repo_target_path, package))
and os.path.isfile(
os.path.join(versions_repo_target_path, package, "".join(
[package, ".yaml"])))
]
except OSError:
LOG.error("No packages found in versions repository directory")
raise
return package_list
def __init__(self, ip_address, timeout=5):
"""
Initialize camera object.
:param ip_address: the camera ip
:param timeout: timeout of http calls
"""
self.url = 'http://%s' % ip_address
self.timeout = timeout
self.save_all = config.get('save_all_snapshots', False)
self.count = 0
def is_authenticated():
"""
Method to check if we are authenticated
"""
sl_home = config.get("SHIFTLEFT_HOME")
sl_config_json = os.path.join(sl_home, "config.json")
if os.path.exists(sl_config_json):
return True
else:
LOG.debug("ShiftLeft config {} not found".format(sl_config_json))
def get_code(self,
max_lines=config.get("CODE_SNIPPET_MAX_LINES"),
tabbed=False):
"""Gets lines of code from a file the generated this issue.
:param max_lines: Max lines of context to return
:param tabbed: Use tabbing in the output
:return: strings of code
"""
if not self.fname:
return ""
lines = []
max_lines = max(max_lines, 1)
if not self.snippet_based:
lmin = max(1, self.lineno - max_lines // 2)
lmax = lmin + len(self.linerange) + max_lines - 1
tmplt = "%i\t%s" if tabbed else "%i %s"
for line in moves.xrange(lmin, lmax):
text = self._get_code_line(self.fname, line)
if isinstance(text, bytes):
text = text.decode("utf-8", "ignore")
if not len(text):
break
lines.append(tmplt % (line, text))
if lines:
return "".join(lines)
elif self.code:
# Validate if the code snippet is in the right format
orig_lines = self.code.split("\n")
if orig_lines:
orig_first_line = orig_lines[0]
firstword = orig_first_line.split(" ", 1)[0]
if firstword and str(firstword).isdigit():
return self.code
return ""
else:
return ""
else:
lineno = self.lineno
try:
tmplineno = 1
with open(self.fname, mode="r") as fp:
for aline in fp:
if aline.strip() == self.code.strip():
lineno = tmplineno
# Fix the line number
self.lineno = lineno
break
tmplineno = tmplineno + 1
except Exception as e:
LOG.debug(e)
tmplt = "%i\t%s" if tabbed else "%i %s"
return tmplt % (lineno, self.code)
def should_send_to_aenea():
"""Utility function for determining whether commands should be sent to Aenea. Commands will be sent if
Aenea is enabled and the Aenea global context application (the one capturing text on behalf of Aenea) is
the foreground window."""
if config.get("aenea.enabled", False) == True:
win = dragonfly.Window.get_foreground()
return aenea.global_context.matches(win.executable, win.title, win.handle)
else:
return False
def listen(self):
"""收音并识别为文字"""
if self.listening == '':
self.listening = str(int(time.time()))
# Player.play(constants.getData('./media/beep_hi.wav'))
audio.play(constants.getData('./media/on.wav'))
hotword_model = constants.getHotwordModel(
config.get('hotword', 'default.pmdl'))
# print(hotword_model)
listener = snowboydecoder.ActiveListener([hotword_model])
voice = listener.listen(
silent_count_threshold=config.get('silent_threshold', 15),
recording_timeout=config.get('recording_timeout', 5) * 4)
# Player.play(constants.getData('./media/beep_lo.wav'))
Player.play(constants.getData('./media/off.wav'))
query = self.asr.transcribe(voice)
utils.rmdir(voice)
logging.debug("listen: " + query)
self.listening = ''
return query
def user_who(self, user, t, target):
if hasattr(t, 'name'):
t = t.name
else:
target = self.trigger('find_user', target)
if not target:
return
self.trigger('send_user_who', user, t, target.info['user'],
target.info['hostname'], config.get(target, 'server_name'),
target.info['nick'], target.info['realname'])
def should_send_to_aenea():
"""Utility function for determining whether commands should be sent to Aenea. Commands will be sent if
Aenea is enabled and the Aenea global context application (the one capturing text on behalf of Aenea) is
the foreground window."""
if config.get("aenea.enabled", False) == True:
win = dragonfly.Window.get_foreground()
return aenea.ProxyPlatformContext('linux').matches(win.executable, win.title, win.handle)
else:
return False
def __init__(self, ip_address, timeout=5):
"""
Initialize camera object.
:param ip_address: the camera ip
:param timeout: timeout of http calls
"""
# self.url = 'http://%s' % ip_address
self.url = 'http://192.168.0.50/cgi-bin/api.cgi?cmd=Snap&channel=0&rs=foo&user=admin&password='******'save_all_snapshots', False)
self.count = 0
def create_database():
if engine == PooledSqliteDatabase:
return
while True:
try:
if engine == PooledMySQLDatabase:
conn = pymysql.connect(user=config.get('db_user'), password=config.get("db_password"),
host=config.get("db_host"), port=int(config.get("db_port")))
elif engine == PooledPostgresqlDatabase:
conn = psycopg2.connect(user=config.get('db_user'), password=config.get("db_password"),
host=config.get("db_host"), port=int(config.get("db_port")))
except (pymysql.OperationalError, psycopg2.OperationalError):
print('db not connected, wait for 5 seconds')
time.sleep(5)
continue
conn.cursor().execute('create database if not exists {} '.format(config.get('db_name')))
return
def suppress_issues(issues):
"""Suppress issues based on the presence of certain tags and ignore logic
:param issues: List of issues to be checked
:return Filtered issues, Suppressed list
"""
suppress_list = []
filtered_list = []
supress_markers = config.get("suppress_markers", [])
for issue in issues:
suppressed = False
issue_dict = issue_from_dict(issue).as_dict()
rule_id = issue_dict.get("test_id")
filename = issue_dict.get("filename")
code = issue_dict.get("code", "").replace("\n", " ").replace("\t", " ")
# Is this rule ignored globally?
if rule_id in config.ignored_rules:
suppressed = True
# Is there an ignore marker
if not suppressed and code:
for marker in supress_markers:
if marker in code:
suppressed = True
break
if not suppressed and filename:
if is_ignored_file(None, file_name=filename):
suppressed = True
else:
for igdir in config.get("ignore_directories"):
if filename.startswith(f"{igdir}/"):
suppressed = True
break
if suppressed:
suppress_list.append(issue)
else:
filtered_list.append(issue)
return filtered_list, suppress_list
def create(self):
if self.exists:
return
standard_port = find_sock()
ssl_port = find_sock([standard_port])
make_request(TORRC_PREFIX + self.user, "create")
make_request(TORRC_PREFIX + self.user, "map", 6667, config.get(None, "default_address"), standard_port)
make_request(TORRC_PREFIX + self.user, "map", 6697, config.get(None, "default_address"), ssl_port)
config.get(None, "listen").append(
{"bind_address": config.get(None, "default_address"), "bind_port": standard_port, "user": self.user}
)
config.get(None, "listen").append(
{"bind_address": config.get(None, "default_address"), "bind_port": ssl_port, "user": self.user, "ssl": 1}
)
config.write_config()
return [
(config.get(None, "default_address"), standard_port, 0),
(config.get(None, "default_address"), ssl_port, 1),
]
def import_dynamic_modules():
global moduleMapping
config = lib.config.get_config()
path = dynamics.__path__
prefix = dynamics.__name__ + "."
print("Loading dynamic grammar modules:")
for importer, package_name, _ in pkgutil.iter_modules(path, prefix):
if package_name not in sys.modules:
module = importer.find_module(package_name).load_module(
package_name)
moduleMapping[module.DYN_MODULE_NAME] = module
enabled = config.get("dynamics.%s" % module.DYN_MODULE_NAME, False)
print(" %s" % package_name)
if enabled == True:
enable_module(module, useSound=False)
def import_dynamic_modules():
global moduleMapping
config = lib.config.get_config()
path = dynamics.__path__
prefix = dynamics.__name__ + "."
print("Loading dynamic grammar modules:")
for importer, package_name, _ in pkgutil.iter_modules(path, prefix):
if package_name not in sys.modules:
module = importer.find_module(package_name).load_module(
package_name)
moduleMapping[module.DYN_MODULE_NAME] = module
enabled = config.get("dynamics.%s" % module.DYN_MODULE_NAME, False)
print(" %s" % package_name)
if enabled == True:
enable_module(module, useSound=False)
def track(track_obj):
"""
Method to send a track message to the telemetry api
:param track_obj:
:return:
"""
# Check if telemetry is disabled
disable_telemetry = config.get("DISABLE_TELEMETRY", False)
if disable_telemetry == "true" or disable_telemetry == "1":
disable_telemetry = True
else:
disable_telemetry = False
if track_obj and not disable_telemetry:
# configure your telemetry api server here
logging.debug(track_obj)
def spawn(self, user, line):
if not config.get(user, "oper") or utilities.validate(line, 2):
return
def _spawn():
user.srv_notice("%s : [*] Spawning onion for %s" % (user.info["nick"], line[1]))
u = GetUser(line[1])
if not u.exists:
u.create()
user.srv_notice("%s : - Added user %s onion: %s" % (user.info["nick"], line[1], u.onion()))
else:
user.srv_notice("%s : - User %s already exists!" % (user.info["nick"], line[1]))
self.thread = None
if hasattr(self, "thread") and self.thread:
user.srv_notice("%s : [!] Spawn or banish already in progress." % user.info["nick"])
else:
self.thread = threading.Thread(target=_spawn)
self.thread.start()
def banish(self, user, line):
if not config.get(user, "oper") or utilities.validate(line, 2):
return
def _banish():
user.srv_notice("%s : [*] Banishing %s!" % (user.info["nick"], line[1]))
u = GetUser(line[1])
if u.exists:
for port in u.banish():
self.trigger("close_server_sock", port[0], port[1])
user.srv_notice("%s : - Banished %s!" % (user.info["nick"], line[1]))
else:
user.srv_notice("%s : - User %s does not exist!" % (user.info["nick"], line[1]))
self.thread = None
if hasattr(self, "thread") and self.thread:
user.srv_notice("%s : [!] Spawn or banish already in progress." % user.info["nick"])
else:
user.thread = threading.Thread(target=_banish)
user.thread.start()
def spawn_all(self):
for server in config.get(None, 'listen'):
if self.server.sock_by_address(server['bind_address'], server['bind_port']):
continue
ssl = False
if 'ssl' in server:
ssl = server['ssl']
s = linechat.Server(User, port=server['bind_port'],
hostname=server['bind_address'], ssl=ssl)
self.server.add_sock(s)
for server in self.server.socks:
try:
sock = server.sock.getsockname()
except:
return
if not config.get_listen_by_host_port(sock):
self.server.rm_sock_by_address(*sock)
from os import environ, listdir
from os.path import isfile,join
from glob import glob
from lib.keystone import KeyStone
from lib.nova import Nova
from lib.cinder import Cinder
from lib.neutron import Neutron
from lib import log
from lib import config
#### Get settings from INI
pfd = config.get('yaml_project_dir')
auth_url = 'http://' + config.get('admin_endpoint_ip') + ':35357/v3'
auth_url_v2 = 'http://' + config.get('admin_endpoint_ip') + ':35357/v2.0'
ks_username = config.get('os_username')
ks_password = config.get('os_password')
project_name = config.get('os_project_name')
gateway_id = config.get('gateway_network_id')
ca_bundle = config.get('ca_bundle_file')
### End Settings
### start API's
keystone = KeyStone(auth_url,ks_username,ks_password,project_name)
nova = Nova(auth_url_v2,ks_username,ks_password,project_name,ca_bundle)
cinder = Cinder(auth_url_v2,ks_username,ks_password,project_name,ca_bundle)
neutron = Neutron(auth_url_v2,ks_username,ks_password,project_name,ca_bundle)
#!/usr/bin/env python2.7
from keystoneclient.auth.identity import v2
from keystoneclient import session
from novaclient import client
from os import environ
import sys
import yaml
from lib import config
from lib import log
auth_url = 'http://' + config.get('admin_endpoint_ip') + ':35357/v2.0'
ks_username = config.get('os_username')
ks_password = config.get('os_password')
project_name = config.get('os_project_name')
yaml_file = config.get('flavor_yaml_file')
ca_bundle = config.get('ca_bundle_file')
with open(yaml_file) as f:
flavors = yaml.safe_load(f)
f.close()
auth = v2.Password(auth_url=auth_url, username=ks_username, password=ks_password, tenant_name=project_name)
sess = session.Session(auth=auth,verify=ca_bundle)
nova = client.Client("2",session=sess)
current = []
def motd(self, user, line):
self.trigger('motd_start', user)
self.trigger('motd_text', user, open(config.get(user, 'motd')).readlines())
self.trigger('motd_end', user)
from dragonfly import (
CompoundRule,
MappingRule,
RuleRef,
Repetition,
Dictation,
IntegerRef,
Grammar,
Text, # @UnusedImport
Key # @UnusedImport
)
import lib.config
config = lib.config.get_config()
if config.get("aenea.enabled", False) == True:
from proxy_nicknames import Key, Text # @Reimport
import aenea
class SeriesMappingRule(CompoundRule):
def __init__(self, mapping, extras=None, defaults=None):
mapping_rule = MappingRule(mapping=mapping, extras=extras,
defaults=defaults, exported=False)
single = RuleRef(rule=mapping_rule)
series = Repetition(single, min=1, max=16, name="series")
compound_spec = "<series>"
compound_extras = [series]
CompoundRule.__init__(self, spec=compound_spec,
extras=compound_extras, exported=True)
def reload_command(self, user, line):
if not config.get(user, 'oper'):
return
user.srv_notice('%s : [*] Reloading config.' % user.info['nick'])
self.reload()
def setConfig(self, config, section="MEOS"):
self.ColorButton.setColor(config.get(section, self.confSection + "Color"))
self.Grosor.setValue(config.getfloat(section, self.confSection + "lineWidth"))
self.Linea.setCurrentValue(config.get(section, self.confSection + "lineStyle"))
self.Marca.setCurrentValue(config.get(section, self.confSection + "marker"))
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from lib import config
import os
config.load()
policies_dir = config.get('global', 'policies_dir')
policies_ext = config.get('global', 'policies_ext')
for f in os.listdir(policies_dir):
dirname = os.path.join(policies_dir, f)
if os.path.isdir(dirname):
for f in os.listdir(dirname):
if f.endswith(policies_ext):
filename = os.path.join(dirname, f)
lines = open(filename).readlines()
blocks = filter(lambda x: x.startswith('block('), lines)
if blocks:
print filename, 'containes the following block lines:'
# write each block rule in new line; [:-1] removes last newline
print ''.join(map(lambda x: x.strip() + "\n", blocks))[:-1]
def numeric(self, num, message):
self.send(':%s %03d %s %s' % (config.get(self, 'server_name'), num,
self.info['nick'], message))
def srv_notice(self, message):
self.send(':%s NOTICE %s' % (config.get(self, 'server_name'), message))
"(add|fix) missing space": Key("c-left/3, space, c-right/3"),
"(delete|remove) (double|extra) (space|whitespace)": Key("c-left/3, backspace, c-right/3"), # @IgnorePep8
"(delete|remove) (double|extra) (type|char|character)": Key("c-left/3, del, c-right/3"), # @IgnorePep8
# Microphone sleep/cancel started dictation.
"[<text>] (go to sleep|cancel and sleep) [<text2>]": Function(cancel_and_sleep), # @IgnorePep8
# Reload Natlink.
"reload Natlink": Function(reload_natlink),
},
namespace={
"Key": Key,
"Text": Text,
}
)
if config.get("aenea.enabled") == True:
# Keypresses, to get that working better in Linux.
grammarCfg.cmd.map.update({
"press <modifierSingle>": Key("%(modifierSingle)s"),
"press <modifier1> <pressKey> [<n>]": Key("%(modifier1)s-%(pressKey)s:%(n)d"), # @IgnorePep8
"press <modifier1> <modifier2> <pressKey> [<n>]": Key("%(modifier1)s%(modifier2)s-%(pressKey)s:%(n)d"), # @IgnorePep8
})
class KeystrokeRule(MappingRule):
exported = False
mapping = grammarCfg.cmd.map
extras = [
IntegerRef("n", 1, 100),
Dictation("text"),
Dictation("text2"),
#!/usr/bin/python
from modules.Module import Module
import lib.utilities as utilities
import lib.config as config
import socket
import urllib
import threading
TORRC_PREFIX = config.get(None, "torrc_prefix")
def make_request(*args):
args = "/".join([str(arg) for arg in args])
auth = "user:password"
onion = "127.0.0.1:5000"
url = "http://%s@%s/onion/%s" % (auth, onion, args)
while 1:
try:
output = urllib.urlopen(url).read()
break
except Exception as e:
print("[!] Request failed: %s, retrying." % e)
if len(output) > 1:
return output
if output == "1":
return True
else:
return False
#!/usr/bin/python2.7
from os import environ
from lib import ad as ad
from lib import ks as ks
from lib import log as log
from lib import config as config
auth_url = 'http://' + config.get('admin_endpoint_ip') + ':35357/v3'
ks_username = config.get('os_username')
ks_password = config.get('os_password')
project_name = config.get('os_project_name')
user = config.get('ad_user')
password = config.get('ad_password')
domain = config.get('ad_domain') + '\\'
to_address = config.get('account_mail_to')
host = config.get('ad_host')
ks_ad_group_sync_id = config.get('ks_ad_group_sync_id')
c = ad.connect(host,domain+user,password)
ksclient = ks.connect(auth_url,ks_username,ks_password,project_name)
def sync_users():
all_users = ad.openstack_users(c)
ks_users = [u.name for u in ksclient.users.list(group=ks_ad_group_sync_id,enabled=True)]
ks_users_disabled = [u.name for u in ksclient.users.list(group=ks_ad_group_sync_id,enabled=False)]
def send_to_opers(self, message):
for user in users:
if config.get(user, 'oper'):
user.srv_notice('%s : - %s' % (user.info['nick'], message))
