Exemplo n.º 1
0
    def _check_config(self):
        if not exists(self.settings_fname):
            config = ConfigObj()
            config.filename = self.settings_fname
            self.server = config['server'] = '158.98.137.17:950'
            self.username = config['user'] = '******'
            self.password = None
            config.write()
        else:
            config = ConfigObj(self.settings_fname)
            self.server = config['server']
            self.username = config['user']

        self.keyring = Keyring('gsni-authenticator', self.username,
                               self.server, 'gsni')

        # Support < 0.3 passwords stored on file
        if 'pass' in config:
            self.password = config['pass']
            del config['pass']
            self.keyring.set_password(self.password)
            config.write()
        if not self.password:
            try:
                self.password = self.keyring.get_password()
            except gnomekeyring.NoMatchError:
                return False
        return True
Exemplo n.º 2
0
 def removeAccount(self):
     row = self.tableWidget.selectionModel().selectedRows()[0].row()
     email = self.tableWidget.item(row, 0).text()
     kr = Keyring()
     kr.deletePassword(email)
     self.tableWidget.removeRow(row)
     self.emails.pop(row)
     self.types.pop(row)
Exemplo n.º 3
0
 def addAccount(self):
     dialog = AddAccountDialog(self)
     if dialog.exec_() != QDialog.Accepted: return
     email = unicode(dialog.emailEdit.text())
     passwd = unicode(dialog.passwordEdit.text())
     ac_type = unicode(dialog.typeCombo.currentText())
     self.tableWidget.insertRow(0)
     self.tableWidget.setItem(0, 0, QTableWidgetItem(email))
     self.tableWidget.setItem(0, 1, QTableWidgetItem(ac_type))
     self.emails.insert(0, email)
     self.types.insert(0, ac_type)
     kr = Keyring()
     kr.setPassword(email, passwd)
Exemplo n.º 4
0
 def setupClient(self):
     """ Login to email server (IMAP) """
     email_id = str(self.settings.value('EmailId', '').toString())
     if email_id == '':
         QMessageBox.warning(self, 'No Account Selected !',
                                 'Please Click on Menu and Select an account to login')
         return
     kr = Keyring()
     passwd = kr.getPassword(email_id)
     if not passwd :
         QMessageBox.critical(self, 'Not Found !', 'Password not found for the email %s'%email_id)
         return
     print 'login requested'
     self.loginRequested.emit(email_id, passwd)
Exemplo n.º 5
0
def encrypt_and_pack(plaintext: bytes, ring: Keyring, privkey: bytes) -> str:
    symm_ciphertext, symm_key = _symmetric_encrypt(plaintext)
    group_keys = ring.encrypt(symm_key)
    fmt, ciphertext_block = pack_keys_and_ciphertext(group_keys, symm_ciphertext)
    sig = asymmetric.sign(ciphertext_block, privkey)
    fmt, packed = pack_sig_and_block(fmt, sig, ciphertext_block)
    string_data_to_write = serialize_everything(fmt, packed)
    return string_data_to_write
Exemplo n.º 6
0
	def __init__(self, button, config):
		gtk.ScrolledWindow.__init__(self)
		self.props.hscrollbar_policy = gtk.POLICY_AUTOMATIC
		self.props.vscrollbar_policy = gtk.POLICY_AUTOMATIC

		#TODO set the email count to the button label
		self.button = button

		self.emailList = gtk.VBox()
		self.emailList.set_spacing(12)
		self.emailList.pack_start(gtk.Label('Loading emails...'))
		self.add_with_viewport(self.emailList)
		
		self.imapConnectors = list()

		for i in range(int(config.get("misc", "accounts"))):
			domain = config.get("email"+str(i), "domain")
			port = int(config.get('email'+str(i), 'port'))
			protocol = config.get('email'+str(i), 'protocol')
			keyring = Keyring('TouchMenu settings for '+domain, domain, protocol)
			if keyring.has_credentials():
				connector = None
				cred = keyring.get_credentials()
				if protocol == 'imap' and port == 993:
					connector = imaplib.IMAP4_SSL(domain, port)
				elif protocol == 'imap' and port == 143:
					connector = imaplib.IMAP4(domain, port)
				else:
					raise "Unrecognised Email protocol/port"
				connector.login(cred[0], cred[1])
				connector.select('INBOX', True)
				self.imapConnectors.append(connector)

		self.updater = EmailThread(self, int(config.get('misc', 'email-interval')))
		self.updater.connect("doneFetching", self.updatePane)
		self.updater.start()
		self.updater.onTrigger()

		self.connect("destroy", self.destroy)
