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,

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

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.

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.

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...

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.

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"

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?

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

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).

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.

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.

What happened？

There are 1 security vulnerabilities found in cryptography 1.3.4

• CVE-2020-25659

What did I do？

Upgrade cryptography from 1.3.4 to 3.3.2 for vulnerability fix

What did you expect to happen？

Ideally, no insecure libs should be used.

The specification of the pull request

PR Specification from OSCS

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

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.

distutils.spawn.find_executable
Command.__init__
Extension.__init__

Extension.__init__

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.

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?