A free & open modern, fast email client with user-friendly encryption and privacy features

Overview

Welcome to Mailpile!

Build Status

Introduction

Mailpile (https://www.mailpile.is/) is a modern, fast web-mail client with user-friendly encryption and privacy features. The development of Mailpile is funded by a large community of backers and all code related to the project is and will be released under an OSI approved Free Software license.

Mailpile places great emphasis on providing a clean, elegant user interface and pleasant user experience. In particular, Mailpile aims to make it easy and convenient to receive and send PGP encrypted or signed e-mail.

Mailpile's primary user interface is web-based, but it also has a basic command-line interface and an API for developers. Using web technology for the interface allows Mailpile to function both as a local desktop application (accessed by visiting localhost in the browser) or a remote web-mail on a personal server or VPS.

The core of Mailpile is a fast search engine, custom written to deal with large volumes of e-mail on consumer hardware. The search engine allows e-mail to be organized using tags (similar to GMail's labels) and the application can be configured to automatically tag incoming mail either based on static rules or bayesian classifiers.

Note: We are currently working towards a 1.0 release candidate. Until it is ready, Mailpile is really only suitable for developers who can help us find and fix the last few bugs. Our beta releases are obsolete and should not be used, in part for security reasons! For more details follow @MailpileTeam on Twitter or read our blog.

Trying Mailpile

We have live demos up and running on our website. If you are curious about what Mailpile looks like, please feel free to check it out.

Installing Mailpile

Note that Mailpile is still in development and is not suitable for production or end-user use. However, developers and early adopters are encouraged to give it a try and even help us find bugs, fix them and develop new features.

Please see our download page or read the Getting Started guide on our wiki.

Credits and License

Bjarni R. Einarsson (http://bre.klaki.net/) created this! If you think it's neat, you should also check out PageKite: https://pagekite.net/. Smári and Brennan joined the team in 2013 and made this a real project (not just a toy search engine).

The original GMail team deserve a mention for their inspiring work: wishing the Free Software world had something like GMail is what motivated Bjarni to start working on Mailpile. We would also like to thank Edward Snowden for inspiring us to try and make PGP usable for journalists and everday folks!

Contributors:

And of course, we couldn't do this without our community of backers.

This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation. See the file COPYING.md for details.

Comments
  • Translations for UI

    Translations for UI

    Hello i recently found this project, and looks really good, i am search for a web client but we need support spanish language, so i want to know if app support i18n.

    Regards,

    opened by ovnicraft 39
  • XMPP chat integration

    XMPP chat integration

    Hi guys,

    I'm very excited by the promise that Mailpile holds, especially in light of the open development model and the great ideas that are coming out of this issue tracker.

    I see one of your stretch goals is built-in support for XMPP chat.

    I'm the main author of Converse.js, an XMPP chat client similar to GTalk,written fully in Javascript and which can be integrated into any website.

    http://conversejs.org

    I have experience integrating it into a large Python (Plone) site (with single signon/session support), and I'd be happy to contribute to this project as well.

    Regards JC

    Design Front End Back End 
    opened by jcbrand 35
  • Access denied: GPG was unable to decrypt the data

    Access denied: GPG was unable to decrypt the data

    To get started, I did this (after python setup.py install on https://github.com/gthb/Mailpile/tree/patch-2):

    1. $ mailpile
    2. mailpile> setup
    3. mailpile> set profiles.0.email = [email protected]
    4. mailpile> set profiles.0.name = ... here I mucked around with backspace and readline got confused and I hit Ctrl-C, but that quit the program ...

    ... and now it won't start:

    $ mailpile
    Access denied: GPG was unable to decrypt the data.
    
    Bugs Privacy / Security 
    opened by gthb 28
  • Implement Intuitive Interface for PGP Encryption & Signing

    Implement Intuitive Interface for PGP Encryption & Signing

    Making it incredibly easy and intuitive to send signed & encrypted email is not an easy task and there are not many good examples out there. I've been using GPGMail plugin for Mac Mail client which uses GPG Keychain Access- all in all, it works, but there are numerous aspect which I find quite annoying, annoying in fact enough to uninstall the plugin altogether.

    MacMail + GPGMail

    The problems I've encountered with this plugin are:

    Contact Based Format Choosing

    • Defaulting to OpenPGP as opposed to S/MIME is annoying. In theory it offers more verifiability as my emails are "signed", but I argue it is actually a net loss. People whose clients don't support OpenPGP receive an attachment file (which to non tech users) like my Mom, and Friends is confusing. Some say they've tried opening this file, others think it looks like a virus.
    • I propose defaulting to S/MIME and only switching to OpenPGP when a contact is added which has a PGP key associated- at which point we switch to OpenPGP.

    Auto Encrypt When Keys Are Present For Contact

    • I find it weird that when I have a key for a contact I still have to manually remember to choose to "encrypt" the message. If me and a contact have the means to send & receive encrypted msgs, why would I not encrypt them?

    Clearly Explain What is Not Encrypted

    • Addresses and the subject line are not encrypted- this needs to be explained to the user

    Explain Contact Fields Better

    • Most people understand To: Cc: and Bcc: quite well. Adding encryption complicates things. People are Bcc: are not really silent once PGP has been added to an email.
    • Additionally, the words "Participating" and "Listening" seem to more accurately communicate what Cc: and Bcc: are, respectively

    More on this later...

    opened by bnvk 28
  • Plausible deniability and forward security (why not to use PGP)

    Plausible deniability and forward security (why not to use PGP)

    Mailpile plans to secure communications with PGP:

    PGP encryption and verification of emails and recipients

    But PGP's security is at odds with the kind of security appropriate for casual conversation. This is discussed eloquently in the Cypherpunk's paper Why not to use PGP. (They go on to introduce a new cryptosystem with more desirable properties).

    The specific problems with PGP: Suppose your key or your correspondent's key is compromised, say by carelessness, hacking, or court order. Then all your past messages can be decrypted (as well as future ones), and your signatures be verified by a third party (say a court of law).

    Again, in the words of Moxie Marlinspike

    And the problem is that if at any point in the future, Bob’s public key is compromised, all previous traffic is compromised as well; that someone could easily just record all the traffic, and that’s totally not unrealistic today, and then at any point try and compromise Bob’s public key and go back and decrypt all of the previous traffic. So the first thing they notice is that one key compromise affects all previous correspondence. The second thing that seems weird is that the secrecy of what I write is a function of your security practices. I mean, I feel like I’m somewhat paranoid and I have reasonable security practices, but I don’t know about the people that I am communicating with. I would like for what I write to somehow be a function of my security practices. And the third thing that they note is that the PGP model gives you authenticity, but not deniability. If I sign my email “Hey Bob, today I was thinking that Eve is a real jerk” and at some point this email is compromised and discovered, there’s no way for me to deny that I wrote this. So the nice thing is that Bob knows that I wrote it, but there’s no way for me to deny to everyone else that I wrote it – you have this ‘undeniable’ problem.

    To name these problems, PGP doesn't have forward secrecy, and it doesn't have plausible deniability. To be clear, this isn't a break of PGP—it never claimed to have these properties.

    It's not immediately obvious that these properties are even possible. Nevertheless, in 2004, the Cypherpunks exhibited a cryptosystem (off-the-record, or OTR) that fails gracefully:

    You could say that Bob losing control of his private key was the problem. But with today’s easily-compromised personal computers, this is an all-too-likely occurence. We would really prefer to be able to handle such failures gracefully, and not simply give away the farm.

    There were two main problems:

    • The compromise of Bob’s secrets allowed Eve to read not only future messages protected with that key, but past messages as well.
    • When Alice wanted to prove to Bob that she was the author of the message, she used a digital signature, which also proves it to Eve, and any other third party.

    When we think about private messages in the context of social conversation, we really want a system with different properties: we want only Bob to be able to read the message, and Bob should be assured that Alice was the author; however, no one else should be able to do either. Further, after Alice and Bob have exchanged their message, it should be impossible for anyone (including Alice and Bob themselves) to subsequently read or verify the authenticity of the encrypted message, even if they kept a copy of it. It is clear that PGP does not provide these desirable properties.

    This paper introduces a protocol for private social communication which we call “off-the-record messaging”. The notion of an off-the-record conversation well-captures the semantics one intuitively wants from private communication: only the two parties involved are privy to the contents of the conversation; after the conversation is over, no one (not even the parties involved) can produce a [cryptographically verifiable] transcript; and although the participants are assured of each other’s identities, neither they nor anyone else can prove this information to a third party. Using this protocol, Alice and Bob can enjoy the same privacy in their online conversations that they do when they speak in person.

    Ok, so that explains what forward secrecy and deniability are, and why they are desirable. But are they—as I claim—necessary? And if so, why doesn't PGP have them?

    To answer the second question, PGP was written a world ago. Not so much was known then! In 1991 strong cryptography was illegal in the US. The government instead pushed 'key escrow'—encryption to which would always have a backdoor. Phil Zimmerman's stated aims for PGP were to liberate cryptography and to protect the privacy of ordinary conversation from surveillance. As is apparent, the legal battle was won (for the history of how, including why the PGP source code was printed in a paper book, listen to Moxie's talk). Today, crypto underpins the online shopping history. Alas, the second aim hasn't been achieved. Almost all digital communication (text messages, emails, phone calls) remains unencrypted. Security agencies engage in total mass surveillance.

    Now, why is forward security vital? Because key compromises happen. Eventual key compromise should be expected. And it might happen sooner than expected, or without you knowing.

    Legal pressure

    In my country, the UK, it's a criminal offence (RIPA) to refuse to surrender keys to the police. My dad and I used to send PGP encrypted messages to each other—about nothing more than family stuff. Yet at any time in the future, the police may demand my keys. If I yield, they can decrypt all the messages I ever sent. If I refuse, I can be gaoled. Had I used a forward secure protocol, I could safely reveal my private key to the police without compromising past messages (the ephemeral keys would be long lost). On my walk home, I simply announce to my friends to stop using the compromised key.

    Contrary to the PGP FAQ, people in other jurisdictions are not safe. Your government may introduce a similar law in future, and use it to decrypt old messages. Your government may already introduced a similar law in secret.

    Even without draconian laws, intelligence agencies are covertly pressuring providers for keys. Lavabit cracked, but responsibly informed the public and shut down.

    Hacking

    This is speculation (until the next Snowden reveal), but we should assume intelligence agencies are also trying to acquire secret keys by hacking. This is worse than legal pressure, because you might not detect compromise. Forward security doesn't solve the problem, but it is some protection—messages sent before the compromise remain safe.

    Summary

    To protect against today's threats, any cryptosystem worth its salt should be forward secure. Security agencies are recording communications en mass (eg. Prism, Tempura). Key compromises happen regularly.

    There is communication software today (OTR for instant messaging http://www.cypherpunks.ca/otr/ and RedPhone for voice calls https://whispersystems.org/) that does forward secure encryption, authentication, and plausible deniability. That's the standard we want for secure communication. If it's possible for email, we should do it.

    If it's not possible for email, maybe we should ditch email. The network effect makes any change hard, but it's same cost to convince your friends "let's all install pidgin-otr" as "let's all install PGP". The former is a better investment. Encrypting all your messages (and signing them) for five years with the same key—as with PGP—is shooting yourself in the foot.


    It's worth noting Google turned on forward security for their HTTPS servers http://googleonlinesecurity.blogspot.co.uk/2011/11/protecting-data-for-long-term-with.html . I doubt this protects against the NSA--they will have specific backdoors into Google. But it remains an instructional manual for other service providers--use forward secure crypto, make the NSA go out of their way to attack you.

    Discussions 
    opened by hickford 27
  • Create clever copy (jokes) while mail is indexing

    Create clever copy (jokes) while mail is indexing

    Depending on how much email a user imports into Mailpile + how fast there machine, disk, etc are- the process can take a while. Thus, we should display clever copy and jokes along with the progress bar. I'd love to have people contribute ideas to this

    • "Good things come to those who wait"
    • "Make free software and be happy"
    • "Most of Mailpile is made in Iceland, where much of the country believes in elves"
    • "The founders of Mailpile met in a public hot tub in Reykjavik"
    • "Damn kids. They're all alike."
    • "We like volcanos, do you like volcanos?"
    • "Email is the largest internet based social network on the planet"
    • "A million hamsters are spinning their wheels right now"
    • "Tapping earth for more geothermal energy"

    Other ideas would be to follow various category themes like:

    • Names and quotes by political dissidents & whistle blowers
    • Facts about the history of email (or mail in general)

    Also useful will be phrases while generating new public keys for people

    • "Fortifying encryption shields"
    • "Increasing entropy & scrambling bits"
    • "Digging moat, filing with alligators, fortifying walls"
    Packaging & Defaults Low Hanging Fruit 
    opened by bnvk 26
  • Create a forum for users to interact

    Create a forum for users to interact

    Before the 1.0, we need some venue for users of Mailpile to interact with each other, ask questions and help out. Gitub Issues is not a good venue for support or community. Our IRC channel (#mailpile on Freenode) is nice, but it's probably too geeky and it has the downside that since we're not logging it (by choice), experience doesn't accrue and old discussions cannot be discovered in the future.

    The options I'm considering at the moment are:

    • A mailing list
    • A discourse forum, either self-hosted or provided by some service
    • A subreddit

    A mailing list would certainly be the most appropriate for an open source e-mail client project, but since Mailpile's UI for mailing lists isn't very developed yet this isn't a "no brainer" yet. There is of course also the problem that it may lead to a chicken-and-egg situation; if someone is having trouble with their e-mail client, requiring they send and receive e-mail to get help is maybe not super clever.

    Discource is nice. Considering that I already struggle with my existing workload, hosting yet another thing ourselves doesn't seem wise. The flip side of course, is that if we host it ourselves we can make sure our users' privacy is respected. Maybe it's worth doing? People have volunteered to help, maybe I should take someone up on the offer!

    Reddit is a lively boisterous place. I haven't used it enough to know whether it would be suitable. I do expect there would be a large overlap between Mailpile early adopters and reddit users, which is probably a good thing.

    What do you guys think?

    Discussions Documentation 
    opened by BjarniRunar 23
  • Protect message headers in encrypted mail (renamed)

    Protect message headers in encrypted mail (renamed)

    Old subject: Optional encrypted subject line

    if the option is checked, the unsecured subject header would be something generic like "subject:ENCRYPTED", and the real subject would be in the text of the email, possibly an extra MIME part. Mailpile would gracefully use the encrypted subject when possible, suppressing it from the body and showing it in the subject field (and threading on it of course)

    Just a thought

    Back End 
    opened by danx0r 23
  • Rework our Mac OS X integration

    Rework our Mac OS X integration

    The current Mac OS X package is not really usable. Known issues:

    1. The package is unsigned (see #1366)
    2. If multiple users launch Mailpile (using user switching), ports conflict (#1139, #877)
    3. The current approach of launching a terminal and then spawning a browser confuses users

    Item 3 above is the biggie; we are violating the principle of least surprise in a big way. As I understand it, Mac OS X users expect the following:

    1. The app launches and can be started/stopped using an icon in the dock at the bottom.
    2. When clicked, the dock icon should launch a window with UI elements (there may be more than one)

    So that's what we should do. The dock icon can represent the fact that Mailpile is running, clicking it could launch a browser tab (1st iteration?) or a webkit wrapper (2nd iteration?). In addition there should be an option to open a "debug window", which would be the terminal CLI interface. This should not launch by default.

    I think implementation-wise, this means we need a custom app which in turn launches Mailpile in the background and coordinates things. This app can also take care of choosing which port to run on (issue #887). If I recall, the screen utility is included on the Mac, so this launcher app could use the same strategy as mailpile-admin.py, of launching Mailpile itself inside a named screen session that the user can then attach to for debug purposes (and provide a context-menu item for doing exactly that).

    Packaging & Defaults Low Hanging Fruit 
    opened by BjarniRunar 21
  • PGP smartcard support

    PGP smartcard support

    I just tried installing Mailpile on my local system. On starting, it immediately recognized my only GPG key and asked me for its password. Except… I don't have one, because it's on a smartcard.

    In normal usage, GPG agent recognizes my key to be a smartcard and asks me for a PIN, showing me the number of sigs it's made so far. Perhaps similar functionality could be built into mailpile.

    Related to issue #912 I believe.

    Back End Privacy / Security 
    opened by ArdaXi 20
  • Avoid catastrophic data loss in machines with bad RAM

    Avoid catastrophic data loss in machines with bad RAM

    Although ultimately, there's not much we can do on machines with bad hardware, Mailpile is particularly vulnerable to memory corruption because it is a long-running process. Most memory corruption issues would be resolved by restarting the app - unless the configuration itself is corrupted, and the corrupt state has been saved to disk.

    Within the configuration, the most critical piece of data is the master symmetric encryption key itself. If that changes, Mailpile will silently encrypt all new data using the changed key, causing old e-mails and other data to become unreadable from disk. It is very hard to recover from this, if it happens.

    It would not be particularly difficult or expensive to keep multiple copies of the master key in RAM and then compare periodically to make sure the key hasn't changed.

    We would need to take steps to ensure that Python doesn't optimize and unify the storage behind the scenes, but keeping three copies and automatically "voting" on which one is valid every time the key is used wouldn't actually slow things down much. This would mean replacing all use of config.master_key with a function call config.get_master_key(), that does the paranoid best-two-out-of-three thing. Arguably, if corruption is detected, the app might want to complain and shut itself down since that may mean we're on overheated/broken hardware that is likely to make other mistakes.

    Detecting corruption in the rest of the configuration is also important, but much harder to do since it is mutable and is supposed to change.

    For now, protecting the master key seems like low hanging fruit with relatively large upsides though, so marking this issue as such.

    Back End Low Hanging Fruit 
    opened by BjarniRunar 18
  • A list or collection length can not be less than zero it can be great…

    A list or collection length can not be less than zero it can be great…

    This issue was detected in branch master of Mailpile project on the version with commit hash 0989ac. This is an instance of an inappropriate logic.

    Fixes for inappropriate logic: In file: crypto_gnupg.py and workers.py the comparison of Collection length creates a logical short circuit. iCR suggested that the Collection length comparison should be done without creating a logical short circuit.

    This issue was detected by OpenRefactory's Intelligent Code Repair (iCR). We are running iCR on libraries in the PyPI repository to identify issues and fix them. More info at: pypi.openrefactory.com

    opened by openrefactory 0
  • Project dependencies may have API risk issues

    Project dependencies may have API risk issues

    Hi, In Mailpile, inappropriate dependency versioning constraints can cause risks.

    Below are the dependencies and version constraints that the project is using

    appdirs*
    setuptools>=11.3
    cryptography>=1.3.4
    lxml>=2.3.2
    imgsize*
    Jinja2*
    markupsafe*
    py3DNS*
    PySocks*
    pgpdump*
    pillow*
    pbr*
    fasteners*
    stem>=1.4
    icalendar*
    

    The version constraint == will introduce the risk of dependency conflicts because the scope of dependencies is too strict. The version constraint No Upper Bound and * will introduce the risk of the missing API Error because the latest version of the dependencies may remove some APIs.

    After further analysis, in this project, The version constraint of dependency setuptools can be changed to >=51.3.0,<=54.1.1. The version constraint of dependency Jinja2 can be changed to >=2.7,<=3.1.2.

    The above modification suggestions can reduce the dependency conflicts as much as possible, and introduce the latest version as much as possible without calling Error in the projects.

    The invocation of the current project includes all the following methods.

    The calling methods from the setuptools
    distutils.spawn.find_executable
    Command.__init__
    Extension.__init__
    
    The calling methods from the Jinja2
    Extension.__init__
    
    The calling methods from the all methods
    score.add
    smtp_do_or_die
    self._session.config.stop_workers
    self._options.iteritems
    lines.pop.upper
    self.__is_shut_down.clear
    self.find_one_part_value
    msg_ptr.mmbx.get_file_by_ptr.read
    rv.upper
    form.submit
    get_shared_mailpile
    self._load_cookies
    self._overwrite_with
    plugins.outgoing_email_crypto_transform
    opt_obj.get
    thr_keys.sort
    ti.endswith
    data.find
    scope.split
    key_errors.append
    self.select
    res.append
    Message
    Command._error
    tcheck
    self.register_css
    self.variables_as_text
    idx.keylines.set_attr
    play_nice_with_threads
    r.startswith
    self._clean_domain
    args.bb.parse_args.run
    self.flag_cache.get
    self.fd.write
    self.CreateForward
    HeaderPrintMUADetails
    username.lower.split
    mailbox.mbox.clear
    random.sample
    variables.append
    processes.iteritems
    value.replace.replace.strip
    human_tags.join.lower
    happy
    flavor.self.flavor_properties.get.items
    self._hint_days
    MailPileUnittest.__init__
    self.wake_up
    self.buffered.startswith
    ports.append
    term.startswith
    prints.add
    func.__doc__.strip
    _plugins.get_data_kw_extractors
    history_vcl.value.split
    protocols.values
    self.index.MSG_TAGS.msg_info.split
    langs.sort
    ConfigRLock
    self._do_search
    composer.run
    opt.lower
    self.reset_event_discovery_state
    os._exit
    binary.upper
    self._import
    out.write
    msg_id.split.split
    headers.extend
    self.mailbox.get_file_by_ptr
    zlib.compress
    t.get
    gen.flatten
    session.ui.html_variables.get
    NotImplemented
    pvars.update
    columns.sort
    fingerprint.lower
    self._STATUS_ENCRYPTION.get
    msg_thr_mid.split
    BaseMailSource._mailbox_sort_key
    self._conn.close
    ephemeral_mid.rsplit
    self.version_tuple
    self.session.config.load_pickle
    part.set_charset
    self.is_editable_mailbox
    adata.normalized
    user_counts.get
    config.tags.values
    root.lower
    SetLoggedIn
    retrained.append
    self._rescan_vcards
    build.log.warning
    config.vcards.find_vcards
    result.append
    self.display_name
    self._report_option_error
    Compose
    words.append
    self._sorted_msg_ptrs
    os.mkdir
    self.env.session.config.vcards.get_vcard
    self._conn.response
    be.buf.find
    rcpts.get
    self._defaults.keys
    self._lookup
    self._prune_completed
    vcards.iteritems
    tempfile.mkdtemp
    name.self.scripts.replace
    session.config.passphrases.is_set
    self.JOBS.extend
    self._maybe_gzip
    HelpSplash
    msg_data.split.split
    self._STATUS_SIGNATURE.get
    self._get_account
    toc_id.self.get_file.read
    save_error.__str__
    OpenMailbox
    parse_usermap
    full_url.lower
    self.flavor_properties.get
    self._write_postamble
    self._match
    self.reset_rules_from_source
    self.send_http_redirect
    keylist.keys
    os.path.realpath
    _g
    self.do_POST
    pre_command.split
    result.sort
    self.session.config.tags.get
    mbx.apply_tags.extend
    key_id.found_keys.scores.update
    sdata.append
    self._background_save
    path.display_basename
    section.result.append
    authors.get
    find_message_id
    self._lock.release
    self.kid.poll
    error_file.read
    Completer
    tick_func
    config.event_log.events
    k.lower
    self.STATUSES.index
    started_callback
    term.rsplit
    word.startswith
    user_probably_asleep
    base64.encodestring
    ChecksummingStreamer._sha256_callback
    self.log.debug
    threading.Thread
    json.dump
    self._unpack
    bytearray
    config.filters.append
    self.sys.plugins.keys
    request.send_standard_headers
    results.pop
    BaseMailSource.quit
    self._form_defaults
    arg.raw_fp.startswith
    self.GetOAuthURL
    self.WORKERS.append
    ps.communicate
    framework.default_config
    self._tag
    self._shards.append
    islice
    head.check_output.strip.split
    EncryptedDict.rdata_value
    public_keys.iteritems
    log
    self.MSG_THREAD_MID.m_msg_info.split
    self._mbox_cache.append
    self._vcard_get
    notify.keys
    tok_info.user.OAuth2.XOAuth2Response.encode.replace
    self._real_scan_one
    self._write_headers
    FixupForWith
    gzipped.getvalue
    self._failed
    self.add_new_msg
    self.GetOAuthConfig
    password.params.int.params.int.params.int.salt.cryptography.hazmat.backends.default_backend.Scrypt.derive.encode
    config.index.save_changes
    j.g.i.j.g.len.range.j.j.g.join.replace
    self._RECORD_BYTES.self._fd.read.decode
    Update.command
    self.RENAMED.keys
    proto.service_domains.append
    ops.append
    dst.extend
    gpc.bootstrap
    _normalize_key
    method.upper
    session.results.index
    i18n_disabler
    GPG_BINARY
    b64w
    GnuPG21Curve25519KeyGenerator
    mailbox.Maildir
    option.lower
    self.bg_setup_stage_1
    vcard_importers.gpg.append
    e.to_json
    self.index.MSG_REPLIES.conv.get_msg_info.split
    HealthCheck
    _.self.result.strip
    part.get_boundary
    tbird_src.take_over_mailbox
    noproto.split
    self._vcard_set
    problems.append
    Cache
    keyword.replace
    delta.body.rsplit
    droplist.append
    textpart.strip
    self.reap
    self._gnupg.export_pubkeys
    ctrl.authenticate
    self.as_config
    self.auth_type.lower
    MailpileState
    ConfigRule
    mailbox.mbox.__setitem__
    addr.split
    insrv.get
    os.path.dirname
    re.compile
    m.msg_mid
    AutocryptRecord.Load
    config.index.search
    self.RawResult
    fd.read.decode
    e.str.split
    address.partition
    params.append
    fd.seek
    socks.append
    start.startswith
    self.sys.path.get
    f.startswith
    idx.get_msg_id
    event_log.log
    file.write
    es.close
    sendits.iteritems
    self.close
    eids.add
    self.__unicode__.lower
    opt.lower.sect.self._options.display_name
    _open_pop3_mailbox
    self.set_name
    crypto_format.split
    os.urandom
    self._key_generator.start
    build.log.info
    t.tor_controller.remove_ephemeral_hidden_service
    self._get_mx1
    self.is_valid
    self.get_msg_size
    newpart.keys
    groups.append
    UnorderedPicklable
    kid.wait
    lines.pop
    run
    event.source_class.Cancel
    lookup_crypto_keys
    self.idx.get_conversation
    urllib.quote_plus
    ngettext
    self.Window.super.__init__
    mbx.path.startswith
    hdr_value.split
    command.template_path
    vcards.choose_from_address
    MIMEImage
    GnuPG
    l.as_vcardline
    pidfile.open.read
    self.mask_path
    cPickle.dump
    ContactVCard
    self.CommandResult
    t.start
    container.append
    tags.session.Tag.run
    config.get_mail_source
    mp.set
    plaintext.hashlib.md5.hexdigest.startswith
    self._read_filter
    fd.readline.strip
    self.config.get_passphrase
    super
    iter
    Cookie.SimpleCookie
    GetThreadEvent
    msg.rstrip
    self.write_end.close
    KEY_LOOKUP_HANDLERS.sort
    newmsg.get_payload
    self.crypto
    self._sleep
    be.buf.lower
    self.config.items
    payload.decode
    reg
    self.__passkey_recurse__
    json_data.splitlines
    links.append
    xml_attrs
    new_file.tell
    self._delete_routes
    names.extend
    rval
    config._unlocked_get_all_workers
    self.set_event_discovery_state
    GnuPGEventUpdater
    key_info.append
    mailboxes.sort
    unsquish_mimetype
    server.ehlo_or_helo_if_needed
    self.event.update_args
    NamedTemporaryFile
    part.get_filename
    self._mk_command
    cls.RedirectURI
    TOFU_CHECK_HISTORY.keys
    self.tempfile.read
    self.resource
    gzip_obj.close
    self.data_file_and_mimetype
    time.ctime
    value.unicode.lower
    sys.stderr.flush
    filters.sort
    self._conn._new_tag
    ImportError
    part.get
    self.session.config.save_worker.add_unique_task
    dict.keys
    i.self._idx.Email.get_msg
    thr.join
    self._friendly_bytes
    m.name.lower
    self._reorder_all_tags
    sm_connect_server
    os.path.isdir
    MakeBoundary
    self._imap
    self.event_log.ui_unwatch
    self._restore_PGP_keys
    x.split
    make_new_source
    self._name.upper
    CardDAV
    os.path.splitext
    encoded_hdr.strip
    self.server.make_session_id
    vcard.add
    self.config.get_mailboxes
    self.iterkeys
    self.pgp_packet_hdr_parse
    _make_boundary
    self.directory_id
    NoColors.__init__
    ti.split
    self.request.wfile.write
    guard
    self._create_contacts
    l.append
    srs.set_results
    self.CreateMessage
    TemplateNotFound
    cfg.key_types
    mailpiles.values
    hidden_services.iteritems
    self._log_result
    self.get_only_text_part
    _mailpile_key_list
    self.decryption_key_func
    kws.add
    socket.create_connection
    s.display
    conn.quit
    idx.scan_mailbox
    ln
    truthy
    reduce
    string.replace.replace
    self._tag_emails
    self._choose_hint
    Worker._failed
    b.release
    splits.pop
    _plugins.register_config_section
    self._hashgrey_ok
    authors.sort
    self.rfile.read
    config.save_worker.is_idle
    self.sigblock.set_param
    self._process_manifest_pass_two
    self._recently_used_crypto
    p.encode
    keyword.self._cmds
    variables.code.InteractiveConsole.interact
    self.Cell
    value.encode.replace
    okay.append
    self._probe_port
    mbox_cls
    self.session.config.get_tags
    conn.sock.settimeout
    self._get_fd
    tree.keys
    ListFilters.command
    Compose.CreateMessage
    self._update_dict
    X
    self.JOBS_LATER.append
    self.WordInfoClass
    self.expect_exact
    kwargs.keys
    args.sort
    self.compact_to_list
    repr
    obj.add_part
    which.append
    tagname.replace
    match.group.replace.replace.replace.replace.replace
    self.as_vCard
    self._fd.readlines
    manifest.get.get
    TAGGERS.tagger.TAGGERS.get
    matches.groups
    full_method_name.rsplit
    mbox.get_bytes
    config.get_tag
    partial_read_ok.gpg_input.proc.stdin.wtf.StreamWriter.join
    proc.stdin.write
    line_ids.append
    hostport.split
    self._available_opts
    kw.startswith
    p.startswith
    self._add_padding
    play_nice
    self.index.index_email
    mbx_id.lower
    config.load
    existing.get
    ctype.split
    self.source._fmt_path
    p.raw_fp.startswith
    full_name.split
    s.TEST_MSG.splitlines
    pickle.load
    signal.signal
    self.toc_values
    session.Quit.run
    prompt.raw_input.decode
    self.write
    json.load
    expl.update
    self.data.iteritems
    ts.keys
    key_id.lower.session.session.config.index.search.as_set
    opt.lower.sect.self._options.unconvert
    getrandbits
    outputfd.close
    session.load_context
    self.force_display_headers
    line.decode.strip
    self.bin_path.append
    action.extend
    vcl.name.startswith
    expanded_ops.sort
    config.sys.mailbox.append
    vcards.find_vcards
    vcard.sources
    self.source._namespace_info
    CONTACT_IMPORTERS.iteritems
    self._unique_tag_name
    keyword.build.config.items
    capture.render_mode.split
    wrap
    elapsed_datetime
    next
    cgi.parse_header
    self._configure_default_plugins
    app_arguments
    value.unquote.decode
    created.append
    key.startswith
    er.close
    build.log.warn
    vcl.set_attr
    self._test_login_and_proto
    self.SIGNATURE_TYPE.split
    self.LOCK.notify
    MailpileSeleniumTest._get_mailpile_sspec
    c.options
    encryption_info.append
    groups.pop
    args.join.subprocess.check_output.decode.strip
    select.select
    msg.lower
    pmbx.flush
    local.split
    keyinfo.add_subkey_capabilities
    self._email_view_pairs.values
    parent.__getitem__
    config.passphrases.set_passphrase
    os.path.getmtime
    os.path.abspath
    hint
    fingerprints.extend
    mbox.get_file
    prompt.raw_input.decode.strip
    session.searched.extend
    tagname.session.config.get_tag.update
    GPG_VERSIONS.get
    reindex.append
    self.file_id
    path.raw_fp.split
    imap.mailbox_info
    emails.e.e.msg_mid.self.session.AddContact.run
    CRYPTO_POLICIES.append
    key_info_class
    self._shutdown
    self.db.cdict.keys
    options.load_defaults
    bb.parse_args
    mailbox._PartialFile
    qr.split
    TXT_RE_QUOTE.replace
    keep_open.extend
    AccessError
    socket.inet_pton
    NoFromAddressError
    pColumnDict.match
    source_obj.take_over_mailbox
    self.kid.wait
    backup_data.encode
    self.expire
    delete_mailpile
    lmfn.abs_paths.append
    msg_id.split
    self._summarize_auth
    val.strip
    tasksToBeExecuted.append
    scope.named_file
    s.unescape
    kwargs.args.command.self.env.session.Action.as_dict
    idx.lines.startswith
    path.encode
    self.result.get
    self.flatten
    unittest.TestCase.__init__
    session.config.filters.append
    self._extract_date_ts
    self._default_policy
    pl.startswith
    self.component_id
    m_subj.lower.replace
    action.split
    pLine.sub
    pCell.findall
    reply_mids.append
    crypto.decrypt
    subprocess.check_output
    end.append
    self.register_worker
    self._getclues
    self.set_passphrase
    dedup.append
    self.last_headers.split
    self.start
    mbox.describe_msg_by_ptr
    config.sys.plugins_early.append
    self._idx
    c._types.append
    keylines.sort
    proc.stderr.read
    self._decode_value
    cfg.get_tag
    session.config.index.sort_results
    r.rsplit
    self._offset
    args.join.decode
    part.as_string
    os.fdopen
    CC_CONFIG_MAP.get
    keyinfo.recalculate_expiration
    record.iv.self._aes_key.aes_ctr_encrypt.iv.encode
    self.gpg_pass.read
    wervd.MailpileMailbox
    cls.ustr.super.__new__
    pgpdata.append
    found_keys.values
    text.strip.splitlines
    self._delete_sources
    self.cache.insert
    VCard.command
    MorkImporter
    shutil.rmtree
    self.auto_configure_tor
    reasons.get
    UserSessionCache
    fset
    rpc_server.serve_forever
    part.is_multipart
    self.splitter.setOrientation
    index.MSG_TAGS.msg_info.split
    locks.locked
    hl.strip.split
    src.get_metadata_keywords
    GnuPG14KeyGenerator
    self._discover_plugins
    check
    self.tempfile.close
    app_args.parse_args
    quopri.encodestring
    self.source_class.EventAsHtml
    Window
    self.version.add_header
    tls_new_context
    raw.reverse
    self._path.os.path.join.open.write
    config.oauth.providers.keys
    self.session.config.sys.md5sum_blacklist.split
    in_fd.close
    self.GIT_DIFF_LINE.match
    self.LOADED.append
    lines.join.lower
    id_src_map.get
    extra_headers.append
    good.append
    crypto.as_set
    ...
    

    @Singletoned Could please help me check this issue? May I pull a request to fix it? Thank you very much.

    opened by PyDeps 1
  • Internal error: 'NoneType' object has no attribute 'mailbox_info'

    Internal error: 'NoneType' object has no attribute 'mailbox_info'

    I recently installed Mailpile via Dockerfile to test it out, I connected an Outlook account to it and I configured it this way:

    • IMAP/TLS: outlook.office365.com - port 993 - Authentication: Password
    • No SMTP configuration
    • Encryption key: Disable encryption for this account

    Now, what happens is that it was able to retrieve emails only from the "Sent" folder, but not from the inbox, and every time i open the inbox I get the message "Internal error! Sleeping", so I checked the logs and i found this traceback:

        "traceback": "Traceback (most recent call last):
      File \"/Mailpile/mailpile/mail_source/__init__.py\", line 1094, in run
        self.sync_mail()
      File \"/Mailpile/mailpile/mail_source/__init__.py\", line 307, in sync_mail
        elif (self._has_mailbox_changed(mbx_cfg, state) or
      File \"/Mailpile/mailpile/mail_source/imap.py\", line 983, in _has_mailbox_changed
        uv = state['uv'] = shared_mbox.mailbox_info('UIDVALIDITY', ['0'])[0]
    AttributeError: 'NoneType' object has no attribute 'mailbox_info'
    "
    

    Is there something I can look for to get it working?

    opened by alakel1 0
  • Upgrade to Debian 11 Bullseye broke Mailpile

    Upgrade to Debian 11 Bullseye broke Mailpile

    I recently upgraded my OS to Debian 11 Bullseye. This broke Mailpile. It appears that, due to the end of upstream support for Python 2.7, the Debian packages providing a number of Python2 modules have been removed from Bullseye, e.g. python-icalendar, python-appdirs, python-cryptography, python-lxml ... . Also, python-pip (for 2.7) has been removed. It is present in Debian testing but has a number of serious bug reports.

    After considerable hacking (e.g. attempting to install pip from testing and other packages from oldstable) with no success I decided to remove Debian Python2 packages completely from my Bullseye system and to do a "local" Python2 install (i.e. by a non-privileged user without using root). Then it was possible to use pip to install the needed Python packages. I still do not have virtualenv working, so I am not using it. Mailpile now works as before.

    Of course this is not a long term solution since there's no longer support upstream for Python 2.7 and it could result in security vulnerabilities. It works for now!

    Here's an outline of the process, after upgrading to Bullseye.

    • With Synaptic, as root, purge python2.7, python2.7-minimal, libpython2.7-minimal, libpython2.7-stdlib.
    • Following advice here (see ** below) with apt, as root, apt install libncurses-dev libgdbm-dev libz-dev tk-dev libsqlite3-dev libreadline-dev liblzma-dev libffi-dev libssl-dev
    • As unprivileged user (jack in this example), download https://www.python.org/ftp/python/2.7.18/Python-2.7.18.tgz
    • Calculate and check the MD5 hash of the downloaded file which is here
    md5sum Python-2.7.18.tgz
    38c84292658ed4456157195f1c9bcbe1  Python-2.7.18.tgz
    
    • Extract the above and cd to the extracted directory, then
    make clean
    ./configure --prefix="/home/jack/.local" --with-ensurepip=install
    make
    make install
    
    • Go to the Mailpile program directory and install required Python packages using pip:
    export PATH=/home/jack/.local/bin:$PATH
    pip install -r requirements-dev.txt
    
    • Launch Mailpile (substituting your own Mailpale data directory in MAILPILE_HOME):
    export PATH=/home/jack/.local/bin:$PATH
    export PYTHONHOME=/home/jack/.local
    export MAILPILE_HOME="/home/jack/.local/share/Mailpile/jack"
    ./mp
    

    Notes:

    • ** If the apt install step specified above is not performed, the "make" step produces the following output: Python build finished, but the necessary bits to build these modules were not found: _bsddb _curses _curses_panel
      _sqlite3 _ssl _tkinter
      bsddb185 bz2 dbm
      dl gdbm imageop
      readline sunaudiodev Then pip crashes because it is unable to use https. The apt install step corrects this. The make step still complains about some "missing bits", but _ssl is not among them, and pip works.

    • The make clean step does not appear to completely clean the installation configuration. It may be necessary to manually delete /home/jack/.local/lib/pkgconfig /home/jack/.local/lib/python2.7 /home/jack/.local/lib/libpython2.7.a /home/jack/.local/include/python2.7

    WIth Mailpile not working, I was forced to access my email with Thunderbird and K9Mail for a couple of weeks. This reminded me how much I like Mailpile, especially it's search capability. Thanks @BjarniRunar and the other contributors!

    opened by JackDca 2
Releases(1.0.0rc6)
Owner
mailpile
A modern, fast web-mail client with user-friendly encryption and privacy features
mailpile
Insular email distribution - mail server as Docker images

Mailu is a simple yet full-featured mail server as a set of Docker images. It is free software (both as in free beer and as in free speech), open to s

Mailu 4k Sep 26, 2022
Reference client for Bitmessage: a P2P encrypted decentralised communication protocol:

PyBitmessage Bitmessage is a P2P communication protocol used to send encrypted messages to another person or to many subscribers. It is decentralized

Bitmessage 2.7k Oct 2, 2022
the first third-party instant messaging client for Google Hangouts

hangups hangups is the first third-party instant messaging client for Google Hangouts. It includes both a Python library and a reference client with a

Tom Dryer 1.7k Sep 22, 2022
Zulip server and webapp - powerful open source team chat

Zulip overview Zulip is a powerful, open source group chat application that combines the immediacy of real-time chat with the productivity benefits of

Zulip 16.4k Sep 22, 2022
ProPublica's collaborative tip-gathering framework. Import and manage CSV, Google Sheets and Screendoor data with ease.

Collaborate This is a web application for managing and building stories based on tips solicited from the public. This project is meant to be easy to s

ProPublica 85 Sep 3, 2022
Securely and anonymously share files, host websites, and chat with friends using the Tor network

OnionShare OnionShare is an open source tool that lets you securely and anonymously share files, host websites, and chat with friends using the Tor ne

Micah Lee 5.3k Oct 2, 2022
Askbot is a Django/Python Q&A forum. **Contributors README**: https://github.com/ASKBOT/askbot-devel#how-to-contribute. Commercial hosting of Askbot and support are available at https://askbot.com

ATTENTION: master branch is experimental, please read below Askbot - a Django Q&A forum platform This is Askbot project - open source Q&A system, like

ASKBOT 1.5k Sep 27, 2022
A wiki system with complex functionality for simple integration and a superb interface. Store your knowledge with style: Use django models.

django-wiki Django support The below table explains which Django versions are supported. Release Django Upgrade from 0.7.x 2.2, 3.0, 3.1 0.5 or 0.6 0.

django-wiki 1.6k Sep 24, 2022
Easy-to-use and powerful offline translation tool

Introduction Virtaal is a graphical program for doing translation. It is meant to be easy to use and powerful at the same time. Although the initial f

Translate 268 Sep 22, 2022
Fully Automated YouTube Channel ▶️with Added Extra Features.

Fully Automated Youtube Channel ▒█▀▀█ █▀▀█ ▀▀█▀▀ ▀▀█▀▀ █░░█ █▀▀▄ █▀▀ █▀▀█ ▒█▀▀▄ █░░█ ░░█░░ ░▒█░░ █░░█ █▀▀▄ █▀▀ █▄▄▀ ▒█▄▄█ ▀▀▀▀ ░░▀░░ ░▒█░░ ░▀▀▀ ▀▀▀░

sam-sepiol 218 Sep 27, 2022
Email-bomber - Email bomber unlike other email bombers u don't need your gmail email id to use this

Email-bomber - Email bomber unlike other email bombers u don't need your gmail email id to use this

rfeferfefe 61 Sep 26, 2022
Modern, privacy-friendly, and detailed web analytics that works without cookies or JS.

Modern, privacy-friendly, and cookie-free web analytics. Getting started » Screenshots • Features • Office Hours Motivation There are a lot of web ana

R. Miles McCain 2k Sep 21, 2022
As easy as /aitch-tee-tee-pie/ 🥧 Modern, user-friendly command-line HTTP client for the API era. JSON support, colors, sessions, downloads, plugins & more. https://twitter.com/httpie

HTTPie: human-friendly CLI HTTP client for the API era HTTPie (pronounced aitch-tee-tee-pie) is a command-line HTTP client. Its goal is to make CLI in

HTTPie 23.8k Sep 23, 2022
As easy as /aitch-tee-tee-pie/ 🥧 Modern, user-friendly command-line HTTP client for the API era. JSON support, colors, sessions, downloads, plugins & more. https://twitter.com/httpie

HTTPie: human-friendly CLI HTTP client for the API era HTTPie (pronounced aitch-tee-tee-pie) is a command-line HTTP client. Its goal is to make CLI in

HTTPie 23.9k Sep 28, 2022
Privacy as Code for DSAR Orchestration: Privacy Request automation to fulfill GDPR, CCPA, and LGPD data subject requests.

Meet Fidesops: Privacy as Code for DSAR Orchestration A part of the greater Fides ecosystem. ⚡ Overview Fidesops (fee-dez-äps, combination of the Lati

Ethyca 42 Sep 6, 2022
Official repository of the paper Privacy-friendly Synthetic Data for the Development of Face Morphing Attack Detectors

SMDD-Synthetic-Face-Morphing-Attack-Detection-Development-dataset Official repository of the paper Privacy-friendly Synthetic Data for the Development

null 9 Sep 9, 2022
An easy to use, user-friendly and efficient code for extracting OpenAI CLIP (Global/Grid) features from image and text respectively.

Extracting OpenAI CLIP (Global/Grid) Features from Image and Text This repo aims at providing an easy to use and efficient code for extracting image &

Jianjie(JJ) Luo 8 Sep 25, 2022
FPKG Maker GUI - A user friendly User Interface for fPKG Tools for PS4

Know Issues being worked on Please place this application on the root of a drive

null 24 Jul 19, 2022
A friendly wrapper for modern SQLAlchemy and Alembic

A friendly wrapper for modern SQLAlchemy (v1.4 or later) and Alembic. Documentation: https://jpsca.github.io/sqla-wrapper/ Includes: A SQLAlchemy wrap

Juan-Pablo Scaletti 126 Jul 9, 2022
A modern/fast python SOAP client based on lxml / requests

Zeep: Python SOAP client A fast and modern Python SOAP client Highlights: Compatible with Python 3.6, 3.7, 3.8 and PyPy Build on top of lxml and reque

Michael van Tellingen 1.7k Sep 28, 2022