Exemplo n.º 7
0
	def save(self, widget):
		config = RawConfigParser()
		config.add_section("misc")
		config.set("misc", "accounts", "1")
		config.add_section("email0")
		domain = self.domain.get_text()
		config.set("email0", "domain", domain)
		config.set("email0", "port", self.port.get_text())
		config.set("email0", "protocol", 'imap')

		keyring = Keyring('TouchMenu settings for '+domain, domain, 'imap')
		keyring.set_credentials((self.user.get_text(), self.password.get_text()))

		try:
			os.remove(os.path.expanduser("~/.touchmenu/settings"))
		except:
			pass

		os.mkdir(os.path.expanduser('~/.touchmenu/'))
		os.mkdir(os.path.expanduser('~/.touchmenu/mozilla/'))
		config.write(open(os.path.expanduser("~/.touchmenu/settings"), 'wb'))
		gtk.main_quit()
Exemplo n.º 8
0
def getfreeapp(html, br):
    global didIbuy
    soup = BeautifulSoup(html)
    for widget in soup.findAll("div", {"class": "fad-widget-large"}):
        if isappfree(widget):
            br.select_form(name="handleBuy")
            appurchached = br.submit().read()
            #print appurchached
            didIbuy = True
        else:
            print "Free app not free!"


if __name__ == '__main__':

    kr = Keyring()
    #time.sleep(random.randint(1,120))
    options = getOptions()

    br = mechanize.Browser()
    #   br.set_proxies({"http":"localhost:8080"})
    br.set_handle_robots(False)
    br.addheaders = [(
        "User-agent",
        "Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.2.13) Gecko/20101206 Ubuntu/10.10 (maverick) Firefox/3.6.13"
    )]

    sign_in = br.open("http://www.amazon.com/gp/flex/sign-out.html")

    br.select_form(name="sign-in")
    if options.username != None:
Exemplo n.º 9
0
def getfreeapp(html, br):
    global didIbuy
    soup = BeautifulSoup(html)
    for widget in soup.findAll("div", {"class":"fad-widget-large"}):
        if isappfree(widget):
            br.select_form(name="handleBuy")
            appurchached = br.submit().read()
            #print appurchached
            didIbuy = True
        else:
            print "Free app not free!"

if __name__ == '__main__':

    kr = Keyring()
    #time.sleep(random.randint(1,120))
    options = getOptions()

    br = mechanize.Browser()
#   br.set_proxies({"http":"localhost:8080"})
    br.set_handle_robots(False)
    br.addheaders = [("User-agent", "Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.2.13) Gecko/20101206 Ubuntu/10.10 (maverick) Firefox/3.6.13")]

    sign_in = br.open("http://www.amazon.com/gp/flex/sign-out.html")

    br.select_form(name="sign-in")
    if options.username != None:
        br["email"] = options.username
        br["password"] = options.password
    else:
Exemplo n.º 10
0
	def Key(self, fingerprint=None):
		if fingerprint is not None:
			return Keyring().Key(self.Entropy(),fingerprint)
		else: 
			return Keyring().Key(self.Entropy(),'')
Exemplo n.º 11
0
class AuthClient(object):
    def __init__(self, options):
        self.options = options
        self.debuglevel = 1 if options.debug else 0
        self.is_manual_auth = False
        self.server = self.password = self.username = None
        DBusGMainLoop(set_as_default=True)
        self.bus = dbus.SystemBus()
        self.dbus_get_network_manager().connect_to_signal(
            "StateChanged", self.onNetworkStateChanged)
        self.dbus_get_network_manager_settings().connect_to_signal(
            "NewConnection", self.onNewConnection)
        self.tray = gtk.StatusIcon()
        self.set_icon('gsni_auth_regular.png')
        self.tray.set_tooltip(_('Not authenticated'))
        self.tray.connect('popup-menu', self.on_right_click, 'test')
        self.doing_login = False
        self.settings_dialog = False
        config_dir = options.config_dir or join(xdg_config_home,
                                                'gsni-authenticator')
        if options.is_spain:
            resources.UI_DIR_NAME = 'ui_es'
        else:
            resources.UI_DIR_NAME = 'ui_pt'
        if options.set_icon_flag:
            resources.UI_DIR_NAME = 'ui_' + options.set_icon_flag
        print config_dir
        if not exists(config_dir):
            os.makedirs(config_dir)

        self.settings_fname = join(config_dir, 'auth.conf')

        self.agnclient_watcher = AGNClientConnectWatcher(
            self.on_agnclient_connect)
        self.agnclient_watcher.start()

    def on_right_click(self, icon, event_button, event_time, data=None):
        self.make_menu(event_button, event_time, data)

    def make_menu(self, event_button, event_time, data):
        menu = gtk.Menu()

        # show data string
        item = gtk.MenuItem("Authenticate")
        if not self.doing_login:
            item.show()

        menu.append(item)
        item.connect('activate', self.do_manual_auth)

        # show settings dialog
        item = gtk.MenuItem("Config...")
        if self.settings_dialog:
            item.set_sensitive(False)
        item.show()
        menu.append(item)
        item.connect('activate', self.do_config)

        # show about dialog
        item = gtk.MenuItem("About")
        item.show()
        menu.append(item)
        item.connect('activate', self.show_about_dialog)

        separator = gtk.SeparatorMenuItem()
        separator.show()
        menu.append(separator)
        # add quit item
        quit = gtk.MenuItem("Quit")
        quit.show()
        menu.append(quit)

        quit.connect('activate', gtk.main_quit)

        menu.popup(None, None, gtk.status_icon_position_menu, event_button,
                   event_time, self.tray)

    def _check_config(self):
        if not exists(self.settings_fname):
            config = ConfigObj()
            config.filename = self.settings_fname
            self.server = config['server'] = '158.98.137.17:950'
            self.username = config['user'] = '******'
            self.password = None
            config.write()
        else:
            config = ConfigObj(self.settings_fname)
            self.server = config['server']
            self.username = config['user']

        self.keyring = Keyring('gsni-authenticator', self.username,
                               self.server, 'gsni')

        # Support < 0.3 passwords stored on file
        if 'pass' in config:
            self.password = config['pass']
            del config['pass']
            self.keyring.set_password(self.password)
            config.write()
        if not self.password:
            try:
                self.password = self.keyring.get_password()
            except gnomekeyring.NoMatchError:
                return False
        return True

    def do_manual_auth(self, widget):
        self.is_manual_auth = True
        self.do_login(widget)

    def do_login(self, widget):
        if not self._check_config():
            if self.is_manual_auth and not self._run_config():
                return
        if self.doing_login:
            return
        self.doing_login = True
        self._login_in_thread()

    def on_agnclient_connect(self):
        self.do_login(self)

    def do_config(self, widget):
        self._check_config()
        self._run_config()

    def _run_config(self):
        prompt = EntryDialog(default_value=self.server,
                             buttons=gtk.BUTTONS_OK_CANCEL)
        prompt.set_markup('What is your GSNI server?')
        server = prompt.run()
        prompt.hide()
        if not server:
            return False
        prompt = EntryDialog(default_value=self.username,
                             buttons=gtk.BUTTONS_OK_CANCEL)
        prompt.set_markup('What is your GSNI username?')
        username = prompt.run()
        prompt.hide()
        if not username:
            return False
        prompt = EntryDialog(default_value=self.password or '',
                             buttons=gtk.BUTTONS_OK_CANCEL,
                             visibility=False)
        prompt.set_markup('What is your GSNI password?')
        password = prompt.run()
        prompt.hide()
        if not password:
            return False
        self.password = password
        self.keyring.set_password(self.password)
        config = ConfigObj(self.settings_fname)
        config['server'] = self.server = server
        config['user'] = self.username = username
        config.write()
        return True

    def _login_in_thread(self):
        gobject.timeout_add(300, self.swap_icon, True)
        Thread(target=self._login_function).start()

    def _login_function(self):
        tacacs = Auth("https://" + self.server, self.debuglevel,
                      self.options.three_steps_auth)
        login_result = tacacs.login(self.username, self.password)
        gobject.idle_add(self._login_completed, login_result)

    def _login_completed(self, ret):
        self.doing_login = False
        print "Ret=", ret

        if ret == -1:
            retry_login = 600  # Retry in 10mins
            self.set_icon('gsni_auth_regular.png')
            self.tray.set_tooltip('Unable to connect to server ' + self.server)
        elif ret == -2:
            retry_login = None
            self.set_icon('gsni_auth_error.png')
            self.tray.set_tooltip('Failed authentication on ' + self.server)
        elif ret == 0:
            retry_login = 3600  # Retry in 1h
            self.set_icon('gsni_auth_connected.png')
            self.tray.set_tooltip('Successfully authenticated to ' +
                                  self.server)

        if retry_login:
            print "Repeating authentication in %d minutes." % int(
                retry_login / 60)
            gobject.timeout_add_seconds(retry_login, self.do_login, None)
        self.is_manual_auth = False

    def dbus_get_network_manager(self):
        """Gets the network manager dbus interface."""
        print "Getting NetworkManager DBUS interfacse"
        proxy = self.bus.get_object('org.freedesktop.NetworkManager',
                                    '/org/freedesktop/NetworkManager')
        return dbus.Interface(proxy, 'org.freedesktop.NetworkManager')

    def dbus_get_network_manager_settings(self):
        """Gets the network manager dbus interface."""
        print "Getting NetworkManager(VP) DBUS interfacse"
        proxy = self.bus.get_object(
            'org.freedesktop.NetworkManager',
            '/org/freedesktop/NetworkManager/Settings')
        return dbus.Interface(proxy, 'org.freedesktop.NetworkManager.Settings')

    def onNetworkStateChanged(self, state):
        print "Network state changed to", state
        if state == 70:
            print "Checking for an BMI IP address"
            if self.running_with_ibm_network():
                print "Network connection established and running with BMI net, authenticating... "
                self.on_agnclient_connect()

    def onNewConnection(self, state):
        print "New connection detected"
        print "Checking for an BMI IP address"
        if self.running_with_ibm_network():
            print "Network connection established and running with BMI net, authenticating... "
            self.on_agnclient_connect()

    def swap_icon(self, value):
        if not self.doing_login:
            return
        if value:
            self.set_icon('gsni_auth_connected.png')
        else:
            self.set_icon('gsni_auth_regular.png')
        gobject.timeout_add(300, self.swap_icon, value ^ True)

    def running_with_ibm_network(self):
        for network in get_network_interfaces():
            addresses = network.addresses.get(AF_INET)
            if not addresses:
                continue
            for addr in addresses:
                if addr.startswith('9.'):
                    return True
            continue
        return False

    def run(self):
        gtk.gdk.threads_init()
        if self.running_with_ibm_network():
            gobject.idle_add(self.do_login, None)
        gtk.main()

    def set_icon(self, name):
        self.tray.set_from_file(resources.get_ui_asset(name))
        self.Icon_name = name

    def show_about_dialog(self, widget):
        about_dialog = gtk.AboutDialog()
        about_dialog.set_destroy_with_parent(True)
        about_dialog.set_icon_name("gsni-authenticator")
        about_dialog.set_name('GSNI Authenticator')
        about_dialog.set_version('0.8.4')
        about_dialog.set_copyright("(C) 2013-2018 BMI")
        about_dialog.set_comments(
            _("Automated authentication with a gSNI server"))
        about_dialog.set_authors(['*****@*****.**'])
        about_dialog.run()
        about_dialog.destroy()

    def desktop_notify(self, status_change, icon_path):
        notify = pynotify.Notification("GSNI Authentication", status_change,
                                       icon_path)
        notify.set_urgency(pynotify.URGENCY_LOW)
        notify.set_timeout(3000)
        notify.show()