pax_global_header00006660000000000000000000000064130423563410014513gustar00rootroot0000000000000052 comment=e007216d98324efd96a39b8ede9f44cd197db13e schleuder-3.0.1/000077500000000000000000000000001304235634100134725ustar00rootroot00000000000000schleuder-3.0.1/.gitattributes000066400000000000000000000000251304235634100163620ustar00rootroot00000000000000/gems/ export-ignore schleuder-3.0.1/.gitignore000066400000000000000000000000631304235634100154610ustar00rootroot00000000000000.bundle vendor *.swp db/*.sqlite3 testmails/* .pc/ schleuder-3.0.1/.rspec000066400000000000000000000000361304235634100146060ustar00rootroot00000000000000--color --require spec_helper schleuder-3.0.1/.travis.yml000066400000000000000000000006351304235634100156070ustar00rootroot00000000000000language: ruby rvm: - 2.1 - 2.2 - 2.3 - 2.4.0-rc1 before_install: - gem install bundler - sudo apt-get -qq update - sudo apt-get install -y gnupg2 libgpgme11-dev libsqlite3-dev haveged before_script: - SCHLEUDER_ENV=test SCHLEUDER_CONFIG=spec/schleuder.yml bundle exec rake db:create db:schema:load script: - bundle exec rspec notifications: email: recipients: - schleuder@nadir.org schleuder-3.0.1/CHANGELOG.md000066400000000000000000000207451304235634100153130ustar00rootroot00000000000000Change Log ========== This project adheres to [Semantic Versioning](http://semver.org/). The format of this file is based on [Keep a Changelog](http://keepachangelog.com/). ## [3.0.1] / 2017-01-26 ### Fixed * Fixed setting admin- and delivery-flags on subscription. Requests from schleuder-cli were interpreted wrongly, which led to new lists having no admins. * A short description for the man-page of schleuder-api-daemon to satisfy the lintian. * Listing openssl as dependency in README. If the openssl header-files are not present when eventmachine compiles its native code, schleuder-api-daemon cannot use TLS. * Removed reference to Github from Code of Conduct. ## [3.0.0] / 2017-01-26 ### Changed * **API-keys always required!** From now on all requests to schleuder-api-daemon require API-keys, even via localhost. This helps protecting against rogue non-root-accounts or -scripts on the local machine. * **TLS always used!** schleuder-api-daemon now always uses TLS. * Switched project-site and git-repository to . * Set proper usage flags when creating a new OpenPGP-key: the primary key gets "SC", the subkey "E". (Thanks, dkg!) * Avoid possible future errors by ignoring every unknown output of gpg (like GnuPG's doc/DETAILS recommends). (Thanks, dkg!) * Friendlier error message if delivery to subscription fails. * Set list-email as primary address after adding UIDs. Previously it was a little random, for reasons only known to GnuPG. * Only use temporary files where neccessary, and with more secure paths. * Tighten requirements for valid email-addresses a little: The domain-part may now only contain alpha-numeric characters, plus these: `._-` * Required version of schleuder-cli: 0.0.2. ### Added * X-LISTNAME: A **new mandatory keyword** to accompany all keywords. From now on every message containing keywords must also include the listname-keyword like this: `X-LISTNAME: list@hostname` The other keywords will only be run if the given listname matches the email-address of the list that the message is sent to. This mitigates replay-attacks among different lists. * Also send helpful message if a subscription's key is present but unusable. * Provide simpler postfix integration, now using virtual_domains and an sql-script. (Thanks, dkg!) * Enable refreshing keys from keyservers: A script that is meant to be run regularly from cron. It refreshes each key of each list one by one from a configurable keyserver, and sends the result to the respective list-admins. * Import attached, ascii-armored keys from messages with `add-key`-keyword. (Thanks, Kéfir!) * Check possible key-material for expected format before importing it. (Thanks, Kéfir!) ### Fixed * Allow fingerprints to be prefixed with '0x' in `subscribe`-keyword. * Also delete directory of list-logfile on deletion if that resides outside of the list-dir. * Sign and possibly encrypt error notifications. * Fix setting admin- and delivery-flags while subscribing. * Fix subscribing from schleuder-cli. * Fix finding subscriptions from signatures made by a signing-capable sub-key. ## [3.0.0.beta17] / 2017-01-12 ### Changed * Stopped using SCHLEUDER_ROOT in specs. Those make life difficult for packaging for debian. * While running specs, ensure smtp-daemon.rb has been stopped before starting it anew. ### Added * A Code of Conduct. ## [3.0.0.beta16] / 2017-01-11 ### Fixed * Fix running `schleuder migrate...`. * Fix assigning list-attributes when migrating a list. ### Added * Import the secret key and clear its passphrase when migrating a list from v2. * More tests. ## [3.0.0.beta15] / 2017-01-10 ### Changed * Default `lists_dir` and `listlogs_dir` to `/var/lib/schleuder`. * Use '/usr/local/bin' as daemon PATH in schleuder-api-daemon sysvinit script. ### Fixed * Fix running for fresh lists if `lists_dir` is different from `listlogs_dir` (by creating logfile-basedir, closes Debian bug #850545). * Fix error-message from ListBuilder if given email is invalid. * Fix checking for sufficient gpg-version (previously '2.1' didn't suffice if '2.1.0' was required). ### Added * Cron job file to check keys. * Show when delivery is disabled for a subscription (in reply to 'list-subscriptions'-keyword). * Add timeout to default sqlite-config (avoids errors in the case that the DB-file is locked on first attempt). * Provide method to call gpg-executable. * Also add additional UIDs to generated PGP-keys when using gpg 2.0. * Specs for ListBuilder. ## [3.0.0.beta14] / 2016-12-29 ### Fixed * Fix key expiry check * Fix link to schleuder.nadir.org in List-Help header * Fix deleting listdir ### Added * Runner and integration tests * More fixtures ## [3.0.0.beta13] / 2016-12-22 ### Fixed * Fix creating new lists. ## [3.0.0.beta12] / 2016-12-22 ### Changed * Show file permission warning if cert is being generated as root. * Use hard-coded defaults as base to merge config-file over. ### Added * New keyword `x-resend-cc` to send a message to multiple recipients that should know of each another. The ciphertext will be encrypted only once to all recipients, too. * More specs. * Skript for schleuder-api-daemon under sysvinit. ### Fixed * Fix tests for non-default listlogs_dir. * Fix pseudo-header "Sig" for unknown keys. * Fix adding subject_prefix_in for unencrypted messages. * Fix checking permissions of listdir and list.log for newly created lists. * Fix occasionally empty 'date'-pseudo-header. ## [3.0.0.beta11] / 2016-12-07 ### Changed * Fixed recognition and validation of clearsigned-inline messages. * Fix log-file rotation (for list.log). * Show hint to set `use_tls: true` after generation of certificate. ### Added * During installation, show error message and exit if data of an installation of schleuder-2.x is found in the configured lists_dir. * More tests. ## [3.0.0.beta10] / 2016-12-05 ### Changed * Fixed tarball to contain correct version and state of changelog. ## [3.0.0.beta9] / 2016-12-02 ### Added * Include tarball into release. * Make basedir of list-logs configurable (`listlogs_dir`). No operational change with the default value. * Recognize "encapsulated" signatures (RFC 3156, 6.1). (These signatures might still be reported as invalid, that's a bug in mail-gpg which will probably be fixed in their next release.) * Make installed schleuder-files accessible for owner and group only. * Make list-logs accessible to owner and group only. ### Changed * Improved documentation. ### Fixed * Fix checking for empty messages for nested multiparts (e.g. Thunderbird with memoryhole-headers). * Fix `schleuder install` to respect config settings (e.g. `lists_dir`) ## [3.0.0.beta8] / 2016-11-27 ### Changed * Add network and local-filesystem as dependencies in systemd-unit-file. * Improved documentation. ### Fixed * Declare dependency on thin. ## [3.0.0.beta7] / 2016-11-23 ### Added * `man`-page for schleuder(8). * schleuder-api-daemon: optionally use TLS. * schleuder-api-daemon: authenticate client by API-key if TLS is used. ### Changed * Sign git-tags, gems, and tarballs as 0xB3D190D5235C74E1907EACFE898F2C91E2E6E1F3. * Rename schleuderd to schleuder-api-daemon. * schleuder-api-daemon: bind to `localhost` by default. * schleuder-api-daemon: changed name of `bind` config option to `host`. * schleuder-api-daemon: return 204 if not content is being sent along. * Refactor and improve model validations. ### Fixed * Fixed creating lists. * Fixed default config. * Log errors to syslog-logger in case of problems with list-dir. ## [3.0.0.beta6] / 2016-11-13 ### Added * Add `-v`, `--version` arguments to CLI. * New model validators. * Translations (de, en) and better wording for validation error messages. * Specs (test-cases) for the list model. * Use Travis to automate testing. * Test listname to be a valid email address before creating list. * A simple contribution guide. * Check that GnuPG >= 2.0 is being used. * Enable to specify path to gpg-executable in GPGBIN environment variable. * A simple schleuder-only MTA to help with development. ### Changed * schleuderd: use GET instead of OPTIONS to work around bug in ruby 2.1. * Allow "inline"-pgp for request-messages (mail-gpg 0.2.7 fixed their issue). ### Fixed * Fix testing nested messages for emptiness. * Fix bouncing a message if it was found to be empty. * Fix truncated 'adding UID failed' message (transported via HTTP-headers). ## ... --------- Template, please ignore: ## [x.x.x] / YYYY-MM-DD ### Added ### Changed ### Deprecated ### Removed ### Fixed ### Security schleuder-3.0.1/CODE_OF_CONDUCT.md000066400000000000000000000046171304235634100163010ustar00rootroot00000000000000# Schleuder's Code of Conduct The Schleuder project strongly values contributors from anywhere, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, physical appearance, body size, race, ethnicity, age, religion, or nationality. As a result, the Schleuder development team has agreed to and enforces this code of conduct in order to provide a harassment-free experience for everyone who participates in the development of Schleuder. ### Summary Harassment in code and discussion or violation of physical boundaries is completely unacceptable anywhere in the Schleuder project’s codebases, issue trackers, chat rooms, mailing lists, meetups, and any other events. Violators will be warned and then blocked or banned by the development team at or before the 3rd violation. ### In detail Harassment includes offensive verbal comments related to level of experience, gender, gender identity and expression, sexual orientation, disability, physical appearance, body size, race, ethnicity, age, religion, nationality, the use of sexualized language or imagery, deliberate intimidation, stalking, sustained disruption, and unwelcome sexual attention. Individuals asked to stop any harassing behavior are expected to comply immediately. Maintainers, including the development team, are also subject to the anti-harassment policy. If anyone engages in abusive, harassing, or otherwise unacceptable behavior, including maintainers, we may take appropriate action, up to and including warning the offender, deletion of comments, removal from the project’s codebase and communication systems. If you are being harassed, notice that someone else is being harassed, or have any other concerns, please [contact the development team](mailto:schleuder@nadir.org) immediately. We expect everyone to follow these rules anywhere in the Schleuder project’s codebases, issue trackers, IRC channel, group chat, and mailing lists. This code of conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Finally, don't forget that it is human to make mistakes! We all do. Let’s work together to help each other, resolve issues, and learn from the mistakes that we will all inevitably make from time to time. ### Thanks Thanks to the [Bundler Code of Conduct](https://bundler.io/conduct.html), which we adopted for ourselves. schleuder-3.0.1/CONTRIBUTING.md000066400000000000000000000010001304235634100157120ustar00rootroot00000000000000Contributing ============ To contribute please follow this workflow: 1. Talk to us! E.g. create an issue about your idea or problem. 2. Fork the repository and work in a meaningful named branch that is based off of our "master". 3. Commit in rather small chunks but don't split depending code across commits. Please write sensible commit messages. 4. Please add tests for your feature or bugfix. 5. If in doubt request feedback from us! 6. When finished create a merge request. Thank you for your interest! schleuder-3.0.1/Gemfile000066400000000000000000000001371304235634100147660ustar00rootroot00000000000000source 'https://rubygems.org' # Specify your gem's dependencies in schleuder.gemspec gemspec schleuder-3.0.1/Gemfile.lock000066400000000000000000000044421304235634100157200ustar00rootroot00000000000000PATH remote: . specs: schleuder (3.0.1) activerecord (~> 4.1) mail-gpg (~> 0.3.0) rake (~> 10) sinatra (~> 1) sinatra-contrib (~> 1) sqlite3 (~> 1) thin (~> 1) thor (~> 0) GEM remote: https://rubygems.org/ specs: activemodel (4.2.7.1) activesupport (= 4.2.7.1) builder (~> 3.1) activerecord (4.2.7.1) activemodel (= 4.2.7.1) activesupport (= 4.2.7.1) arel (~> 6.0) activesupport (4.2.7.1) i18n (~> 0.7) json (~> 1.7, >= 1.7.7) minitest (~> 5.1) thread_safe (~> 0.3, >= 0.3.4) tzinfo (~> 1.1) arel (6.0.4) backports (3.6.8) builder (3.2.2) daemons (1.2.4) database_cleaner (1.5.3) diff-lcs (1.2.5) eventmachine (1.2.1) factory_girl (4.8.0) activesupport (>= 3.0.0) gpgme (2.0.12) mini_portile2 (~> 2.1.0) hirb (0.7.3) i18n (0.7.0) json (1.8.5) mail (2.6.4) mime-types (>= 1.16, < 4) mail-gpg (0.3.0) gpgme (~> 2.0, >= 2.0.2) mail (~> 2.5, >= 2.5.3) mime-types (3.1) mime-types-data (~> 3.2015) mime-types-data (3.2016.0521) mini_portile2 (2.1.0) minitest (5.10.1) multi_json (1.12.1) rack (1.6.5) rack-protection (1.5.3) rack rack-test (0.6.3) rack (>= 1.0) rake (10.5.0) rspec (3.5.0) rspec-core (~> 3.5.0) rspec-expectations (~> 3.5.0) rspec-mocks (~> 3.5.0) rspec-core (3.5.4) rspec-support (~> 3.5.0) rspec-expectations (3.5.0) diff-lcs (>= 1.2.0, < 2.0) rspec-support (~> 3.5.0) rspec-mocks (3.5.0) diff-lcs (>= 1.2.0, < 2.0) rspec-support (~> 3.5.0) rspec-support (3.5.0) sinatra (1.4.7) rack (~> 1.5) rack-protection (~> 1.4) tilt (>= 1.3, < 3) sinatra-contrib (1.4.7) backports (>= 2.0) multi_json rack-protection rack-test sinatra (~> 1.4.0) tilt (>= 1.3, < 3) sqlite3 (1.3.13) thin (1.7.0) daemons (~> 1.0, >= 1.0.9) eventmachine (~> 1.0, >= 1.0.4) rack (>= 1, < 3) thor (0.19.4) thread_safe (0.3.5) tilt (2.0.5) tzinfo (1.2.2) thread_safe (~> 0.1) PLATFORMS ruby DEPENDENCIES database_cleaner factory_girl hirb rspec (~> 3.5.0) schleuder! BUNDLED WITH 1.13.7 schleuder-3.0.1/LICENSE.txt000066400000000000000000001045131304235634100153210ustar00rootroot00000000000000 GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The GNU General Public License is a free, copyleft license for software and other kinds of works. The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things. To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others. For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it. For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software. For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions. Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users. Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free. The precise terms and conditions for copying, distribution and modification follow. TERMS AND CONDITIONS 0. Definitions. "This License" refers to version 3 of the GNU General Public License. "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks. "The Program" refers to any copyrightable work licensed under this License. Each licensee is addressed as "you". "Licensees" and "recipients" may be individuals or organizations. To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work. A "covered work" means either the unmodified Program or a work based on the Program. To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well. To "convey" a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying. An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion. 1. Source Code. The "source code" for a work means the preferred form of the work for making modifications to it. "Object code" means any non-source form of a work. A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language. The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it. The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work. The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source. The Corresponding Source for a work in source code form is that same work. 2. Basic Permissions. All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law. You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you. Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary. 3. Protecting Users' Legal Rights From Anti-Circumvention Law. No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures. When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures. 4. Conveying Verbatim Copies. You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program. You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee. 5. Conveying Modified Source Versions. You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions: a) The work must carry prominent notices stating that you modified it, and giving a relevant date. b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to "keep intact all notices". c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it. d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so. A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate. 6. Conveying Non-Source Forms. You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways: a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange. b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge. c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b. d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements. e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d. A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work. A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product. "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made. If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM). The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network. Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying. 7. Additional Terms. "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions. When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission. Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms: a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or d) Limiting the use for publicity purposes of names of licensors or authors of the material; or e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors. All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying. If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms. Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way. 8. Termination. You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11). However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation. Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice. Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10. 9. Acceptance Not Required for Having Copies. You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so. 10. Automatic Licensing of Downstream Recipients. Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License. An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts. You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it. 11. Patents. A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's "contributor version". A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License. Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version. In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party. If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid. If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it. A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007. Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law. 12. No Surrender of Others' Freedom. If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program. 13. Use with the GNU Affero General Public License. Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such. 14. Revised Versions of this License. The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation. If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program. Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version. 15. Disclaimer of Warranty. THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. Limitation of Liability. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 17. Interpretation of Sections 15 and 16. If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . Also add information on how to contact you by electronic and paper mail. If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode: Copyright (C) This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, your program's commands might be different; for a GUI interface, you would use an "about box". You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see . The GNU General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read . schleuder-3.0.1/README.md000066400000000000000000000077661304235634100147710ustar00rootroot00000000000000Schleuder, version 3 ====================================== Schleuder is a gpg-enabled mailing list manager with resending-capabilities. Subscribers can communicate encrypted (and pseudonymously) among themselves, receive emails from non-subscribers and send emails to non-subscribers via the list. Version 3 of schleuder is a complete rewrite, which aims to be more robust, flexible, and internationalized. It also provides an API for the optional web interface called [schleuder-web](https://0xacab.org/schleuder/schleuder-web). For more details see . Requirements ------------ * ruby >=2.1 * gnupg >=2.0 * gpgme * sqlite3 * openssl On systems that base on Debian 8 ("Jessie"), install these via apt-get install ruby2.1-dev gnupg2 libgpgme11-dev libsqlite3-dev libssl-dev We **recommend** to also run a random number generator like [haveged](http://www.issihosts.com/haveged/). This ensures Schleuder won't be blocked by lacking entropy, which otherwise might happen especially during key generation. On Debian based systems, install it via apt-get install haveged Additionally these **rubygems** are required (will be installed automatically unless present): * rake * active_record * sqlite3 * thor * thin * mail-gpg * sinatra * sinatra-contrib Installing Schleuder ------------ 1. Download [the gem](https://0xacab.org/schleuder/schleuder/raw/master/gems/schleuder-3.0.1.gem) and [the OpenPGP-signature](https://0xacab.org/schleuder/schleuder/raw/master/gems/schleuder-3.0.1.gem.sig) and verify: ``` gpg --recv-key 0xB3D190D5235C74E1907EACFE898F2C91E2E6E1F3 gpg --verify schleuder-3.0.1.gem.sig ``` 2. If all went well install the gem: ``` gem install schleuder-3.0.1.gem ``` 3. Set up schleuder: ``` schleuder install ``` This creates neccessary directories, copies example configs, etc. If you see errors about missing write permissions please follow the advice given. For further information on setup and configuration please read . Command line usage ----------------- See `schleuder help`. E.g.: Commands: schleuder check_keys # Check all lists for unusable or expiring keys and send the results to the list-admins. (This is supposed... schleuder help [COMMAND] # Describe available commands or one specific command schleuder install # Set up Schleuder initially. Create folders, copy files, fill the database, etc. schleuder version # Show version of schleuder schleuder work list@hostname < message # Run a message through a list. List administration ------------------- Please use [schleuder-cli](https://0xacab.org/schleuder/schleuder-cli) to create and manage lists from the command line. Optionally consider installing [schleuder-web](https://0xacab.org/schleuder/schleuder-web), the web interface for schleuder. It enables list-admins to manage their lists through the web instead of using [request-keywords](https://schleuder.nadir.org/docs/#subscription-and-key-management). Todo ---- See . Testing ------- We use rspec to test our code. To setup the test environment run: SCHLEUDER_ENV=test SCHLEUDER_CONFIG=spec/schleuder.yml bundle exec rake db:create db:schema:load To execute the test suite run: bundle exec rspec We are working on extendig the test coverage. Contributing ------------ Please see [CONTRIBUTING.md](CONTRIBUTING.md). Code of Conduct --------------- We adopted a code of conduct. Please read [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md). License ------- GNU GPL 3.0. Please see [LICENSE.txt](LICENSE.txt). Alternative Download -------------------- Alternatively to the gem-files you can download the latest release as [a tarball](https://0xacab.org/schleuder/schleuder/raw/master/gems/schleuder-3.0.1.tar.gz) and [its OpenPGP-signature](https://0xacab.org/schleuder/schleuder/raw/master/gems/schleuder-3.0.1.tar.gz.sig). schleuder-3.0.1/Rakefile000066400000000000000000000063011304235634100151370ustar00rootroot00000000000000project = 'schleuder' require_relative "lib/#{project}.rb" @version = Schleuder::VERSION @tagname = "#{project}-#{@version}" @gpguid = 'schleuder@nadir.org' load "active_record/railties/databases.rake" # Configure ActiveRecord ActiveRecord::Tasks::DatabaseTasks.tap do |config| config.root = File.dirname(__FILE__) config.db_dir = 'db' config.migrations_paths = ['db/migrate'] config.env = ENV['SCHLEUDER_ENV'] config.database_configuration = Schleuder::Conf.databases end # ActiveRecord requires this task to be present Rake::Task.define_task("db:environment") def edit_and_add_file(filename) puts "Please edit #{filename} to refer to version #{@version}" if system("gvim -f #{filename}.md") `git add #{filename}.md` else exit 1 end end def move_sign_and_add(file) `mv -iv #{file} gems/` `cd gems && gpg -u #{@gpguid} -b #{file}` `git add gems/#{file}*` end task :console do exec "irb -r #{File.dirname(__FILE__)}/lib/schleuder.rb" end task :publish_gem => :website task :git_tag => :check_version desc "Build new version: git-tag and gem-file" task :new_version => [ :check_version, :edit_readme, :edit_changelog, :git_add_version, :update_gemfile_lock, :git_commit, :gem, :tarball, :git_amend_gems, :git_tag ] do end desc "Edit CHANGELOG.md" task :edit_changelog do edit_and_add_file('CHANGELOG') end desc "Edit README" task :edit_readme do edit_and_add_file('README') end desc "Make sure the Gemfile.lock is up to date and added to the index" task :update_gemfile_lock do `bundle install` `git add Gemfile.lock` end desc 'git-tag HEAD as new version' task :git_tag do `git tag -u #{@gpguid} -s -m "Version #{@version}" #{@tagname}` end desc "Add changed version to git-index" task :git_add_version do `git add lib/#{project}/version.rb` end desc "Commit changes as new version" task :git_commit do `git commit -m "Version #{@version} (README, gems, ...)"` end desc "git-amend gem, tarball and signatures to previous commit" task :git_amend_gems do `git add gems && git commit --amend -C HEAD` end desc 'Build, sign and commit a gem-file.' task :gem do gemfile = "#{@tagname}.gem" `gem build #{project}.gemspec` move_sign_and_add(gemfile) end desc 'Publish gem-file to rubygems.org' task :publish_gem do puts "Really push #{@tagname}.gem to rubygems.org? [yN]" if gets.match(/^y/i) puts "Pushing..." `gem push #{@tagname}.gem` else puts "Not pushed." end end desc 'Build and sign a tarball' task :tarball do tarball = "#{@tagname}.tar.gz" `git archive --format tar.gz --prefix "#{@tagname}/" -o #{tarball} master` move_sign_and_add(tarball) end desc 'Describe manual release-tasks' task :website do puts "Please update the website: * Update changelog. * Publish release-announcement. " end desc 'Check if version-tag already exists' task :check_version do # Check if Schleuder::VERSION has been updated since last release if `git tag`.match?(/^#{@tagname}$/) $stderr.puts "Warning: Tag '#{@tagname}' already exists. Did you forget to update #{project}/version.rb?" $stderr.print "Delete tag to continue? [yN] " if $stdin.gets.match(/^y/i) `git tag -d #{@tagname}` else exit 1 end end end schleuder-3.0.1/bin/000077500000000000000000000000001304235634100142425ustar00rootroot00000000000000schleuder-3.0.1/bin/pinentry-clearpassphrase000077500000000000000000000025201304235634100212150ustar00rootroot00000000000000#!/usr/bin/env ruby # This file can be deleted once we cease to support gnupg 2.0. require 'fileutils' require 'cgi' require 'openssl' def respond(msg, flush=true) $stdout.puts msg if flush $stdout.flush end end def send_ok(flush=true) respond 'OK', flush end def send_password if File.exist?(OLDPWDSENTFILE) pwd = '' if File.exist?(EMPTYPWDSENTFILE1) FileUtils.touch(EMPTYPWDSENTFILE2) else FileUtils.touch(EMPTYPWDSENTFILE1) end else pwd = OLDPASSWD FileUtils.touch(OLDPWDSENTFILE) end respond "D #{pwd}" end def do_exit if File.exist?(EMPTYPWDSENTFILE2) FileUtils.rm_rf(TMPDIR) end exit 0 end OLDPASSWD = CGI.escape(ENV['PINENTRY_USER_DATA'].to_s) if OLDPASSWD.empty? respond "Fatal error: passed PINENTRY_USER_DATA was empty, cannot continue" exit 1 end # We need a static directory name to maintain the state across invocations of # this file. TMPDIR = File.join(ENV['GNUPGHOME'], '.tmp-pinentry-clearpassphrase') OLDPWDSENTFILE = File.join(TMPDIR, '1') EMPTYPWDSENTFILE1 = File.join(TMPDIR, '2') EMPTYPWDSENTFILE2 = File.join(TMPDIR, '3') if ! Dir.exist?(TMPDIR) Dir.mkdir(TMPDIR) end respond "OK - what's up?" while line = $stdin.gets do case line when /^GETPIN/ send_password send_ok when /^BYE/ send_ok false do_exit else send_ok end end schleuder-3.0.1/bin/schleuder000077500000000000000000000004751304235634100161540ustar00rootroot00000000000000#!/usr/bin/env ruby # Don't emit any warnings, they would be sent back to the email-sender as an # error-message. $VERBOSE=nil trap("INT") { exit 1 } begin require_relative '../lib/schleuder/cli' Schleuder::Cli.start rescue => exc $stderr.puts "Technical Error: #{exc}\n#{exc.backtrace.first}" exit 1 end schleuder-3.0.1/bin/schleuder-api-daemon000077500000000000000000000203201304235634100201530ustar00rootroot00000000000000#!/usr/bin/env ruby # Make sinatra use production as default-environment ENV['RACK_ENV'] ||= 'production' require 'sinatra/base' require 'sinatra/json' require 'sinatra/namespace' require 'thin' require_relative '../lib/schleuder.rb' %w[tls_cert_file tls_key_file].each do |config_key| path = Conf.api[config_key] if ! File.readable?(path) $stderr.puts "Error: '#{path}' is not a readable file (from #{config_key} in config)." exit 1 end end class SchleuderApiDaemon < Sinatra::Base register Sinatra::Namespace use Rack::Auth::Basic, "Schleuder API Daemon" do |username, key| username == 'schleuder' && Conf.api_valid_api_keys.include?(key) end configure do set :server, :thin set :port, Schleuder::Conf.api['port'] || 4443 set :bind, Schleuder::Conf.api['host'] || 'localhost' if settings.development? set :logging, Logger::DEBUG else set :logging, Logger::WARN end end before do cast_param_values end after do # Return connection to pool after each request. ActiveRecord::Base.connection.close end error do exc = env['sinatra.error'] logger.error "Error: #{env['sinatra.error'].message}" case exc when Errno::EACCES server_error(exc.message) else client_error(exc.to_s) end end error 404 do 'Not found' end get '/status.json' do json status: :ok end get '/version.json' do json version: Schleuder::VERSION end helpers do def list(id_or_email=nil) if id_or_email.blank? if params[:list_id].present? id_or_email = params[:list_id] else client_error "Parameter list_id is required" end end if id_or_email.to_i == 0 # list_id is actually an email address list = List.where(email: id_or_email).first else list = List.where(id: id_or_email).first end list || halt(404) end def subscription(id_or_email) if id_or_email.to_i == 0 # Email if params[:list_id].blank? client_error "Parameter list_id is required when using email as identifier for subscriptions." else sub = list.subscriptions.where(email: id_or_email).first end else sub = Subscription.where(id: id_or_email.to_i).first end sub || halt(404) end def requested_list_id # ActiveResource doesn't want to use query-params with create(), so here # list_id might be included in the request-body. params['list_id'] || parsed_body['list_id'] || client_error('Need list_id') end def parsed_body @parsed_body ||= begin b = JSON.parse(request.body.read) logger.debug "parsed body: #{b.inspect}" b end end def server_error(msg) logger.warn msg halt(500, json(error: msg)) end # TODO: unify error messages. This method currently sends an old error format. See . def client_error(obj_or_msg, http_code=400) text = case obj_or_msg when String, Symbol obj_or_msg.to_s when ActiveRecord::Base obj_or_msg.errors.full_messages else obj_or_msg end logger.error "Sending error to client: #{text.inspect}" halt(http_code, json(errors: text)) end # poor persons type casting def cast_param_values params.each do |key, value| params[key] = case value when 'true' then true when 'false' then false when '0' then 0 when value.to_i > 0 then value.to_i else value end end end def key_to_json(key) { fingerprint: key.fingerprint, email: key.email, ascii: key.armored, expiry: key.expires, trust_issues: key.usability_issue } end end namespace '/lists' do get '.json' do json List.all, include: :subscriptions end post '.json' do listname = parsed_body['email'] fingerprint = parsed_body['fingerprint'] adminaddress = parsed_body['adminaddress'] adminkey = parsed_body['adminkey'] list, messages = ListBuilder.new({email: listname, fingerprint: fingerprint}, adminaddress, adminkey).run if list.nil? client_error(messages, 422) elsif ! list.valid? client_error(list, 422) else if messages.present? headers 'X-Messages' => messages.join(' // ').gsub(/\n/, ' // ') end body json(list) end end get '/configurable_attributes.json' do json(List.configurable_attributes) + "\n" end get '/new.json' do json List.new end get '/:id.json' do |id| json list(id) end put '/:id.json' do |id| list = list(id) if list.update(parsed_body) 204 else client_error(list) end end patch '/:id.json' do |id| list = list(id) if list.update(parsed_body) 204 else client_error(list) end end delete '/:id.json' do |id| list = list(id) if list.destroy 200 else client_error(list) end end end namespace '/subscriptions' do get '.json' do filterkeys = Subscription.configurable_attributes + [:list_id, :email] filter = params.select do |param| filterkeys.include?(param.to_sym) end logger.debug "Subscription filter: #{filter.inspect}" if filter['list_id'] && filter['list_id'].to_i == 0 # Value is an email-address if list = List.where(email: filter['list_id']).first filter['list_id'] = list.id else status 404 return json(errors: 'No such list') end end json Subscription.where(filter) end post '.json' do begin list = list(requested_list_id) sub = list.subscribe( parsed_body['email'], parsed_body['fingerprint'], parsed_body['admin'], parsed_body['delivery_enabled'] ) logger.debug "subcription: #{sub.inspect}" if sub.valid? logger.debug "Subscribed: #{sub.inspect}" redirect to("/subscriptions/#{sub.id}.json"), 201 else client_error(sub, 422) end rescue ActiveRecord::RecordNotUnique logger.error "Already subscribed" status 422 json errors: {email: ['is already subscribed']} end end get '/configurable_attributes.json' do json(Subscription.configurable_attributes) + "\n" end get '/new.json' do json Subscription.new end get '/:id.json' do |id| json subscription(id) end put '/:id.json' do |id| sub = subscription(id) if sub.update(parsed_body) 200 else client_error(sub, 422) end end patch '/:id.json' do |id| sub = subscription(id) if sub.update(parsed_body) 200 else client_error(sub) end end delete '/:id.json' do |id| if sub = subscription(id).destroy 200 else client_error(sub) end end end namespace '/keys' do get '.json' do keys = list.keys.sort_by(&:email).map do |key| key_to_json(key) end json keys end post '.json' do input = parsed_body['keymaterial'] if ! input.match('BEGIN PGP') input = Base64.decode64(input) end json list(requested_list_id).import_key(input) end get '/:fingerprint.json' do |fingerprint| if key = list.key(fingerprint) json key_to_json(key) else 404 end end delete '/:fingerprint.json' do |fingerprint| if list.delete_key(fingerprint) 200 else 404 end end get '/check_keys.json' do json result: list.check_keys end end def self.run! super do |server| server.ssl = true server.ssl_options = { :cert_chain_file => Conf.api['tls_cert_file'], :private_key_file => Conf.api['tls_key_file'] } end end # Run this class as application run! end schleuder-3.0.1/bin/schleuder-bundler000077500000000000000000000003631304235634100176010ustar00rootroot00000000000000#!/bin/bash -l export HOME=/home/$(id -nu) # Little helper script to call schleuder through bundler. Useful e.g. for # hooking up development code into postfix. bindir="$(realpath $(dirname $0))" cd $bindir/.. bundle exec ./bin/schleuder $@ schleuder-3.0.1/bin/schleuder-smtpd.rb000077500000000000000000000032761304235634100177050ustar00rootroot00000000000000#!/usr/bin/env ruby # # This script is a very simple SMTP-daemon, that delivers every incoming email # to a given schleuder-list. It's meant to help developing without a real, # local MTA. require 'socket' require 'open3' trap ("INT") { exit 0 } def usage puts "Usage: #{File.basename(__FILE__)} [-p portnum]" exit 1 end # get args case ARGV.first when '-h', '--help', 'help' usage when '-p' port = ARGV[1].to_i if port == 0 usage end end port ||= 25 schleuderbin = File.join(File.dirname(__FILE__), 'schleuder') begin # run the server server = TCPServer.new("127.0.0.1", port) # receive input while (connection = server.accept) input = '' recipient = '' connection.puts "220 localhost SMTP" begin while line = connection.gets line.chomp! case line[0..3].downcase when 'ehlo', 'helo' connection.puts "250 localhost" when 'mail', 'rset' connection.puts "250 ok" when 'rcpt' recipient = line.split(':').last.gsub(/[<>\s]*/, '') connection.puts "250 ok" when 'data' connection.puts "354 go ahead" when 'quit' connection.puts "221 localhost" when '.' puts "New message to #{recipient}" err, status = Open3.capture2e("#{schleuderbin} work #{recipient}", {stdin_data: input}) if status.exitstatus > 0 puts "Error from schleuder: #{err}." connection.puts "550 #{err}" else connection.puts "250 ok" end else input << line + "\n" end end rescue IOError end connection.close end rescue => exc $stderr.puts exc exit 1 end schleuder-3.0.1/db/000077500000000000000000000000001304235634100140575ustar00rootroot00000000000000schleuder-3.0.1/db/migrate/000077500000000000000000000000001304235634100155075ustar00rootroot00000000000000schleuder-3.0.1/db/migrate/20140501103532_create_lists.rb000066400000000000000000000027541304235634100221570ustar00rootroot00000000000000class CreateLists < ActiveRecord::Migration def change create_table :lists do |t| t.timestamps t.string :email t.string :fingerprint t.string :gpg_passphrase t.string :log_level, default: 'warn' t.string :default_mime, default: 'mime' t.string :subject_prefix, default: '' t.string :subject_prefix_in, default: '' t.string :subject_prefix_out, default: '' t.string :openpgp_header_preference, default: 'signencrypt' t.text :public_footer, default: '' t.text :headers_to_meta, default: '["from","to","date",":cc"]' t.text :bounces_drop_on_headers, default: '{"x-spam-flag":"yes"}' t.text :keywords_admin_only, default: '["unsubscribe", "unsubscribe", "delete-key"]' t.text :keywords_admin_notify, default: '["add-key"]' t.boolean :send_encrypted_only, default: false t.boolean :receive_encrypted_only, default: false t.boolean :receive_signed_only, default: false t.boolean :receive_authenticated_only, default: false t.boolean :receive_from_subscribed_emailaddresses_only, default: false t.boolean :receive_admin_only, default: false t.boolean :keep_msgid, default: true t.boolean :bounces_drop_all, default: false t.boolean :bounces_notify_admins, default: true t.boolean :include_list_headers, default: true t.boolean :include_openpgp_header, default: true t.integer :max_message_size_kb, default: 10240 end end end schleuder-3.0.1/db/migrate/20140501112859_create_subscriptions.rb000066400000000000000000000006331304235634100237360ustar00rootroot00000000000000class CreateSubscriptions < ActiveRecord::Migration def change create_table :subscriptions do |t| t.integer :list_id t.string :email t.string :fingerprint t.boolean :admin, default: false t.boolean :delivery_disabled, default: false t.timestamps end add_index :subscriptions, :list_id add_index :subscriptions, [:email, :list_id], unique: true end end schleuder-3.0.1/db/migrate/201508092100_add_language_to_lists.rb000066400000000000000000000002031304235634100236350ustar00rootroot00000000000000class AddLanguageToLists < ActiveRecord::Migration def change add_column :lists, :language, :string, default: 'en' end end schleuder-3.0.1/db/migrate/20150812165700_change_keywords_admin_only_defaults.rb000066400000000000000000000004741304235634100267620ustar00rootroot00000000000000class ChangeKeywordsAdminOnlyDefaults < ActiveRecord::Migration def up change_column_default :lists, :keywords_admin_only, "[\"subscribe\", \"unsubscribe\", \"delete-key\"]" end def down change_column_default :lists, :keywords_admin_only, "[\"unsubscribe\", \"unsubscribe\", \"delete-key\"]" end end schleuder-3.0.1/db/migrate/20150813235800_add_forward_all_incoming_to_admins.rb000066400000000000000000000002461304235634100265270ustar00rootroot00000000000000class AddForwardAllIncomingToAdmins < ActiveRecord::Migration def change add_column :lists, :forward_all_incoming_to_admins, :boolean, default: false end end schleuder-3.0.1/db/migrate/201508141727_change_send_encrypted_only_default.rb000066400000000000000000000003361304235634100264230ustar00rootroot00000000000000class ChangeSendEncryptedOnlyDefault < ActiveRecord::Migration def up change_column_default :lists, :send_encrypted_only, true end def down change_column_default :lists, :send_encrypted_only, false end end schleuder-3.0.1/db/migrate/201508222143_add_logfiles_to_keep_to_lists.rb000066400000000000000000000002171304235634100253730ustar00rootroot00000000000000class AddLogfilesToKeepToLists < ActiveRecord::Migration def change add_column :lists, :logfiles_to_keep, :integer, default: 2 end end 201508261723_rename_delivery_disabled_to_delivery_enabled_and_change_default.rb000066400000000000000000000006241304235634100341760ustar00rootroot00000000000000schleuder-3.0.1/db/migrateclass RenameDeliveryDisabledToDeliveryEnabledAndChangeDefault < ActiveRecord::Migration def up rename_column :subscriptions, :delivery_disabled, :delivery_enabled change_column_default :subscriptions, :delivery_enabled, true end def down rename_column :subscriptions, :delivery_enabled, :delivery_disabled change_column_default :subscriptions, :delivery_disabled, false end end schleuder-3.0.1/db/migrate/201508261815_strip_gpg_passphrase.rb000066400000000000000000000002621304235634100235710ustar00rootroot00000000000000class StripGpgPassphrase < ActiveRecord::Migration def up remove_column :lists, :gpg_passphrase end def down add_column :lists, :gpg_passphrase, :string end end schleuder-3.0.1/db/migrate/201508261827_remove_default_mime.rb000066400000000000000000000002761304235634100233620ustar00rootroot00000000000000class RemoveDefaultMime < ActiveRecord::Migration def up remove_column :lists, :default_mime end def down add_column :lists, :default_mime, :string, default: 'mime' end end schleuder-3.0.1/db/migrate/20160501172700_fix_headers_to_meta_defaults.rb000066400000000000000000000002611304235634100253520ustar00rootroot00000000000000class FixHeadersToMetaDefaults < ActiveRecord::Migration def up change_column_default :lists, :headers_to_meta, '["from", "to", "date", "cc"]' end def down end end schleuder-3.0.1/db/schema.rb000066400000000000000000000075361304235634100156570ustar00rootroot00000000000000# encoding: UTF-8 # This file is auto-generated from the current state of the database. Instead # of editing this file, please use the migrations feature of Active Record to # incrementally modify your database, and then regenerate this schema definition. # # Note that this schema.rb definition is the authoritative source for your # database schema. If you need to create the application database on another # system, you should be using db:schema:load, not running all the migrations # from scratch. The latter is a flawed and unsustainable approach (the more migrations # you'll amass, the slower it'll run and the greater likelihood for issues). # # It's strongly recommended that you check this file into your version control system. ActiveRecord::Schema.define(version: 20160501172700) do create_table "lists", force: :cascade do |t| t.datetime "created_at" t.datetime "updated_at" t.string "email", limit: 255 t.string "fingerprint", limit: 255 t.string "log_level", limit: 255, default: "warn" t.string "subject_prefix", limit: 255, default: "" t.string "subject_prefix_in", limit: 255, default: "" t.string "subject_prefix_out", limit: 255, default: "" t.string "openpgp_header_preference", limit: 255, default: "signencrypt" t.text "public_footer", default: "" t.text "headers_to_meta", default: "[\"from\", \"to\", \"date\", \"cc\"]" t.text "bounces_drop_on_headers", default: "{\"x-spam-flag\":\"yes\"}" t.text "keywords_admin_only", default: "[\"subscribe\", \"unsubscribe\", \"delete-key\"]" t.text "keywords_admin_notify", default: "[\"add-key\"]" t.boolean "send_encrypted_only", default: true t.boolean "receive_encrypted_only", default: false t.boolean "receive_signed_only", default: false t.boolean "receive_authenticated_only", default: false t.boolean "receive_from_subscribed_emailaddresses_only", default: false t.boolean "receive_admin_only", default: false t.boolean "keep_msgid", default: true t.boolean "bounces_drop_all", default: false t.boolean "bounces_notify_admins", default: true t.boolean "include_list_headers", default: true t.boolean "include_openpgp_header", default: true t.integer "max_message_size_kb", default: 10240 t.string "language", limit: 255, default: "en" t.boolean "forward_all_incoming_to_admins", default: false t.integer "logfiles_to_keep", default: 2 end create_table "subscriptions", force: :cascade do |t| t.integer "list_id" t.string "email", limit: 255 t.string "fingerprint", limit: 255 t.boolean "admin", default: false t.boolean "delivery_enabled", default: true t.datetime "created_at" t.datetime "updated_at" end add_index "subscriptions", ["email", "list_id"], name: "index_subscriptions_on_email_and_list_id", unique: true add_index "subscriptions", ["list_id"], name: "index_subscriptions_on_list_id" end schleuder-3.0.1/etc/000077500000000000000000000000001304235634100142455ustar00rootroot00000000000000schleuder-3.0.1/etc/init.d/000077500000000000000000000000001304235634100154325ustar00rootroot00000000000000schleuder-3.0.1/etc/init.d/schleuder-api-daemon000077500000000000000000000032031304235634100213440ustar00rootroot00000000000000#!/bin/sh ### BEGIN INIT INFO # Provides: schleuder-api-daemon # Required-Start: $local_fs $network $syslog # Required-Stop: $local_fs $network $syslog # Default-Start: 2 3 4 5 # Default-Stop: 0 1 6 # Short-Description: Schleuder API daemon # Description: Schleuder API daemon — provides access for schleuder-cli and schleuder-web ### END INIT INFO PATH=/sbin:/usr/sbin:/bin:/usr/bin . /lib/init/vars.sh . /lib/lsb/init-functions NAME=schleuder-api-daemon DAEMON=/usr/local/bin/schleuder-api-daemon PIDFILE=/var/run/$NAME.pid USER=schleuder GROUP=schleuder test -x $DAEMON || exit 5 start() { if [ -f /var/run/$NAME.pid ]; then log_failure_msg "$NAME is running already, please stop it first" exit 1 fi if ! id $USER >/dev/null 2>&1; then log_failure_msg "User \"$USER\" does not exist" exit 1 fi if ! getent group $GROUP >/dev/null 2>&1; then log_failure_msg "Group \"$GROUP\" does not exist" exit 1 fi log_daemon_msg "Starting $NAME" "$DAEMON" start-stop-daemon --chuid "$USER":"$GROUP" --pidfile $PIDFILE --make-pidfile --background --exec $DAEMON --start log_end_msg $? } stop() { if ! [ -f /var/run/$NAME.pid ]; then log_failure_msg "$NAME isn't running currently, nothing to do" exit 1 fi log_daemon_msg "Stopping $NAME" "$DAEMON" start-stop-daemon --oknodo --pidfile $PIDFILE --stop --retry 10 log_end_msg $? rm $PIDFILE } restart() { stop start } case "$1" in start) start ;; stop) stop ;; restart) restart ;; *) log_success_msg "Usage: $0 {start|stop|restart}" exit 1 esac schleuder-3.0.1/etc/list-defaults.yml000066400000000000000000000076751304235634100175670ustar00rootroot00000000000000# Setting default values for newly generated lists. Once a list is created it # is not affected by these settings but has its own set of options in the # database. # # The configuration format is yaml (http://www.yaml.org). # # Options are listed with the behaviour encoded in the database schema. # Only send out enrypted emails? send_encrypted_only: true # Allow only encrypted emails? If true, any other email will be bounced. receive_encrypted_only: false # Allow only emails that are validly signed? If true, any other email will be # bounced. receive_signed_only: false # Allow only emails that are validly signed by a subscriber's key? If true, # any other email will be bounced. receive_authenticated_only: false # Allow only emails being sent from subscribed addresses? If true, any other # email will be bounced. # NOTE: This is a very weak restriction mechanism on which you should not rely, # as sending addresses can easily be faked! We recommend you to rather # rely on the `receive_authenticated_only` option. Setting the # `receive_authenticated_only` option to true, will authenticated senders # based on the signature on the mail, which is the strongest # authentication mechanism you can get. # This option could be useful, if you would like to have a closed # mailinglist, but could not yet get all subscribers to properly use GPG. receive_from_subscribed_emailaddresses_only: false # Allow only emails that are validly signed by a list-admin's key. # This is useful for newsletters, announce or notification lists receive_admin_only: false # Which headers to include from the original mail. headers_to_meta: - from - to - cc - date # Preserve the Message-IDs (In-Reply-To, References) from the incoming email. # This setting can lead to information leakage, as replies are connectable # and a thread of (encrypted) messages can be built by an eavesdropper. keep_msgid: true # Which keywords ("email-commands") should be restricted to list-admins? keywords_admin_only: - subscribe - unsubscribe - delete-key # For which keywords should the list-admins receive a notice whenever it # triggers a command. keywords_admin_notify: - add-key # Public footer to append each email that is sent to non-subscribed addresses. public_footer: # Prefix to be inserted into the subject of every email that is validly signed # by a subscribed address. subject_prefix: # Prefix to be inserted into the subject of every email that is *not* validly # signed by a subscribed address. subject_prefix_in: # Prefix to be inserted into the subject of every email that has been # resent to a non-subscribed address. subject_prefix_out: # Drop any bounces (incoming emails not passing the receive_*_only-rules)? bounces_drop_all: false # Drop bounces if they match one of these headers. Must be a hash, keys # and values are case insensitive. bounces_drop_on_headers: x-spam-flag: yes # Send a notice to the list-admins whenever an email is bounced or dropped? bounces_notify_admins: true # Include RFC-compliant List-* Headers into emails? include_list_headers: true # Include OpenPGP-Header into emails? include_openpgp_header: true # Prefered way to receive emails to note in OpenPGP-Header # ('sign'|'encrypt'|'signencrypt'|'unprotected'|'none') openpgp_header_preference: signencrypt # Maximum size of emails allowed on the list, in kilobyte. All others will be # bounced. max_message_size_kb: 10240 # How verbose to log on the list-level (Notifications will be sent to # list-admins)? Error, warn, info, or debug. log_level: warn # How many logfiles to keep, including the current one. # Logfiles are rotated daily, so 2 means: delete logfiles older than # yesterday. Values lower than 1 are ignored. logfiles_to_keep: 2 # Which language to use for automated replies, error-messages, etc. # Available: en, de. language: en # Forward a raw copy of all incoming emails to the list-admins? # Mainly useful for debugging. forward_all_incoming_to_admins: false schleuder-3.0.1/etc/postfix/000077500000000000000000000000001304235634100157415ustar00rootroot00000000000000schleuder-3.0.1/etc/postfix/schleuder_sqlite.cf000066400000000000000000000022351304235634100216140ustar00rootroot00000000000000# Use this as a table for postfix to select addresses that schleuder # thinks belong to it. This is useful when # smtpd_reject_unlisted_recipient = yes (which is the default for # modern Postfix) # For example, you might dedicate Postfix's "virtual" domains to # schleuder with the following set of configs in main.cf: # # virtual_domains = lists.example.org # virtual_transport = schleuder # virtual_alias_maps = hash:/etc/postfix/virtual_aliases # virtual_mailbox_maps = sqlite:/etc/postfix/schleuder_sqlite.cf # schleuder_destination_recipient_limit = 1 # it is not recommended to use this table for more powerful # configuration options (e.g. transport_maps) because it could give # the schleuder user (which can write the given sqlite database) the # power to change settings for for other mail handled by this Postfix # instance. dbpath = /var/lib/schleuder/db.sqlite query = select 'present' where '%s' in ( select email from lists union select replace(email, '@', '-bounces@') from lists union select replace(email, '@', '-owner@') from lists union select replace(email, '@', '-request@') from lists union select replace(email, '@', '-sendkey@') from lists) schleuder-3.0.1/etc/schleuder-api-daemon.service000066400000000000000000000002731304235634100216170ustar00rootroot00000000000000[Unit] Description=Schleuder API daemon After=local-fs.target network.target [Service] ExecStart=/usr/local/bin/schleuder-api-daemon User=schleuder [Install] WantedBy=multi-user.target schleuder-3.0.1/etc/schleuder.cron.weekly000066400000000000000000000002071304235634100204040ustar00rootroot00000000000000#!/bin/sh set -e test -x /usr/local/bin/schleuder || exit 0 su -s /bin/sh schleuder -c "/usr/local/bin/schleuder check_keys" exit 0 schleuder-3.0.1/etc/schleuder.yml000066400000000000000000000033731304235634100167540ustar00rootroot00000000000000# Where are the list-directories stored (contain log-files and GnuPG-keyrings). lists_dir: /var/lib/schleuder/lists # Where to write list-logs. The actual log-file will be ///list.log. listlogs_dir: /var/lib/schleuder/lists # Schleuder reads plugins also from this directory. plugins_dir: /etc/schleuder/plugins # How verbose should Schleuder log to syslog? (list-specific messages are written to the list's log-file). log_level: warn # Which keyserver to refresh keys from (used by `schleuder refresh_keys`, meant # to be run from cron weekly). # If you have gnupg 2.1, we strongly suggest to use a hkps-keyserver: #keyserver: hkps://hkps.pool.sks-keyservers.net # If you have gnupg 2.1 and TOR running locally, use a onion-keyserver: #keyserver: hkp://jirk5u4osbsr34t5.onion # The default works for all supported versions of gnupg: keyserver: pool.sks-keyservers.net # For these options see documentation for ActionMailer::smtp_settings, e.g. . smtp_settings: address: localhost port: 25 #domain: #enable_starttls_auto: #openssl_verify_mode: #authentication: #user_name: #password: # The database to use. Unless you want to run the tests you only need the `production`-section. database: production: adapter: 'sqlite3' database: /var/lib/schleuder/db.sqlite timeout: 5000 api: host: localhost port: 4443 # Certificate and key to use. You can create new ones with `schleuder cert generate`. tls_cert_file: /etc/schleuder/schleuder-certificate.pem tls_key_file: /etc/schleuder/schleuder-private-key.pem # List of api_keys to allow access to the API. # Example: # valid_api_keys: # - abcdef... # - zyxwvu... valid_api_keys: schleuder-3.0.1/gem-public_cert.pem000066400000000000000000000023611304235634100172400ustar00rootroot00000000000000-----BEGIN CERTIFICATE----- MIIDeDCCAmCgAwIBAgIBATANBgkqhkiG9w0BAQUFADBBMRMwEQYDVQQDDApzY2hs ZXVkZXIyMRUwEwYKCZImiZPyLGQBGRYFbmFkaXIxEzARBgoJkiaJk/IsZAEZFgNv cmcwHhcNMTMwOTI5MjAwNzQxWhcNMTQwOTI5MjAwNzQxWjBBMRMwEQYDVQQDDApz Y2hsZXVkZXIyMRUwEwYKCZImiZPyLGQBGRYFbmFkaXIxEzARBgoJkiaJk/IsZAEZ FgNvcmcwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQChGruoNnq3Ir7d Fd+ktG0tMZlm2ZSOkuHO5QRrgYLgbBhpTEf8i6AjzoVL0AIC+uMMVY9iE6fzaKUD B7SvNtccHskX6zHUVVtSqF9VpbQomWpck0iBqwQIw4vELe2iZ+/ZULKIJI/BY43y tX7Ora8izSyPGcu6E1fr5PJI6igFnlEgs/jCjP/JYHf/f49fnIzAJgO0Q7YNNJVr R0Zqm1HbYE2t+RtomT2jgCjBtF42hX8+gB4yV5nedfHKyZfD6zd7doPE/pdtpn80 BrRQbHXlEPDCadHH013j7oL7B5fJlHejX6PFfPtepq3adDQ/O3lFvzfHuJUGjEO5 QXp7l5+fAgMBAAGjezB5MAkGA1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQW BBSBtRuT8QNZTfwVGJKJr5bbDlgk3jAfBgNVHREEGDAWgRRzY2hsZXVkZXIyQG5h ZGlyLm9yZzAfBgNVHRIEGDAWgRRzY2hsZXVkZXIyQG5hZGlyLm9yZzANBgkqhkiG 9w0BAQUFAAOCAQEAOW1oNWquxZegMjQDZF3yTDsXbDAs4JYsLEbjnD2z32nMGvat wDxKD0g3XIPHEoEi28/3n6C4Py2J+P7gUObr+wWF8G67nwg2tDjarOia93RcpxqW n4NKeyRmvEzQ+yU+X9xiwJ005mc2ME2j3QF+sjDxgd+uCN0ZT77qz2Kk4iuCGOrM cuTmrcZdTiHkGhK7UtDn7nk3ShgwrtyC0SqPna+PUMYkPr5FQLVwsOHGExOtVHZX +VhPezxtXTAQ0pIYXF5NssxnhcngHV8fPs0g4gbU0RRKar9egfgZ8cVITgVauVPt HdW17U59V5gWNuJBqqwiV2PJubSZekUq/YMdtg== -----END CERTIFICATE----- schleuder-3.0.1/lib/000077500000000000000000000000001304235634100142405ustar00rootroot00000000000000schleuder-3.0.1/lib/schleuder.rb000066400000000000000000000041221304235634100165420ustar00rootroot00000000000000# Stdlib require 'fileutils' require 'singleton' require 'yaml' require 'pathname' require 'syslog/logger' require 'logger' require 'open3' # Require mandatory libs. The database-layer-lib is required below. require 'mail-gpg' require 'active_record' # An extra from mail-gpg require 'hkp' # Load schleuder libdir = Pathname.new(__FILE__).dirname.realpath rootdir = libdir.dirname $:.unshift libdir # Monkeypatches require 'schleuder/mail/message.rb' require 'schleuder/gpgme/import_status.rb' require 'schleuder/gpgme/key.rb' require 'schleuder/gpgme/sub_key.rb' require 'schleuder/gpgme/ctx.rb' # The Code[tm] require 'schleuder/errors/base' Dir["#{libdir}/schleuder/errors/*.rb"].each do |file| require file end # Load schleuder/conf before the other classes, it defines constants! require 'schleuder/conf' require 'schleuder/version' require 'schleuder/logger_notifications' require 'schleuder/logger' require 'schleuder/listlogger' require 'schleuder/plugins_runner' Dir["#{libdir}/schleuder/plugins/*.rb"].each do |file| require file end require 'schleuder/filters_runner' Dir["#{libdir}/schleuder/filters/*.rb"].each do |file| require file end Dir["#{libdir}/schleuder/validators/*.rb"].each do |file| require file end require 'schleuder/runner' require 'schleuder/list' require 'schleuder/list_builder' require 'schleuder/subscription' # Setup ENV["SCHLEUDER_CONFIG"] ||= '/etc/schleuder/schleuder.yml' ENV["SCHLEUDER_LIST_DEFAULTS"] ||= '/etc/schleuder/list-defaults.yml' ENV["SCHLEUDER_ENV"] ||= 'production' ENV["SCHLEUDER_ROOT"] = rootdir.to_s GPGME::Ctx.set_gpg_path_from_env GPGME::Ctx.check_gpg_version # Require lib for database specified in config. require Schleuder::Conf.database['adapter'] # TODO: Test if database is writable if sqlite. ActiveRecord::Base.establish_connection(Schleuder::Conf.database) ActiveRecord::Base.logger = Schleuder.logger Mail.defaults do delivery_method :smtp, Schleuder::Conf.smtp_settings.symbolize_keys end I18n.load_path += Dir["#{rootdir}/locales/*.yml"] I18n.enforce_available_locales = true I18n.default_locale = :en File.umask(0027) include Schleuder schleuder-3.0.1/lib/schleuder/000077500000000000000000000000001304235634100162165ustar00rootroot00000000000000schleuder-3.0.1/lib/schleuder/cli.rb000066400000000000000000000233731304235634100173220ustar00rootroot00000000000000require 'thor' require 'yaml' require 'gpgme' require_relative '../schleuder' require 'schleuder/cli/subcommand_fix' require 'schleuder/cli/schleuder_cert_manager' require 'schleuder/cli/cert' module Schleuder class Cli < Thor register(Cert, 'cert', 'cert ...', 'Generate TLS-certificate and show fingerprint') map '-v' => :version map '--version' => :version desc 'version', 'Show version of schleuder' def version say Schleuder::VERSION end desc 'new_api_key', 'Generate a new API key to be used by a client.' def new_api_key require 'securerandom' puts SecureRandom.hex(32) end desc 'work list@hostname < message', 'Run a message through a list.' def work(listname) message = STDIN.read error = Schleuder::Runner.new.run(message, listname) if error.kind_of?(StandardError) fatal error end rescue => exc begin Schleuder.logger.fatal(exc.message_with_backtrace, message) say I18n.t('errors.fatalerror') rescue => e # Give users a clue what to do in case everything blows up. # As apparently even the logging raised exceptions we can't even store # any information in the logs. fatal "A serious, unhandleable error happened. Please contact the administrators of this system or service and provide them with the following information:\n\n#{e.message}" end exit 1 end desc 'check_keys', 'Check all lists for unusable or expiring keys and send the results to the list-admins. (This is supposed to be run from cron weekly.)' def check_keys List.all.each do |list| I18n.locale = list.language text = list.check_keys if text && ! text.empty? msg = "#{I18n.t('check_keys_intro', email: list.email)}\n\n#{text}" list.logger.notify_admin(msg, nil, I18n.t('check_keys')) end end end desc 'refresh_keys', "Refresh all keys of all list from the keyservers sequentially (one by one). (This is supposed to be run from cron weekly.)" def refresh_keys List.all.each do |list| I18n.locale = list.language output = list.refresh_keys if output.present? msg = "#{I18n.t('refresh_keys_intro', email: list.email)}\n\n#{output}" list.logger.notify_admin(msg, nil, I18n.t('refresh_keys')) end end end desc 'install', "Set-up or update Schleuder environment (create folders, copy files, fill the database)." def install config_dir = Pathname.new(ENV['SCHLEUDER_CONFIG']).dirname root_dir = Pathname.new(ENV['SCHLEUDER_ROOT']) # Check if lists_dir contains v2-data. if Dir.glob("#{Conf.lists_dir}/*/*/members.conf").size > 0 msg = "Lists directory #{Conf.lists_dir} appears to contain data from a Schleuder version 2.x installation.\nPlease move it out of the way or configure a different `lists_dir` in `#{ENV['SCHLEUDER_CONFIG']}`.\nTo migrate lists from Schleuder v2 to Schleuder v3 please use `schleuder migrate_v2_list` after the installation succeeded." fatal msg, 2 end [Conf.lists_dir, Conf.listlogs_dir, config_dir].each do |dir| dir = Pathname.new(dir) if ! dir.exist? begin dir.mkpath rescue Errno::EACCES => exc problem_dir = exc.message.split(' - ').last fatal "Cannot create required directory due to lacking write permissions: #{problem_dir}.\nPlease fix the permissions or create the directory manually and then run this command again." end end end Pathname.glob(root_dir.join("etc").join("*.yml")).each do |file| target = config_dir.join(file.basename) if ! target.exist? if target.dirname.writable? FileUtils.cp file, target else fatal "Cannot copy default config file due to lacking write permissions, please copy manually and then run this command again:\n#{file.realpath} → #{target}" end end end if ActiveRecord::SchemaMigration.table_exists? say `cd #{root_dir} && rake db:migrate` else say `cd #{root_dir} && rake db:schema:load` if Conf.database['adapter'].match(/sqlite/) say "NOTE: The database was prepared using sqlite. If you prefer to use a different DBMS please edit the 'database'-section in /etc/schleuder/schleuder.yml, create the database, install the corresponding ruby-library (e.g. `gem install mysql`) and run this current command again" end end if ! File.exist?(Conf.api['tls_cert_file']) || ! File.exist?(Conf.api['tls_key_file']) Schleuder::Cert.new.generate end say "Schleuder has been set up. You can now create a new list using `schleuder-cli`.\nWe hope you enjoy!" rescue => exc fatal exc.message end desc 'migrate-v2-list /path/to/listdir', 'Migrate list from v2.2 to v3.' def migrate_v2_list(path) dir = Pathname.new(path) if ! dir.readable? || ! dir.directory? fatal "Not a readable directory: `#{path}`." end %w[list.conf members.conf pubring.gpg].each do |file| if ! (dir + file).exist? fatal "Not a complete schleuder v2.2 listdir: missing #{file}" end end conf = YAML.load(File.read(dir + 'list.conf')) if conf.nil? || conf.empty? fatal "list.conf is blank" end listname = conf['myaddr'] if listname.nil? || listname.empty? fatal "myaddr is blank in list.conf" end # Identify list-fingerprint. ENV['GNUPGHOME'] = dir.to_s listkey = GPGME::Key.find(:public, "<#{listname}>").first if listkey.nil? fatal "Failed to identify the list's OpenPGP-key!" end # Create list. begin list, messages = Schleuder::ListBuilder.new({email: listname, fingerprint: listkey.fingerprint}).run rescue => exc fatal exc end if messages fatal messages.values.join(" - ") elsif list.errors.any? fatal list.errors.full_messages.join(" - ") end # Import keys list.import_key(File.read(dir + 'pubring.gpg')) list.import_key(File.read(dir + 'secring.gpg')) # Clear passphrase of imported list-key. output = list.key.clearpassphrase(conf['gpg_password']) if output.present? fatal "while clearing passphrase of list-key: #{output.inspect}" end # Set list-options. List.configurable_attributes.each do |option| option = option.to_s if conf.keys.include?(option) value = case option when /^keywords_/ filter_keywords(conf[option]) when 'log_level' conf[option].to_s.downcase else conf[option] end list.set_attribute(option, value) end end # Set changed options. changed_options = { 'prefix' => 'subject_prefix', 'prefix_in' => 'subject_prefix_in', 'prefix_out' => 'subject_prefix_out', 'dump_incoming_mail' => 'forward_all_incoming_to_admins', 'receive_from_member_emailaddresses_only' => 'receive_from_subscribed_emailaddresses_only', 'bounces_notify_admin' => 'bounces_notify_admins', 'max_message_size' => 'max_message_size_kb' } changed_options.each do |old, new| if conf.keys.include?(old) list.set_attribute(new, conf[old]) end end list.save! # Subscribe members YAML.load(File.read(dir + 'members.conf')).each do |member| list.subscribe(member['email'], member['fingerprint']) end # Subscribe or flag admins conf['admins'].each do |member| sub = list.subscriptions.where(email: member['email']).first if sub sub.admin = true sub.save! else adminfpr = member['fingerprint'] || list.keys(member['email']).first.fingerprint list.subscribe(member['email'], adminfpr, true) end end # Notify of removed options say "Please note: the following options have been *removed*: * `default_mime` for lists (we only support pgp/mime for now), * `archive` for lists, * `gpg_passphrase` for lists, * `log_file`, `log_io`, `log_syslog` for lists (we only log to syslog (before list-creation) and a file (after it) for now), * `mime` for subscriptions/members (we only support pgp/mime for now), * `send_encrypted_only` for members/subscriptions. If you really miss any of them please tell us. Please also note that the following keywords have been renamed: * list-members => list-subscriptions * add-member => subscribe * delete-member => unsubscribe Please notify the users and admins of this list of these changes. " say "\nList #{listname} migrated to schleuder v3." if messages.present? say messages.gsub(' // ', "\n") end rescue => exc fatal "#{exc}\n#{exc.backtrace.first}" end no_commands do def fatal(msg, exitcode=1) error("Error: #{msg}") exit exitcode end KEYWORDS = { 'add-member' => 'subscribe', 'delete-member' => 'unsubscribe', 'list-members' => 'list-subscriptions', 'subscribe' => 'subscribe', 'unsubscribe' => 'unsubscribe', 'list-subscriptions' => 'list-subscriptions', 'set-finterprint' => 'set-fingerprint', 'add-key' => 'add-key', 'delete-key' => 'delete-key', 'list-keys' => 'list-keys', 'get-key' => 'get-key', 'fetch-key' => 'fetch-key' } def filter_keywords(value) Array(value).map do |keyword| KEYWORDS[keyword.downcase] end.compact end end end end schleuder-3.0.1/lib/schleuder/cli/000077500000000000000000000000001304235634100167655ustar00rootroot00000000000000schleuder-3.0.1/lib/schleuder/cli/cert.rb000066400000000000000000000017051304235634100202520ustar00rootroot00000000000000module Schleuder class Cert < Thor extend SubcommandFix desc 'generate', 'Generate a new TLS-certificate.' def generate key = Conf.api['tls_key_file'] cert = Conf.api['tls_cert_file'] fingerprint = SchleuderCertManager.generate('schleuder', key, cert) puts "Fingerprint of generated certificate: #{fingerprint}" puts "Have this fingerprint included into the configuration-file of all clients that want to connect to your Schleuder API." if Process.euid == 0 puts "! Warning: this process was run as root — please make sure the above files are accessible by the user that is running `schleuder-api-daemon`." end end desc 'fingerprint', 'Show fingerprint of configured certificate.' def fingerprint cert = Conf.api['tls_cert_file'] fingerprint = SchleuderCertManager.fingerprint(cert) say "Fingerprint of #{Conf.api['tls_cert_file']}: #{fingerprint}" end end end schleuder-3.0.1/lib/schleuder/cli/schleuder_cert_manager.rb000066400000000000000000000046421304235634100240050ustar00rootroot00000000000000require 'openssl' require 'pathname' class SchleuderCertManager def self.generate(project_name, filename_key, filename_cert) keysize = 2048 subject = "/C=MW/O=Schleuder/OU=#{project_name}" filename_key = Pathname.new(filename_key).expand_path filename_cert = Pathname.new(filename_cert).expand_path key = OpenSSL::PKey::RSA.new(keysize) cert = OpenSSL::X509::Certificate.new cert.subject = OpenSSL::X509::Name.parse(subject) cert.issuer = cert.subject cert.not_before = Time.now cert.not_after = Time.now + 10 * 365 * 24 * 60 * 60 cert.public_key = key.public_key cert.serial = 0x0 cert.version = 2 ef = OpenSSL::X509::ExtensionFactory.new ef.subject_certificate = cert ef.issuer_certificate = cert cert.extensions = [ ef.create_extension("basicConstraints","CA:TRUE", true), ef.create_extension("subjectKeyIdentifier", "hash"), ] cert.add_extension ef.create_extension("authorityKeyIdentifier", "keyid:always,issuer:always") cert.sign key, OpenSSL::Digest::SHA256.new filename_key = prepare_writing(filename_key) filename_cert = prepare_writing(filename_cert) filename_key.open('w', 400) do |fd| fd.puts key end puts "Private key written to: #{filename_key}" filename_cert.open('w') do |fd| fd.puts cert.to_pem end puts "Certificate written to: #{filename_cert}" fingerprint(cert) rescue => exc error exc.message end def self.fingerprint(cert) if ! cert.is_a?(OpenSSL::X509::Certificate) path = Pathname.new(cert).expand_path if ! path.readable? error "Error: Not a readable file: #{path}" end cert = OpenSSL::X509::Certificate.new(path.read) end OpenSSL::Digest::SHA256.new(cert.to_der).to_s end def self.error(msg) $stderr.puts "Error: #{msg}" exit 1 end def self.note(msg) $stdout.puts "Note: #{msg}" end def self.prepare_writing(filename) if filename.exist? note "File exists: #{filename} — writing to current directory, you should move the file manually or change the configuration file." if filename.basename.exist? error "File exists: #{filename.basename} — (re)move it or fix previous error and try again." end filename = filename.basename end if ! filename.dirname.exist? filename.dirname.mkpath end filename end end schleuder-3.0.1/lib/schleuder/cli/subcommand_fix.rb000066400000000000000000000005071304235634100223120ustar00rootroot00000000000000module Schleuder module SubcommandFix # Fixing a bug in Thor where the actual subcommand wouldn't show up # with some invokations of the help-output. def banner(task, namespace = true, subcommand = true) "#{basename} #{task.formatted_usage(self, true, subcommand).split(':').join(' ')}" end end end schleuder-3.0.1/lib/schleuder/conf.rb000066400000000000000000000057511304235634100175000ustar00rootroot00000000000000module Schleuder class Conf include Singleton EMAIL_REGEXP = /\A.+@[[:alnum:]_.-]+\z/i DEFAULTS = { 'lists_dir' => '/var/lib/schleuder/lists', 'listlogs_dir' => '/var/lib/schleuder/lists', 'plugins_dir' => '/etc/schleuder/plugins', 'log_level' => 'warn', 'keyserver' => 'hkp://pool.sks-keyservers.net', 'smtp_settings' => { 'address' => 'localhost', 'port' => 25, 'domain' => 'localhost', 'enable_starttls_auto' => true, # Don't verify by default because most smtp servers don't include # 'localhost' into their TLS-certificates. 'openssl_verify_mode' => 'none', 'authentication' => nil, 'user_name' => nil, 'password' => nil, }, 'database' => { 'production' => { 'adapter' => 'sqlite3', 'database' => '/var/lib/schleuder/db.sqlite', 'timeout' => 5000 } }, 'api' => { 'host' => 'localhost', 'port' => 4443, 'tls_cert_file' => '/etc/schleuder/schleuder-certificate.pem', 'tls_key_file' => '/etc/schleuder/schleuder-private-key.pem', 'valid_api_keys' => [] } } def config @config ||= load_config(ENV['SCHLEUDER_CONFIG']) end def self.lists_dir instance.config['lists_dir'] end def self.listlogs_dir instance.config['listlogs_dir'] end def self.plugins_dir instance.config['plugins_dir'] end def self.database instance.config['database'][ENV['SCHLEUDER_ENV']] end def self.databases instance.config['database'] end def self.superadmin instance.config['superadmin'] end def self.log_level instance.config['log_level'] || 'WARN' end def self.api instance.config['api'] || {} end def self.api_valid_api_keys Array(api['valid_api_keys']) end # Three legacy options def self.smtp_host instance.config['smtp_host'] end def self.smtp_port instance.config['smtp_port'] end def self.smtp_helo_domain instance.config['smtp_helo_domain'] end def self.smtp_settings settings = instance.config['smtp_settings'] || {} # Support previously used config-options. # Remove this in future versions. {smtp_host: :address, smtp_port: :port, smtp_helo_domain: :domain}.each do |old, new| value = self.send(old) if value.present? Schleuder.logger.warn "Deprecation warning: In schleuder.yml #{old} should be changed to smtp_settings[#{new}]." settings[new] = value end end settings end def self.keyserver instance.config['keyserver'] end private def load_config(filename) DEFAULTS.deep_merge(load_config_file(filename)) end def load_config_file(filename) file = Pathname.new(filename) if file.readable? YAML.load(file.read) else {} end end end end schleuder-3.0.1/lib/schleuder/errors/000077500000000000000000000000001304235634100175325ustar00rootroot00000000000000schleuder-3.0.1/lib/schleuder/errors/active_model_error.rb000066400000000000000000000004171304235634100237250ustar00rootroot00000000000000module Schleuder module Errors class ActiveModelError < Base def initialize(errors) @errors = errors end def message @errors.messages.map do |message| message.join(' ') end.join("\n") end end end end schleuder-3.0.1/lib/schleuder/errors/base.rb000066400000000000000000000004271304235634100207740ustar00rootroot00000000000000module Schleuder module Errors class Base < StandardError def t(*args) I18n.t(*args) end def to_s message + t('errors.signoff') end def set_default_locale I18n.locale = I18n.default_locale end end end end schleuder-3.0.1/lib/schleuder/errors/decryption_failed.rb000066400000000000000000000004721304235634100235460ustar00rootroot00000000000000module Schleuder module Errors class DecryptionFailed < Base def initialize(list) set_default_locale @list = list end def message t('errors.decryption_failed', { key: @list.key.to_s, email: @list.sendkey_address }) end end end end schleuder-3.0.1/lib/schleuder/errors/file_not_found.rb000066400000000000000000000003311304235634100230460ustar00rootroot00000000000000module Schleuder module Errors class FileNotFound < Base def initialize(file) @file = file end def message t('errors.file_not_found', file: @file) end end end end schleuder-3.0.1/lib/schleuder/errors/invalid_listname.rb000066400000000000000000000003561304235634100234050ustar00rootroot00000000000000module Schleuder module Errors class InvalidListname < Base def initialize(listname) @listname = listname end def message t('errors.invalid_listname', email: @listname) end end end end schleuder-3.0.1/lib/schleuder/errors/key_adduid_failed.rb000066400000000000000000000003541304235634100234670ustar00rootroot00000000000000module Schleuder module Errors class KeyAdduidFailed < Base def initialize(errmsg) @errmsg = errmsg end def message t('errors.key_adduid_failed', { errmsg: @errmsg }) end end end end schleuder-3.0.1/lib/schleuder/errors/key_generation_failed.rb000066400000000000000000000005131304235634100243650ustar00rootroot00000000000000module Schleuder module Errors class KeyGenerationFailed < Base def initialize(listdir, listname) @listdir = listdir @listname = listname end def message t('errors.key_generation_failed', { listdir: @listdir, listname: @listname }) end end end end schleuder-3.0.1/lib/schleuder/errors/keyword_admin_only.rb000066400000000000000000000003571304235634100237610ustar00rootroot00000000000000module Schleuder module Errors class KeywordAdminOnly < Base def initialize(keyword) @keyword = keyword end def message t('errors.keyword_admin_only', keyword: @keyword) end end end end schleuder-3.0.1/lib/schleuder/errors/list_exists.rb000066400000000000000000000003441304235634100224320ustar00rootroot00000000000000module Schleuder module Errors class ListExists < Base def initialize(listname) @listname = listname end def message t('errors.list_exists', email: @listname) end end end end schleuder-3.0.1/lib/schleuder/errors/list_not_found.rb000066400000000000000000000003561304235634100231110ustar00rootroot00000000000000module Schleuder module Errors class ListNotFound < Base def initialize(recipient) @recipient = recipient end def message t('errors.list_not_found', email: @recipient) end end end end schleuder-3.0.1/lib/schleuder/errors/list_property_missing.rb000066400000000000000000000003461304235634100245320ustar00rootroot00000000000000module Schleuder module Errors class ListPropertyMissing < Base def initialize(property) @property = property end def to_s t("errors.list_#{@property}_missing") end end end end schleuder-3.0.1/lib/schleuder/errors/listdir_problem.rb000066400000000000000000000005171304235634100232540ustar00rootroot00000000000000module Schleuder module Errors class ListdirProblem < Base def initialize(dir, problem) @dir = dir @problem = problem end def message problem = t("errors.listdir_problem.#{@problem}") t('errors.listdir_problem.message', dir: @dir, problem: problem) end end end end schleuder-3.0.1/lib/schleuder/errors/loading_list_settings_failed.rb000066400000000000000000000004351304235634100257550ustar00rootroot00000000000000module Schleuder module Errors class LoadingListSettingsFailed < Base def initialize @config_file = ENV['SCHLEUDER_LIST_DEFAULTS'] end def message t('errors.loading_list_settings_failed', config_file: @config_file) end end end end schleuder-3.0.1/lib/schleuder/errors/message_empty.rb000066400000000000000000000004471304235634100227260ustar00rootroot00000000000000module Schleuder module Errors class MessageEmpty < Base def initialize(list) set_default_locale @request_address = list.request_address end def message t('errors.message_empty', { request_address: @request_address }) end end end end schleuder-3.0.1/lib/schleuder/errors/message_not_from_admin.rb000066400000000000000000000003401304235634100245530ustar00rootroot00000000000000module Schleuder module Errors class MessageNotFromAdmin < Base def initialize(list) set_default_locale end def message t('errors.message_not_from_admin') end end end end schleuder-3.0.1/lib/schleuder/errors/message_sender_not_subscribed.rb000066400000000000000000000003561304235634100261340ustar00rootroot00000000000000module Schleuder module Errors class MessageSenderNotSubscribed < Base def initialize(list) set_default_locale end def message t('errors.message_sender_not_subscribed') end end end end schleuder-3.0.1/lib/schleuder/errors/message_too_big.rb000066400000000000000000000004451304235634100232100ustar00rootroot00000000000000module Schleuder module Errors class MessageTooBig < Base def initialize(list) set_default_locale @allowed_size = list.max_message_size_kb end def message t('errors.message_too_big', { allowed_size: @allowed_size }) end end end end schleuder-3.0.1/lib/schleuder/errors/message_unauthenticated.rb000066400000000000000000000003361304235634100247520ustar00rootroot00000000000000module Schleuder module Errors class MessageUnauthenticated < Base def initialize set_default_locale end def message t('errors.message_unauthenticated') end end end end schleuder-3.0.1/lib/schleuder/errors/message_unencrypted.rb000066400000000000000000000003341304235634100241230ustar00rootroot00000000000000module Schleuder module Errors class MessageUnencrypted < Base def initialize(list) set_default_locale end def message t('errors.message_unencrypted') end end end end schleuder-3.0.1/lib/schleuder/errors/message_unsigned.rb000066400000000000000000000003261304235634100234000ustar00rootroot00000000000000module Schleuder module Errors class MessageUnsigned < Base def initialize(list) set_default_locale end def message t('errors.message_unsigned') end end end end schleuder-3.0.1/lib/schleuder/errors/standard_error.rb000066400000000000000000000001541304235634100230700ustar00rootroot00000000000000class StandardError def message_with_backtrace "#{message}\n#{self.backtrace.join("\n")}\n" end end schleuder-3.0.1/lib/schleuder/errors/too_many_keys.rb000066400000000000000000000004741304235634100227440ustar00rootroot00000000000000module Schleuder module Errors class TooManyKeys < Base def initialize(listdir, listname) @listdir = listdir @listname = listname end def message t('errors.too_many_keys', { listdir: @listdir, listname: @listname }) end end end end schleuder-3.0.1/lib/schleuder/errors/unknown_list_option.rb000066400000000000000000000005151304235634100242020ustar00rootroot00000000000000module Schleuder module Errors class UnknownListOption < Base def initialize(exception) @option = exception.attribute @config_file = ENV['SCHLEUDER_LIST_DEFAULTS'] end def message t('errors.unknown_list_option', option: @option, config_file: @config_file) end end end end schleuder-3.0.1/lib/schleuder/filters/000077500000000000000000000000001304235634100176665ustar00rootroot00000000000000schleuder-3.0.1/lib/schleuder/filters/auth_filter.rb000066400000000000000000000025771304235634100225340ustar00rootroot00000000000000module Schleuder module Filters def self.receive_encrypted_only(list, mail) if list.receive_encrypted_only? && ! mail.was_encrypted? list.logger.info "Rejecting mail as unencrypted" return Errors::MessageUnencrypted.new(list) end end def self.receive_signed_only(list, mail) if list.receive_signed_only? && ! mail.was_validly_signed? list.logger.info "Rejecting mail as unsigned" return Errors::MessageUnsigned.new(list) end end def self.receive_authenticated_only(list, mail) if list.receive_authenticated_only? && ( ! mail.was_encrypted? || ! mail.was_validly_signed? ) list.logger.info "Rejecting mail as unauthenticated" return Errors::MessageUnauthenticated.new end end def self.receive_from_subscribed_emailaddresses_only(list, mail) if list.receive_from_subscribed_emailaddresses_only? && list.subscriptions.where(email: mail.from.first).blank? list.logger.info "Rejecting mail as not from subscribed address." return Errors::MessageSenderNotSubscribed.new(list) end end def self.receive_admin_only(list, mail) if list.receive_admin_only? && ( ! mail.was_validly_signed? || ! mail.signer.admin? ) list.logger.info "Rejecting mail as not from admin." return Errors::MessageNotFromAdmin.new(list) end end end end schleuder-3.0.1/lib/schleuder/filters/bounces_filter.rb000066400000000000000000000004671304235634100232250ustar00rootroot00000000000000module Schleuder module Filters def self.forward_bounce_to_admins(list, mail) if mail.bounce? list.logger.info "Forwarding bounce to admins" list.logger.notify_admin I18n.t(:forward_bounce_to_admins), mail.original_message, I18n.t('bounce') exit end end end end schleuder-3.0.1/lib/schleuder/filters/forward_filter.rb000066400000000000000000000006711304235634100232300ustar00rootroot00000000000000module Schleuder module Filters def self.forward_to_owner(list, mail) return if ! mail.to_owner? list.logger.debug "Forwarding addressed to -owner" mail.add_pseudoheader(:note, I18n.t(:owner_forward_prefix)) cleanmail = mail.clean_copy(true) list.admins.each do |admin| list.logger.debug "Forwarding message to #{admin}" admin.send_mail(cleanmail) end exit end end end schleuder-3.0.1/lib/schleuder/filters/forward_incoming.rb000066400000000000000000000004431304235634100235430ustar00rootroot00000000000000module Schleuder module Filters def self.forward_all_incoming_to_admins(list, mail) if list.forward_all_incoming_to_admins list.logger.notify_admin I18n.t(:forward_all_incoming_to_admins), mail.original_message, I18n.t('incoming_message') end end end end schleuder-3.0.1/lib/schleuder/filters/max_message_size.rb000066400000000000000000000004221304235634100235340ustar00rootroot00000000000000module Schleuder module Filters def self.max_message_size(list, mail) if (mail.raw_source.size / 1024) > list.max_message_size_kb list.logger.info "Rejecting mail as too big" return Errors::MessageTooBig.new(list) end end end end schleuder-3.0.1/lib/schleuder/filters/request_filter.rb000066400000000000000000000010611304235634100232460ustar00rootroot00000000000000module Schleuder module Filters def self.request(list, mail) return if ! mail.request? list.logger.debug "Request-message" if ! mail.was_encrypted? || ! mail.was_validly_signed? list.logger.debug "Error: Message was not encrypted and validly signed" return Errors::MessageUnauthenticated.new end if mail.keywords.empty? output = I18n.t(:no_keywords_error) else output = Plugins::Runner.run(list, mail).compact end mail.reply_to_signer(output) exit end end end schleuder-3.0.1/lib/schleuder/filters/send_key_filter.rb000066400000000000000000000016671304235634100233730ustar00rootroot00000000000000module Schleuder module Filters def self.send_key(list, mail) return if ! mail.sendkey_request? list.logger.debug "Sending public key as reply." out = mail.reply out.from = list.email # We're not sending to a subscribed address, so we need to specify a return-path manually. out.return_path = list.bounce_address out.body = I18n.t(:list_public_key_attached) # TODO: clean this up, there must be an easier way to attach inline-disposited content. filename = "#{list.email}.asc" out.add_file({ filename: filename, content: list.export_key }) out.attachments[filename].content_type = 'application/pgp-keys' out.attachments[filename].content_description = 'OpenPGP public key' # TODO: find out why the gpg-module puts all the headers into the first mime-part, too out.gpg list.gpg_sign_options out.deliver exit end end end schleuder-3.0.1/lib/schleuder/filters_runner.rb000066400000000000000000000045031304235634100216060ustar00rootroot00000000000000module Schleuder module Filters class Runner # To define priority sort this. FILTERS = %w[ request forward_bounce_to_admins forward_all_incoming_to_admins send_key forward_to_owner max_message_size receive_admin_only receive_authenticated_only receive_signed_only receive_encrypted_only receive_from_subscribed_emailaddresses_only ] def self.run(list, mail) @list = list @mail = mail FILTERS.map do |cmd| @list.logger.debug "Calling filter #{cmd}" response = Filters.send(cmd, list, mail) if stop?(response) if bounce?(response) return response else return nil end end end nil end def self.stop?(response) response.kind_of?(StandardError) end def self.bounce?(response) if @list.bounces_drop_all @list.logger.debug "Dropping bounce as configurated" notify_admins(I18n.t('.bounces_drop_all')) return false end @list.bounces_drop_on_headers.each do |key, value| if @mail.headers[key].to_s.match(/${value}/i) @list.logger.debug "Incoming message header key '#{key}' matches value '#{value}': dropping the bounce." notify_admins(I18n.t('.bounces_drop_on_headers', key: key, value: value)) return false end end @list.logger.debug "Bouncing message" true end def self.notify_admins(reason) if @list.bounces_notify_admins? @list.logger.notify_admin reason, @mail.original_message, I18n.t('notice') end end def self.reply_to_sender(msg) sender_addr = @mail.from.first logger.debug "Replying to #{sender_addr.inspect}" reply = @mail.reply reply.from = @list.email reply.return_path = @list.bounce_address reply.body = msg gpg_opts = @list.gpg_sign_options if @list.keys("<#{sender_addr}>").present? logger.debug "Found key for address" gpg_opts[encrypt] = true end reply.gpg gpg_opts list.logger.info "Sending message to #{sender_addr}" reply.deliver end end end end schleuder-3.0.1/lib/schleuder/gpgme/000077500000000000000000000000001304235634100173155ustar00rootroot00000000000000schleuder-3.0.1/lib/schleuder/gpgme/ctx.rb000066400000000000000000000114531304235634100204440ustar00rootroot00000000000000module GPGME class Ctx IMPORT_FLAGS = { 'new key' => 1, 'new_uids' => 2, 'new_signatures' => 4, 'new_subkeys' => 8 } def keyimport(*args) self.import_keys(*args) result = self.import_result result.imports.map(&:set_action) result end # Tell gpgme to use the given binary. def self.set_gpg_path_from_env path = ENV['GPGBIN'].to_s if ! path.empty? Schleuder.logger.debug "setting gpg to use #{path}" GPGME::Engine.set_info(GPGME::PROTOCOL_OpenPGP, path, ENV['GNUPGHOME']) if gpg_engine.version.nil? $stderr.puts "Error: The binary you specified doesn't provide a gpg-version." exit 1 end end end def self.sufficient_gpg_version?(required) Gem::Version.new(required) <= Gem::Version.new(gpg_engine.version) end def self.check_gpg_version if ! sufficient_gpg_version?('2.0') $stderr.puts "Error: GnuPG version >= 2.0 required.\nPlease install it and/or provide the path to the binary via the environment-variable GPGBIN.\nExample: GPGBIN=/opt/gpg2/bin/gpg ..." exit 1 end end def self.gpg_engine GPGME::Engine.info.find {|e| e.protocol == GPGME::PROTOCOL_OpenPGP } end def self.refresh_keys(keys) output = [] base_args = "--quiet --no-auto-check-trustdb --keyserver #{Conf.keyserver} --refresh-keys" keys.each do |key| args = "#{base_args} #{key.fingerprint}" err, gpgout, _ = gpgcli(args) gpgout = filter_gpgcli_output(gpgout) output << filter_gpgcli_output(err) # Add any gpgkeys-message (gpg 2.0 writes those messages to stdout). # Those could e.g. report a failure to connect to the keyserver. output << gpgout.select { |line| line.match(/^gpgkeys: .*$/) } import_stats = translate_import_data(gpgout) if import_stats.present? output << I18n.t("key_updated", { fingerprint: key.fingerprint, states: import_stats.join(', ') }) end sleep rand(1.0..5.0) end GPGME::Ctx.gpgcli("--check-trustdb") output.flatten.uniq.join end def self.translate_import_data(gpgoutput) result = [] import_ok = gpgoutput.grep(/IMPORT_OK/).first return result if import_ok.blank? import_status = import_ok.split(/\s/).slice(2).to_i return result if import_status.zero? # TODO: Raise alarm if new key is found? IMPORT_FLAGS.each do |text, int| if (import_status & int) > 0 result << I18n.t("import_states.#{text}") end end result end # Unfortunately we can't distinguish between a failure to connect the # keyserver, and a failure to find the key on the server. So we try to # filter misleading errors to check if there are any to be reported. def self.filter_gpgcli_output(strings) strings.reject do |line| line.chomp == 'gpg: keyserver refresh failed: No data' || line.match(/^gpgkeys: key .* not found on keyserver/) || line.match(/^gpg: refreshing /) || line.match(/^gpg: requesting key /) || line.match(/^gpg: no valid OpenPGP data found/) end end def self.gpgcli(args) exitcode = -1 errors = [] output = [] base_cmd = gpg_engine.file_name base_args = "--no-greeting --no-permission-warning --quiet --armor --trust-model always --no-tty --command-fd 0 --status-fd 1" cmd = [base_cmd, base_args, args].flatten.join(' ') Open3.popen3(cmd) do |stdin, stdout, stderr, thread| if block_given? output = yield(stdin, stdout, stderr) else output = stdout.readlines end stdin.close errors = stderr.readlines exitcode = thread.value.exitstatus end [errors, output, exitcode] rescue Errno::ENOENT raise 'Need gpg in $PATH or in $GPGBIN' end def self.gpgcli_expect(args) gpgcli(args) do |stdin, stdout, stderr| counter = 0 while line = stdout.gets rescue nil counter += 1 if counter > 1042 return "Too many input-lines from gpg, something went wrong" end output, error = yield(line.chomp) if output == false return error elsif output stdin.puts output end end end end def self.spawn_daemon(name, args) delete_daemon_socket(name) cmd = "#{name} #{args} --daemon > /dev/null 2>&1" if ! system(cmd) return [false, "#{name} exited with code #{$?}"] end end def self.delete_daemon_socket(name) path = File.join(ENV["GNUPGHOME"], "S.#{name}") if File.exist?(path) File.delete(path) end end end end schleuder-3.0.1/lib/schleuder/gpgme/import_status.rb000066400000000000000000000014421304235634100225600ustar00rootroot00000000000000module GPGME class ImportStatus attr_reader :action # Unfortunately in initialize() @status and @result are not yet intialized. def set_action @action ||= if self.status > 0 'imported' elsif self.result == 0 'unchanged' else # An error happened. # TODO: Give details by going through the list of errors in # "gpg-errors.h" and find out which is present here. 'not imported' end self end # Force encoding, some databases save "ASCII-8BIT" as binary data. alias_method :orig_fingerprint, :fingerprint def fingerprint orig_fingerprint.encode(Encoding::US_ASCII) end end end schleuder-3.0.1/lib/schleuder/gpgme/key.rb000066400000000000000000000117331304235634100204370ustar00rootroot00000000000000module GPGME class Key # Overwrite to specify the full fingerprint instead of the short key-ID. def to_s primary_subkey = subkeys[0] s = sprintf("%s %4d%s/%s %s\n", primary_subkey.secret? ? 'sec' : 'pub', primary_subkey.length, primary_subkey.pubkey_algo_letter, primary_subkey.fingerprint, primary_subkey.timestamp.strftime('%Y-%m-%d')) uids.each do |user_id| s << "uid\t\t#{user_id.name} <#{user_id.email}>\n" end subkeys.each do |subkey| s << subkey.to_s end s end def armored "#{self.to_s}\n\n#{export(armor: true).read}" end # Force encoding, some databases save "ASCII-8BIT" as binary data. alias_method :orig_fingerprint, :fingerprint def fingerprint orig_fingerprint.encode(Encoding::US_ASCII) end def usable? usability_issue.blank? end def usability_issue if trust.present? trust elsif ! usable_for?(:encrypt) "not capable of encryption" else nil end end def set_primary_uid(email) # We rely on the order of UIDs here. Seems to work. index = self.uids.map(&:email).index(email) uid_number = index + 1 primary_set = false args = "--edit-key '#{self.fingerprint}' #{uid_number}" errors, _ = GPGME::Ctx.gpgcli_expect(args) do |line| case line.chomp when /keyedit.prompt/ if ! primary_set primary_set = true "primary" else "save" end else nil end end errors.join end def adduid(uid, email) # This block can be deleted once we cease to support gnupg 2.0. if ! GPGME::Ctx.sufficient_gpg_version?('2.1.4') return adduid_expect(uid, email) end # Specifying the key via fingerprint apparently doesn't work. errors, _ = GPGME::Ctx.gpgcli("--quick-adduid #{uid} '#{uid} <#{email}>'") errors.join end # This method can be deleted once we cease to support gnupg 2.0. def adduid_expect(uid, email) args = "--allow-freeform-uid --edit-key '#{self.fingerprint}' adduid" errors, _ = GPGME::Ctx.gpgcli_expect(args) do |line| case line.chomp when /keygen.name/ uid when /keygen.email/ email when /keygen.comment/ '' when /keyedit.prompt/ "save" else nil end end errors.join end def clearpassphrase(oldpw) # This block can be deleted once we cease to support gnupg 2.0. if ! GPGME::Ctx.sufficient_gpg_version?('2.1.0') return clearpassphrase_v20(oldpw) end oldpw_given = false # Don't use '--passwd', it claims to fail (even though it factually doesn't). args = "--pinentry-mode loopback --edit-key '#{self.fingerprint}' passwd" errors, _, exitcode = GPGME::Ctx.gpgcli_expect(args) do |line| case line when /passphrase.enter/ if ! oldpw_given oldpw_given = true oldpw else "" end when /BAD_PASSPHRASE/ [false, 'bad passphrase'] when /change_passwd.empty.okay/ 'y' when /keyedit.prompt/ "save" else nil end end # Only show errors if something apparently went wrong. Otherwise we might # leak useless strings from gpg and make the caller report errors even # though this method succeeded. if exitcode > 0 errors.join else nil end end # This method can be deleted once we cease to support gnupg 2.0. def clearpassphrase_v20(oldpw) start_gpg_agent(oldpw) # Don't use '--passwd', it claims to fail (even though it factually doesn't). errors, _, exitcode = GPGME::Ctx.gpgcli_expect("--edit-key '#{self.fingerprint}' passwd") do |line| case line when /BAD_PASSPHRASE/ [false, 'bad passphrase'] when /change_passwd.empty.okay/ 'y' when /keyedit.prompt/ "save" else nil end end stop_gpg_agent # Only show errors if something apparently went wrong. Otherwise we might # leak useless strings from gpg and make the caller report errors even # though this method succeeded. if exitcode > 0 errors.join else nil end end # This method can be deleted once we cease to support gnupg 2.0. def stop_gpg_agent # gpg-agent terminates itself if its socket goes away. GPGME::Ctx.delete_daemon_socket('gpg-agent') end def start_gpg_agent(oldpw) ENV['PINENTRY_USER_DATA'] = oldpw pinentry = File.join(ENV['SCHLEUDER_ROOT'], 'bin', 'pinentry-clearpassphrase') GPGME::Ctx.spawn_daemon('gpg-agent', "--use-standard-socket --pinentry-program #{pinentry}") end end end schleuder-3.0.1/lib/schleuder/gpgme/sub_key.rb000066400000000000000000000005241304235634100213040ustar00rootroot00000000000000module GPGME class SubKey # Overwrite to specify the full fingerprint instead of the short key-ID. def to_s sprintf("%s %4d%s/%s %s\n", secret? ? 'ssc' : 'sub', length, pubkey_algo_letter, fingerprint, timestamp.strftime('%Y-%m-%d')) end end end schleuder-3.0.1/lib/schleuder/list.rb000066400000000000000000000200721304235634100175170ustar00rootroot00000000000000module Schleuder class List < ActiveRecord::Base has_many :subscriptions, dependent: :destroy before_destroy :delete_listdirs serialize :headers_to_meta, JSON serialize :bounces_drop_on_headers, JSON serialize :keywords_admin_only, JSON serialize :keywords_admin_notify, JSON validates :email, presence: true, uniqueness: true, email: true validates :fingerprint, presence: true, fingerprint: true validates :send_encrypted_only, :receive_encrypted_only, :receive_signed_only, :receive_authenticated_only, :receive_from_subscribed_emailaddresses_only, :receive_admin_only, :keep_msgid, :bounces_drop_all, :bounces_notify_admins, :include_list_headers, :include_openpgp_header, :forward_all_incoming_to_admins, boolean: true validates_each :headers_to_meta, :keywords_admin_only, :keywords_admin_notify do |record, attrib, value| value.each do |word| if word !~ /\A[a-z_-]+\z/i record.errors.add(attrib, I18n.t("errors.invalid_characters")) end end end validates_each :bounces_drop_on_headers do |record, attrib, value| value.each do |key, val| if key.to_s !~ /\A[a-z-]+\z/i || val.to_s !~ /\A[[:graph:]]+\z/i record.errors.add(attrib, I18n.t("errors.invalid_characters")) end end end validates :subject_prefix, :subject_prefix_in, :subject_prefix_out, no_line_breaks: true validates :openpgp_header_preference, presence: true, inclusion: { in: %w(sign encrypt signencrypt unprotected none), } validates :max_message_size_kb, :logfiles_to_keep, greater_than_zero: true validates :log_level, presence: true, inclusion: { in: %w(debug info warn error), } validates :language, presence: true, inclusion: { # TODO: find out why we break translations and available_locales if we use I18n.available_locales here. in: %w(de en), } validates :public_footer, allow_blank: true, format: { with: /\A[[:graph:]\s]*\z/i, } def self.configurable_attributes @configurable_attributes ||= begin all = self.validators.map(&:attributes).flatten.uniq.compact.sort all - [:email, :fingerprint] end end def logfile @logfile ||= File.join(Conf.listlogs_dir, self.email.split('@').reverse, 'list.log') end def logger @logger ||= Listlogger.new(self) end def to_s email end def admins subscriptions.where(admin: true) end def key(fingerprint=self.fingerprint) keys(fingerprint).first end def secret_key gpg.keys(self.fingerprint, true).first end def keys(identifier='') gpg.keys(identifier) end def keys_by_email(address) keys("<#{address}>") end def import_key(importable) gpg.keyimport(GPGME::Data.new(importable)) end def delete_key(fingerprint) if key = gpg.keys(fingerprint).first key.delete! true else false end end def export_key(fingerprint=self.fingerprint) key = keys(fingerprint).first if key.blank? return false end key.armored end def check_keys now = Time.now checkdate = now + (60 * 60 * 24 * 14) # two weeks unusable = [] expiring = [] keys.each do |key| expiry = key.subkeys.first.expires if expiry && expiry > now && expiry < checkdate # key expires in the near future expdays = ((expiry - now)/86400).to_i expiring << [key, expdays] end if ! key.usable? unusable << [key, key.usability_issue] end end text = '' expiring.each do |key,days| text << I18n.t('key_expires', { days: days, fingerprint: key.fingerprint, email: key.email }) end unusable.each do |key,usability_issue| text << I18n.t('key_unusable', { usability_issue: usability_issue, fingerprint: key.fingerprint, email: key.email }) end text end def refresh_keys GPGME::Ctx.refresh_keys(self.keys) end def self.by_recipient(recipient) listname = recipient.gsub(/-(sendkey|request|owner|bounce)@/, '@') where(email: listname).first end def sendkey_address @sendkey_address ||= email.gsub('@', '-sendkey@') end def request_address @request_address ||= email.gsub('@', '-request@') end def owner_address @owner_address ||= email.gsub('@', '-owner@') end def bounce_address @bounce_address ||= email.gsub('@', '-bounce@') end def gpg @gpg_ctx ||= begin # TODO: figure out why set it again... # Set GNUPGHOME when list is created. set_gnupg_home GPGME::Ctx.new armor: true end end # TODO: place this somewhere sensible. # Call cleanup when script finishes. #Signal.trap(0, proc { @list.cleanup }) def cleanup if @gpg_agent_pid Process.kill('TERM', @gpg_agent_pid.to_i) end rescue => e $stderr.puts "Failed to kill gpg-agent: #{e}" end def gpg_sign_options {sign: true, sign_as: self.fingerprint} end def fingerprint=(arg) # Strip whitespace from incoming arg. if arg write_attribute(:fingerprint, arg.gsub(/\s*/, '').chomp) end end def self.listdir(listname) File.join( Conf.lists_dir, listname.split('@').reverse ) end def listdir @listdir ||= self.class.listdir(self.email) end def subscribe(email, fingerprint=nil, adminflag=false, deliveryflag=true) # Ensure we have true or false as values for these two attributes. admin = adminflag.to_s == 'true' delivery_enabled = deliveryflag.to_s != 'false' sub = Subscription.new( list_id: self.id, email: email, fingerprint: fingerprint, admin: admin, delivery_enabled: delivery_enabled ) sub.save sub end def unsubscribe(email, delete_key=false) sub = subscriptions.where(email: email).first if sub.blank? false end if ! sub.destroy return sub end if delete_key sub.delete_key end end def keywords_admin_notify Array(read_attribute(:keywords_admin_notify)) end def keywords_admin_only Array(read_attribute(:keywords_admin_only)) end def admin_only?(keyword) keywords_admin_only.include?(keyword) end def from_admin?(mail) return false if ! mail.was_validly_signed? admins.find do |admin| admin.fingerprint == mail.signing_key.fingerprint end.presence || false end def set_attribute(attrib, value) self.send("#{attrib}=", value) end private def set_gnupg_home ENV['GNUPGHOME'] = listdir end def delete_listdirs if File.exists?(self.listdir) FileUtils.rm_rf(self.listdir, secure: true) Schleuder.logger.info "Deleted #{self.listdir}" end # If listlogs_dir is different from lists_dir, the logfile still exists # and needs to be deleted, too. logfile_dir = File.dirname(self.logfile) if File.exists?(logfile_dir) FileUtils.rm_rf(logfile_dir, secure: true) Schleuder.logger.info "Deleted #{logfile_dir}" end true rescue => exc # Don't use list-logger here — if the list-dir isn't present we can't log to it! Schleuder.logger.error "Error while deleting listdir: #{exc}" return false end end end schleuder-3.0.1/lib/schleuder/list_builder.rb000066400000000000000000000101411304235634100212210ustar00rootroot00000000000000module Schleuder class ListBuilder def initialize(list_attributes, adminemail=nil, adminkey=nil) @list_attributes = list_attributes.with_indifferent_access @listname = list_attributes[:email] @fingerprint = list_attributes[:fingerprint] @adminemail = adminemail @adminkey = adminkey end def read_default_settings hash = YAML.load_file(ENV['SCHLEUDER_LIST_DEFAULTS']) if ! hash.kind_of?(Hash) raise Errors::LoadingListSettingsFailed.new end hash rescue Psych::SyntaxError raise Errors::LoadingListSettingsFailed.new end def run Schleuder.logger.info "Building new list" if @listname.blank? || ! @listname.match(Conf::EMAIL_REGEXP) return [nil, {'email' => ["'#{@listname}' is not a valid email address"]}] end settings = read_default_settings.merge(@list_attributes) list = List.new(settings) @list_dir = list.listdir create_or_test_dir(@list_dir) # In case listlogs_dir != lists_dir we have to create the basedir of the # list's log-file. create_or_test_dir(File.dirname(list.logfile)) if list.fingerprint.blank? list_key = gpg.keys("<#{list.email}>").first if list_key.nil? list_key = create_key(list) end list.fingerprint = list_key.fingerprint end if ! list.valid? return list end list.save! if @adminkey.present? import_result = list.import_key(@adminkey) # Get the fingerprint of the imported key if it was exactly one. If it # was imported or was already present doesn't matter. if import_result.considered == 1 admin_fpr = import_result.imports.first.fpr end end if @adminemail.present? # Try if we can find the admin-key "manually". Maybe it's present # in the keyring aleady. if admin_fpr.blank? admin_key = list.keys_by_email(@adminemail).first if admin_key.present? admin_fpr = admin_key.fingerprint end end sub = list.subscribe(@adminemail, admin_fpr, true) if sub.errors.present? raise ActiveModelError.new(sub.errors) end end list end def gpg @gpg_ctx ||= begin ENV["GNUPGHOME"] = @list_dir GPGME::Ctx.new end end def create_key(list) Schleuder.logger.info "Generating key-pair, this could take a while..." gpg.generate_key(key_params(list)) # Get key without knowing the fingerprint yet. keys = list.keys_by_email(@listname) if keys.empty? raise Errors::KeyGenerationFailed.new(@list_dir, @listname) elsif keys.size > 1 raise Errors::TooManyKeys.new(@list_dir, @listname) else adduids(list, keys.first) end keys.first end def adduids(list, key) # Add UIDs for -owner and -request. [list.request_address, list.owner_address].each do |address| err = key.adduid(list.email, address) if err.present? raise err end end # Go through list.key() to re-fetch the key from the keyring, otherwise # we don't see the new UIDs. errors = list.key.set_primary_uid(list.email) if errors.present? raise errors end rescue => exc raise Errors::KeyAdduidFailed.new(exc.to_s) end def key_params(list) " Key-Type: RSA Key-Length: 4096 Key-Usage: sign Subkey-Type: RSA Subkey-Length: 4096 Subkey-Usage: encrypt Name-Real: #{list.email} Name-Email: #{list.email} Expire-Date: 0 %no-protection " end def create_or_test_dir(dir) if File.exists?(dir) if ! File.directory?(dir) raise Errors::ListdirProblem.new(dir, :not_a_directory) end if ! File.writable?(dir) raise Errors::ListdirProblem.new(dir, :not_writable) end else FileUtils.mkdir_p(dir) end end end end schleuder-3.0.1/lib/schleuder/listlogger.rb000066400000000000000000000017261304235634100207240ustar00rootroot00000000000000module Schleuder class Listlogger < ::Logger include LoggerNotifications def initialize(list) super(list.logfile, 'daily') @from = list.email @list = list @adminaddresses = list.admins.map { |sub| [sub.email, sub.key] } @level = ::Logger.const_get(list.log_level.upcase) remove_old_logfiles(list) end # Logger rotates but doesn't delete older files, so we're helping # ourselves. def remove_old_logfiles(list) logfiles_to_keep = list.logfiles_to_keep.to_i if logfiles_to_keep < 1 logfiles_to_keep = list.class.column_defaults['logfiles_to_keep'] end suffix_now = Time.now.strftime("%Y%m%d").to_i del_older_than = suffix_now - logfiles_to_keep Pathname.glob("#{list.logfile}.????????").each do |file| if file.basename.to_s.match(/\.([0-9]{8})$/) if del_older_than.to_i >= $1.to_i file.unlink end end end end end end schleuder-3.0.1/lib/schleuder/logger.rb000066400000000000000000000010411304235634100200160ustar00rootroot00000000000000module Schleuder def logger @logger ||= Logger.new end module_function :logger class Logger < Syslog::Logger include LoggerNotifications def initialize if RUBY_VERSION.to_f < 2.1 super('Schleuder') else super('Schleuder', Syslog::LOG_MAIL) end # We need some sender-address different from the superadmin-address. @from = "#{`whoami`.chomp}@#{`hostname`.chomp}" @adminaddresses = Conf.superadmin @level = ::Logger.const_get(Conf.log_level.upcase) end end end schleuder-3.0.1/lib/schleuder/logger_notifications.rb000066400000000000000000000031311304235634100227510ustar00rootroot00000000000000module Schleuder module LoggerNotifications def adminaddresses @adminaddresses.presence || Conf.superadmin.presence || 'root@localhost' end def error(string) super(string) notify_admin(string) end def fatal(string, original_message=nil) super(string.to_s + append_original_message(original_message)) notify_admin(string, original_message) end def notify_admin(string, original_message=nil, subject='Error') # Minimize using other classes here, we don't know what caused the error. Array(adminaddresses).each do |address, key| mail = Mail.new mail.from = @from mail.to = address mail.subject = subject msgpart = Mail::Part.new msgpart.charset = 'UTF-8' msgpart.body = string.to_s mail.add_part msgpart if original_message orig_part = Mail::Part.new orig_part.content_type = 'message/rfc822' orig_part.content_description = 'The originally incoming message' orig_part.body = original_message.to_s mail.add_part orig_part end if @list.present? gpg_opts = @list.gpg_sign_options if key.present? && key.usable? gpg_opts.merge!(encrypt: true, keys: { address => key.fingerprint }) end mail.gpg gpg_opts end mail.deliver end true end private def append_original_message(original_message) if original_message "\n\nOriginal message:\n\n#{original_message.to_s}" else '' end end end end schleuder-3.0.1/lib/schleuder/mail/000077500000000000000000000000001304235634100171405ustar00rootroot00000000000000schleuder-3.0.1/lib/schleuder/mail/message.rb000066400000000000000000000256331304235634100211220ustar00rootroot00000000000000module Mail # TODO: Test if subclassing breaks integration of mail-gpg. class Message attr_accessor :recipient attr_accessor :original_message attr_accessor :list # TODO: This should be in initialize(), but I couldn't understand the # strange errors about wrong number of arguments when overriding # Message#initialize. def setup(recipient, list) if self.encrypted? new = self.decrypt(verify: true) ## Work around a bug in mail-gpg: when decrypting pgp/mime the ## Date-header is not copied. #new.date ||= self.date # Test if there's a signed multipart inside the ciphertext # ("encapsulated" format of pgp/mime). if new.signed? new = new.verify end elsif self.signed? new = self.verify else new = self end new.list = list new.gpg list.gpg_sign_options new.original_message = self.dup.freeze new.recipient = recipient new end def clean_copy(with_pseudoheaders=false) clean = Mail.new clean.list = self.list clean.gpg self.list.gpg_sign_options clean.from = list.email clean.subject = self.subject clean.add_msgids(list, self) clean.add_list_headers(list) clean.add_openpgp_headers(list) if with_pseudoheaders new_part = Mail::Part.new new_part.body = self.pseudoheaders(list) clean.add_part new_part end # Attach body or mime-parts, respectively. if self.multipart? self.parts.each do |part| clean.add_part Mail::Part.new(part) end else # Don't use self.to_s here — that includes all the headers we *don't* # want to copy. new_part = Mail::Part.new new_part.body = self.body.to_s clean.add_part Mail::Part.new(new_part) end clean end def prepend_part(part) self.add_part(part) self.parts.unshift(parts.delete_at(parts.size-1)) end def add_footer! # Add public_footer unless it's empty?. if self.list.present? && ! self.list.public_footer.to_s.strip.empty? footer_part = Mail::Part.new footer_part.body = list.public_footer.strip if parts.size == 1 && parts.first.mime_type == 'multipart/mixed' && parts.first.parts.size == 1 && parts.first.parts.first.mime_type == 'text/plain' self.parts.first.add_part footer_part else self.add_part footer_part end end end def was_encrypted? Mail::Gpg.encrypted?(original_message) end def signature case signatures.size when 0 if multipart? signature_multipart_inline else nil end when 1 signatures.first else raise "Multiple signatures found! Cannot handle!" end end def was_validly_signed? signature.present? && signature.valid? && signer.present? end def signer if signing_key.present? list.subscriptions.where(fingerprint: signing_key.fingerprint).first end end # The fingerprint of the signature might be the one of a sub-key, but the # subscription-assigned fingerprints are (should be) the ones of the # primary keys, so we need to look up the key. def signing_key if signature.present? @signing_key ||= list.keys(signature.fpr).first end end def reply_to_signer(output) reply = self.reply reply.body = Array(output).join("\n") self.signer.send_mail(reply) end def sendkey_request? @recipient.match(/-sendkey@/) end def to_owner? @recipient.match(/-owner@/) end def request? @recipient.match(/-request@/) end def bounce? @recipient.match(/-bounce@/) || # Empty Return-Path self.return_path.to_s == '<>' || # Auto-Submitted exists and does not equal 'no' ( self['Auto-Submitted'].present? && self['Auto-Submitted'].to_s.downcase != 'no' ) end def keywords return @keywords if @keywords part = first_plaintext_part if part.blank? return [] end @keywords = [] part.body = part.decoded.lines.map.with_index do |line, i| # Break after some lines to not run all the way through maybe huge emails. if i > 1000 break end # TODO: Find multiline arguments (add-key). Currently add-key has to # read the whole body and hope for the best. if line.match(/^x-([^: ]*)[: ]*(.*)/i) command = $1.strip.downcase arguments = $2.to_s.strip.downcase.split(/[,; ]{1,}/) @keywords << [command, arguments] nil else line end end.compact.join @keywords end def add_subject_prefix! _add_subject_prefix(nil) end def add_subject_prefix_in! _add_subject_prefix(:in) end def add_subject_prefix_out! _add_subject_prefix(:out) end def add_pseudoheader(key, value) @dynamic_pseudoheaders ||= [] @dynamic_pseudoheaders << make_pseudoheader(key, value) end def make_pseudoheader(key, value) "#{key.to_s.camelize}: #{value.to_s}" end def dynamic_pseudoheaders @dynamic_pseudoheaders || [] end def standard_pseudoheaders(list) if @standard_pseudoheaders.present? return @standard_pseudoheaders else @standard_pseudoheaders = [] end Array(list.headers_to_meta).each do |field| @standard_pseudoheaders << make_pseudoheader(field.to_s, self.header[field.to_s]) end # Careful to add information about the incoming signature. GPGME # throws exceptions if it doesn't know the key. if self.signature.present? # Some versions of gpgme return nil if the key is unknown, so we check # for that manually and provide our own fallback. (Calling # `signature.key` results in an EOFError in that case.) if signing_key.present? msg = signature.to_s else # TODO: I18n msg = "Unknown signature by unknown key 0x#{self.signature.fingerprint}" end else # TODO: I18n msg = "Unsigned" end @standard_pseudoheaders << make_pseudoheader(:sig, msg) # TODO: I18n @standard_pseudoheaders << make_pseudoheader( :enc, was_encrypted? ? 'Encrypted' : 'Unencrypted' ) @standard_pseudoheaders end def pseudoheaders(list) (standard_pseudoheaders(list) + dynamic_pseudoheaders).flatten.join("\n") + "\n" end def add_msgids(list, orig) if list.keep_msgid # Don't use `orig['in-reply-to']` here, because that sometimes fails to # parse the original value and then returns it without the # angle-brackets. self.message_id = clutch_anglebrackets(orig.message_id) self.in_reply_to = clutch_anglebrackets(orig.in_reply_to) self.references = clutch_anglebrackets(orig.references) end end def add_list_headers(list) if list.include_list_headers self['List-Id'] = "<#{list.email.gsub('@', '.')}>" self['List-Owner'] = " (Use list's public key)" self['List-Help'] = '' postmsg = if list.receive_admin_only "NO (Admins only)" elsif list.receive_authenticated_only " (Subscribers only)" else "" end self['List-Post'] = postmsg end end def add_openpgp_headers(list) if list.include_openpgp_header if list.openpgp_header_preference == 'none' pref = '' else pref = "preference=#{list.openpgp_header_preference}" # TODO: simplify. pref << ' (' if list.receive_admin_only pref << 'Only encrypted and signed emails by list-admins are accepted' elsif ! list.receive_authenticated_only if list.receive_encrypted_only && list.receive_signed_only pref << 'Only encrypted and signed emails are accepted' elsif list.receive_encrypted_only && ! list.receive_signed_only pref << 'Only encrypted emails are accepted' elsif ! list.receive_encrypted_only && list.receive_signed_only pref << 'Only signed emails are accepted' else pref << 'All kind of emails are accepted' end elsif list.receive_authenticated_only if list.receive_encrypted_only pref << 'Only encrypted and signed emails by subscribers are accepted' else pref << 'Only signed emails by subscribers are accepted' end else pref << 'All kind of emails are accepted' end pref << ')' end fingerprint = list.key.fingerprint comment = "(Send an email to #{list.sendkey_address} to receive the public-key)" self['OpenPGP'] = "id=0x#{fingerprint} #{comment}; #{pref}" end end def empty? if self.multipart? if self.parts.empty? return true else # Test parts recursively. E.g. Thunderbird with activated # memoryhole-headers send nested parts that might still be empty. return parts.inject(true) { |result, part| result && part.empty? } end else return self.body.empty? end end private def _add_subject_prefix(suffix) attrib = "subject_prefix" if suffix attrib << "_#{suffix}" end if ! self.list.respond_to?(attrib) return false end string = self.list.send(attrib).to_s.strip if ! string.empty? prefix = "#{string} " # Only insert prefix if it's not present already. if ! self.subject.include?(prefix) self.subject = "#{string} #{self.subject}" end end end # Looking for signatures in each part. They are not aggregated into the main part. # We only return the signature if all parts are validly signed by the same key. def signature_multipart_inline fingerprints = parts.map do |part| if part.signature_valid? part.signature.fpr else nil end end if fingerprints.uniq.size == 1 parts.first.signature else nil end end def first_plaintext_part(part=nil) part ||= self if part.multipart? first_plaintext_part(part.parts.first) elsif part.mime_type == 'text/plain' part else nil end end def clutch_anglebrackets(input) Array(input).map do |string| if string.first == '<' string else "<#{string}>" end end.join(' ') end end end schleuder-3.0.1/lib/schleuder/plugins/000077500000000000000000000000001304235634100176775ustar00rootroot00000000000000schleuder-3.0.1/lib/schleuder/plugins/key_management.rb000066400000000000000000000045561304235634100232220ustar00rootroot00000000000000module Schleuder module RequestPlugins def self.add_key(arguments, list, mail) out = [I18n.t('plugins.key_management.import_result')] if mail.has_attachments? results = self.import_keys_from_attachments(list, mail) else results = [self.import_key_from_body(list, mail)] end out << results.compact.collect(&:imports).flatten.map do |import_status| str = I18n.t("plugins.key_management.key_import_status.#{import_status.action}") "#{import_status.fpr}: #{str}" end end def self.delete_key(arguments, list, mail) arguments.map do |argument| # TODO: I18n if list.gpg.delete(argument) "Deleted: #{argument}." else "Not found: #{argument}." end end end def self.list_keys(arguments, list, mail) args = arguments.presence || [''] args.map do |argument| list.keys(argument).map do |key| key.to_s end end end def self.get_key(arguments, list, mail) arguments.map do |argument| list.export_key(argument) end end def self.fetch_key(arguments, list, mail) hkp = Hkp.new arguments.map do |argument| hkp.fetch_and_import(argument) end end def self.is_armored_key?(material) return false unless /^-----BEGIN PGP PUBLIC KEY BLOCK-----$/ =~ material return false unless /^-----END PGP PUBLIC KEY BLOCK-----$/ =~ material lines = material.split("\n").reject(&:empty?) # remove header lines.shift # remove tail lines.pop # verify the rest # TODO: verify length except for lasts lines? # headers according to https://tools.ietf.org/html/rfc4880#section-6.2 lines.map do |line| /\A((comment|version|messageid|hash|charset):.*|[0-9a-z\/=+]+)\Z/i =~ line end.all? end def self.import_keys_from_attachments(list, mail) mail.attachments.map do |attachment| material = attachment.body.to_s list.import_key(material) if self.is_armored_key?(material) end end def self.import_key_from_body(list, mail) if mail.parts.first.present? key_material = mail.parts.first.body.to_s else key_material = mail.body.to_s end list.import_key(key_material) if self.is_armored_key?(key_material) end end end schleuder-3.0.1/lib/schleuder/plugins/resend.rb000066400000000000000000000110221304235634100215000ustar00rootroot00000000000000module Schleuder module ListPlugins def self.resend(arguments, list, mail) resend_it(arguments, mail, false) end def self.resend_enc(arguments, list, mail) resend_encrypted_only(arguments, list, mail) end def self.resend_encrypted_only(arguments, list, mail) resend_it(arguments, mail, true) end def self.resend_cc(arguments, list, mail) resend_it_cc(arguments, mail, false) end def self.resend_cc_enc(arguments, list, mail) resend_cc_encrypted_only(arguments, list, mail) end def self.resend_cc_encrypted_only(arguments, list, mail) resend_it_cc(arguments, mail, true) end def self.resend_it_cc(arguments, mail, encrypted_only) recip_map = map_with_keys(mail, arguments, encrypted_only) # Only continue if all recipients are still here. if recip_map.size < arguments.size return end if do_resend(mail, recip_map, :cc, encrypted_only) mail.add_subject_prefix_out! end # Return nil to prevent any accidental output to be interpreted as an # error. nil end def self.resend_it(arguments, mail, encrypted_only) recip_map = map_with_keys(mail, arguments, encrypted_only) resent_stati = recip_map.map do |email, key| do_resend(mail, {email => key}, :to, encrypted_only) end if resent_stati.include?(true) # At least one message has been resent mail.add_subject_prefix_out! end # Return nil to prevent any accidental output to be interpreted as an # error. nil end def self.do_resend(mail, recipients_map, to_or_cc, encrypted_only) if recipients_map.empty? return end gpg_opts = make_gpg_opts(mail, recipients_map, encrypted_only) if gpg_opts == false return false end # Compose and send email new = mail.clean_copy new[to_or_cc] = recipients_map.keys new.add_footer! # `dup` gpg_opts because `deliver` changes their value and we need them # below to determine encryption! new.gpg gpg_opts.dup if new.deliver add_resent_headers(mail, recipients_map, to_or_cc, gpg_opts[:encrypt]) return true else add_error_header(mail, recipients_map) return false end rescue Net::SMTPFatalError => exc add_error_header(mail, recipients_map) logger.error "Error while sending: #{exc}" return false end def self.map_with_keys(mail, recipients, encrypted_only) Array(recipients).inject({}) do |hash, email| keys = mail.list.keys_by_email(email) case keys.size when 1 hash[email] = keys.first when 0 if encrypted_only # Don't add the email to the result to exclude it from the # recipients. add_keys_error(mail, email, keys.size) else hash[email] = '' end else # Always report this situation, regardless of sending or not. It's # bad and should be fixed. add_keys_error(mail, email, keys.size) if ! encrypted_only hash[email] = '' end end hash end end def self.make_gpg_opts(mail, recipients_map, encrypted_only) gpg_opts = mail.list.gpg_sign_options # Do all recipients have a key? if recipients_map.values.map(&:class).uniq == [GPGME::Key] gpg_opts.merge!(encrypt: true) elsif encrypted_only false end gpg_opts end def self.add_keys_error(mail, email, keys_size) mail.add_pseudoheader(:error, I18n.t("plugins.resend.not_resent_no_keys", email: email, num_keys: keys_size)) end def self.add_error_header(mail, recipients_map) mail.add_pseudoheader(:error, "Resending to #{recipients_map.keys.join(', ')} failed, please check the logs!") end def self.add_resent_headers(mail, recipients_map, to_or_cc, sent_encrypted) if sent_encrypted prefix = I18n.t('plugins.resend.encrypted_to') str = recipients_map.map do |email, key| "#{email} (#{key.fingerprint})" end.join(', ') else prefix = I18n.t('plugins.resend.unencrypted_to') str = recipients_map.keys.join(', ') end headername = resent_header_name(to_or_cc) mail.add_pseudoheader(headername, "#{prefix} #{str}") end def self.resent_header_name(to_or_cc) if to_or_cc.to_s == 'to' 'resent' else 'resent_cc' end end end end schleuder-3.0.1/lib/schleuder/plugins/sign_this.rb000066400000000000000000000031471304235634100222200ustar00rootroot00000000000000module Schleuder module RequestPlugins def self.sign_this(arguments, list, mail) if mail.parts.empty? && mail.body.to_s.present? # Single text/plain-output is handled by the plugin-runner well, we # don't need to take care of the reply. list.logger.debug "Clear-signing text/plain body" clearsign(mail) else # Here we need to send our reply manually because we're sending # attachments. # TODO: Maybe move this ability into the plugin-runner? out = multipart(mail.reply, list, mail) out.body = I18n.t('plugins.signatures_attached') list.logger.info "Replying directly to sender" mail.signer.send_mail(out) list.logger.info "Exiting." exit end end def self.multipart(out, list, mail) list.logger.debug "Signing each attachment's body" mail.parts.each do |part| next if part.body.to_s.strip.blank? file_basename = part.filename.presence || Digest::SHA256.hexdigest(part.body.to_s) list.logger.debug "Signing #{file_basename}" filename = "#{file_basename}.sig" out.add_file({ filename: filename, content: detachsign(part.body.to_s) }) out.attachments[filename].content_description = "OpenPGP signature for '#{file_basename}'" end out end def self.detachsign(thing) crypto.sign(thing, mode: GPGME::SIG_MODE_DETACH).to_s end def self.clearsign(mail) crypto.clearsign(mail.body.to_s).to_s end def self.crypto @crypto ||= GPGME::Crypto.new end end end schleuder-3.0.1/lib/schleuder/plugins/subscription_management.rb000066400000000000000000000070351304235634100251510ustar00rootroot00000000000000module Schleuder module RequestPlugins def self.subscribe(arguments, list, mail) email = arguments.shift fingerprint = arguments.shift if fingerprint.present? fingerprint.sub!(/^0x/, '') end adminflag = arguments.shift deliveryflag = arguments.shift sub = list.subscribe(email, fingerprint, adminflag, deliveryflag) if sub.persisted? I18n.t( "plugins.subscription_management.subscribed", email: sub.email, fingerprint: sub.fingerprint, admin: sub.admin, delivery_enabled: sub.delivery_enabled ) else I18n.t( "plugins.subscription_management.subscribing_failed", email: sub.email, errors: sub.errors.full_messages.join(".\n") ) end end def self.unsubscribe(arguments, list, mail) # If no address was given we unsubscribe the sender. email = arguments.first.presence || mail.signer.email # TODO: May signers have multiple UIDs? We don't match those currently. if ! list.from_admin?(mail) && email != mail.signer.email # Only admins may unsubscribe others. return I18n.t( "plugins.subscription_management.forbidden", email: email ) end sub = list.subscriptions.where(email: email).first if sub.blank? return I18n.t( "plugins.subscription_management.is_not_subscribed", email: email ) end if res = sub.delete I18n.t( "plugins.subscription_management.unsubscribed", email: email ) else I18n.t( "plugins.subscription_management.unsubscribing_failed", email: email, error: res.errors.to_a ) end end def self.list_subscriptions(arguments, list, mail) out = [ "#{I18n.t("plugins.subscription_management.list_of_subscriptions")}:" ] subs = if arguments.blank? list.subscriptions.all.to_a else arguments.map do |argument| list.subscriptions.where("email like ?", "%#{argument}%").to_a end.flatten end out << subs.map do |subscription| # Fingerprints are at most 40 characters long, and lines shouldn't # exceed 80 characters if possible. s = subscription.email if subscription.fingerprint.present? s << "\t0x#{subscription.fingerprint}" end if ! subscription.delivery_enabled? s << "\tDelivery disabled!" end s end end def self.set_fingerprint(arguments, list, mail) email = if list.admin?(mail.signer.email) arguments.first else # TODO: send error message if signer tried to set another # fingerprint than hir own. mail.signer.email end sub = list.subscriptions.where(email: mail.signer.email) if sub.blank? return I18n.t( "plugins.subscription_management.is_not_subscribed", email: email ) end sub.fingerprint = arguments.last if sub.save I18n.t( "plugins.subscription_management.fingerprint_set", email: email, fingerprint: sub.fingerprint ) else I18n.t( "plugins.subscription_management.setting_fingerprint_failed", email: email, fingerprint: arguments.last, error: sub.errors.to_a.join("\n") ) end end end end schleuder-3.0.1/lib/schleuder/plugins_runner.rb000066400000000000000000000051651304235634100216240ustar00rootroot00000000000000module Schleuder module Plugins class Runner def self.run(list, mail) list.logger.debug "Starting plugins runner" @list = list @mail = mail setup output = [] if @mail.request? @plugin_module = RequestPlugins else @plugin_module = ListPlugins end check_listname_keyword mail.keywords.each do |keyword, arguments| @list.logger.debug "Running keyword '#{keyword}'" if @list.admin_only?(keyword) && ! @list.from_admin?(@mail) @list.logger.debug "Error: Keyword is admin-only, sent by non-admin" output << Schleuder::Errors::KeywordAdminOnly.new(keyword).to_s next end output << run_plugin(keyword, arguments) end output end def self.run_plugin(keyword, arguments) command = keyword.gsub('-', '_') if command == 'listname' return nil elsif ! @plugin_module.respond_to?(command) return I18n.t('plugins.unknown_keyword', keyword: keyword) else out = @plugin_module.send(command, arguments, @list, @mail) response = Array(out).flatten.join("\n\n") if @list.keywords_admin_notify.include?(keyword) explanation = I18n.t('plugins.keyword_admin_notify', signer: @mail.signer, keyword: keyword, response: response ) @list.logger.notify_admin("#{explanation}\n\n#{response}\n", nil, 'Notice') end return response end rescue => exc # Log to system, this information is probably more useful for # system-admins than for list-admins. Schleuder.logger.error(exc.message_with_backtrace) I18n.t("plugins.plugin_failed", keyword: keyword) end def self.setup @list.logger.debug "Loading plugins" Dir["#{Schleuder::Conf.plugins_dir}/*.rb"].each do |file| require file end end def self.check_listname_keyword return nil if @mail.keywords.blank? listname_kw = @mail.keywords.assoc('listname') if listname_kw.blank? @mail.reply_to_signer I18n.t(:missing_listname_keyword_error) exit else listname_args = listname_kw.last if ! [@list.email, @list.request_address].include?(listname_args.first) @mail.reply_to_signer I18n.t(:wrong_listname_keyword_error) exit end end end end end end schleuder-3.0.1/lib/schleuder/runner.rb000066400000000000000000000100231304235634100200500ustar00rootroot00000000000000module Schleuder class Runner def run(msg, recipient) error = setup_list(recipient) return error if error logger.info "Parsing incoming email." begin # This decrypts, verifies, etc. @mail = Mail.new(msg) @mail = @mail.setup(recipient, list) rescue GPGME::Error::DecryptFailed logger.warn "Decryption of incoming message failed." return Errors::DecryptionFailed.new(list) end # Filters error = Filters::Runner.run(list, @mail) if error if list.bounces_notify_admins? text = "#{I18n.t('.bounces_notify_admins')}\n\n#{error}" # TODO: raw_source is mostly blank? logger.notify_admin text, @mail.original_message, I18n.t('notice') end return error end if ! @mail.was_validly_signed? logger.debug "Message was not validly signed, adding subject_prefix_in" @mail.add_subject_prefix_in! end if ! @mail.was_encrypted? logger.debug "Message was not encrypted, skipping plugins" elsif @mail.was_validly_signed? # Plugins logger.debug "Message was encrypted and validly signed" output = Plugins::Runner.run(list, @mail).compact # Any output will be treated as error-message. Text meant for users # should have been put into the mail by the plugin. output.each do |something| @mail.add_pseudoheader(:error, something.to_s) if something.present? end end # Don't send empty messages over the list. if @mail.empty? logger.info "Message found empty, not sending it to list." return Errors::MessageEmpty.new(@list) end logger.debug "Adding subject_prefix" @mail.add_subject_prefix! # Subscriptions send_to_subscriptions nil end private def send_to_subscriptions logger.debug "Sending to subscriptions." logger.debug "Creating clean copy of message" new = @mail.clean_copy(true) list.subscriptions.each do |subscription| begin subscription.send_mail(new) rescue => exc msg = I18n.t('errors.delivery_error', { email: subscription.email, error: exc.to_s }) logger.error msg end end end def list @list end def logger list.present? && list.logger || Schleuder.logger end def log_and_return(error) Schleuder.logger.error(error) error end def setup_list(recipient) return @list if @list logger.info "Loading list '#{recipient}'" if ! @list = List.by_recipient(recipient) return log_and_return(Errors::ListNotFound.new(recipient)) end # Check neccessary permissions of crucial files. if ! File.exist?(@list.listdir) return log_and_return(Errors::ListdirProblem.new(@list.listdir, :not_existing)) elsif ! File.directory?(@list.listdir) return log_and_return(Errors::ListdirProblem.new(@list.listdir, :not_a_directory)) elsif ! File.readable?(@list.listdir) return log_and_return(Errors::ListdirProblem.new(@list.listdir, :not_readable)) elsif ! File.writable?(@list.listdir) return log_and_return(Errors::ListdirProblem.new(@list.listdir, :not_writable)) else if File.exist?(@list.logfile) && ! File.writable?(@list.logfile) return log_and_return(Errors::ListdirProblem.new(@list.logfile, :not_writable)) end end # Check basic sanity of list. %w[fingerprint key secret_key admins].each do |attrib| if @list.send(attrib).blank? return log_and_return(Errors::ListPropertyMissing.new(attrib)) end end # Set locale if I18n.available_locales.include?(@list.language.to_sym) I18n.locale = @list.language.to_sym end # This cannot be put in List, as Mail wouldn't know it then. logger.debug "Setting GNUPGHOME to #{@list.listdir}" ENV['GNUPGHOME'] = @list.listdir nil end end end schleuder-3.0.1/lib/schleuder/subscription.rb000066400000000000000000000053541304235634100212760ustar00rootroot00000000000000module Schleuder class Subscription < ActiveRecord::Base belongs_to :list validates :list_id, inclusion: { in: -> (id) { List.pluck(:id) }, message: "must refer to an existing list" } validates :email, presence: true, email: true validates :fingerprint, allow_blank: true, fingerprint: true validates :delivery_enabled, :admin, boolean: true default_scope { order(:email) } def to_s email end def self.configurable_attributes [:fingerprint, :admin, :delivery_enabled] end def fingerprint=(arg) # Strip whitespace from incoming arg. write_attribute(:fingerprint, arg.to_s.gsub(/\s*/, '').chomp) end def key # TODO: make key-related methods a concern, so we don't have to go # through the list and neither re-implement the methods here. # Prefix '0x' to force GnuPG to match only hex-values, not UIDs. list.keys("0x#{self.fingerprint}").first end def send_mail(mail) list.logger.debug "Preparing sending to #{self.inspect}" if ! self.delivery_enabled list.logger.info "Not sending to #{self.email}: delivery is disabled." return false end mail = ensure_headers(mail) gpg_opts = self.list.gpg_sign_options if self.key.blank? if self.list.send_encrypted_only? notify_of_missed_message(:absent) return false else list.logger.warn "Sending plaintext because no key is present!" end elsif ! self.key.usable? if self.list.send_encrypted_only? notify_of_missed_message(key.usability_issue) return false else list.logger.warn "Sending plaintext because assigned key is #{key.usability_issue}!" end else gpg_opts.merge!(encrypt: true, keys: {self.email => "0x#{self.fingerprint}"}) end list.logger.info "Sending message to #{self.email}" mail.gpg gpg_opts mail.deliver end def ensure_headers(mail) mail.to = self.email mail.from = self.list.email mail.return_path = self.list.bounce_address mail end def notify_of_missed_message(reason) self.list.logger.warn "Not sending to #{self.email}: key is unusable because it is #{reason} and sending plain text not allowed" mail = ensure_headers(Mail.new) mail.subject = I18n.t('notice') mail.body = I18n.t("missed_message_due_to_unusable_key", list_email: self.list.email) + I18n.t('errors.signoff') mail.gpg self.list.gpg_sign_options mail.deliver end def admin? self.admin == true end def delete_key list.delete_key(self.fingerprint) end end end schleuder-3.0.1/lib/schleuder/validators/000077500000000000000000000000001304235634100203665ustar00rootroot00000000000000schleuder-3.0.1/lib/schleuder/validators/boolean_validator.rb000066400000000000000000000003401304235634100243740ustar00rootroot00000000000000class BooleanValidator < ActiveModel::EachValidator def validate_each(record, attribute, value) if ! [true, false].include?(value) record.errors.add(attribute, I18n.t("errors.must_be_boolean")) end end end schleuder-3.0.1/lib/schleuder/validators/email_validator.rb000066400000000000000000000003621304235634100240500ustar00rootroot00000000000000class EmailValidator < ActiveModel::EachValidator def validate_each(record, attribute, value) unless value =~ Conf::EMAIL_REGEXP record.errors[attribute] << (options[:message] || I18n.t("errors.invalid_email")) end end end schleuder-3.0.1/lib/schleuder/validators/fingerprint_validator.rb000066400000000000000000000003741304235634100253130ustar00rootroot00000000000000class FingerprintValidator < ActiveModel::EachValidator def validate_each(record, attribute, value) unless value =~ /\A[a-f0-9]+\z/i record.errors[attribute] << (options[:message] || I18n.t("errors.invalid_fingerprint")) end end end schleuder-3.0.1/lib/schleuder/validators/greater_than_zero_validator.rb000066400000000000000000000003431304235634100264620ustar00rootroot00000000000000class GreaterThanZeroValidator < ActiveModel::EachValidator def validate_each(record, attribute, value) if value.to_i == 0 record.errors.add(attribute, I18n.t("errors.must_be_greater_than_zero")) end end end schleuder-3.0.1/lib/schleuder/validators/no_line_breaks_validator.rb000066400000000000000000000003361304235634100257340ustar00rootroot00000000000000class NoLineBreaksValidator < ActiveModel::EachValidator def validate_each(record, attribute, value) if value.to_s.include?("\n") record.errors.add(attribute, I18n.t("errors.no_linebreaks") ) end end end schleuder-3.0.1/lib/schleuder/version.rb000066400000000000000000000000511304235634100202240ustar00rootroot00000000000000module Schleuder VERSION = '3.0.1' end schleuder-3.0.1/locales/000077500000000000000000000000001304235634100151145ustar00rootroot00000000000000schleuder-3.0.1/locales/de.yml000066400000000000000000000203501304235634100162270ustar00rootroot00000000000000de: errors: attributes: language: inclusion: "muss einem der folgenden Werte entsprechen: en, de" log_level: inclusion: "muss einem der folgenden Werte entsprechen: debug, info, warn, error" openpgp_header_preference: inclusion: "muss einem der folgenden Werte entsprechen: sign, encrypt, signencrypt, unprotected, none" public_footer: invalid: "enthält nicht druckbare Zeichen" invalid_email: "ist keine valide E-Mail-Adresse" invalid_fingerprint: "ist kein valider OpenPGP-Fingerabdruck" fingerprint_blank: 'Fingerabdruck der Liste ist nicht gesetzt, kann nicht arbeiten!' list_key_missing: 'Schlüssel der Liste nicht im Schlüsselring gefunden, kann nicht arbeiten!' list_secret_key_missing: 'Geheimer Schlüssel der Liste nicht im Schlüsselring gefunden, kann nicht arbeiten!' admins_missing: 'List hat keine Admins konfiguriert, kann nicht arbeiten!' fatalerror: | Es ist ein schwerwiegender Fehler aufgetreten. Administratoren wurden benachrichtigt. Bitte versuche es später noch ein Mal. signoff: | Freundliche Grüße, Dein Schleuder-System. decryption_failed: | Deine Email konnnte nicht entschlüsselt werden. Emails an diese Adresse müssen mit diesem Schlüssel verschlüsselt werden: %{key} Um den Schlüssel zugesandt zu bekommen sende eine Email an <%{sendkey_email}>. message_unsigned: Emails an diese Adresse müssen mit einem OpenPGP-Schlüssel signiert sein. message_signature_unknown: | Emails an diese Adresse müssen mit dem OpenPGP-Schlüssel signiert sein, der für dein Abo eingetragen ist. Wenn du nicht weisst, welcher Schlüssel das ist, frage die Administrator/innen. Die erreichst du per Email an <%{owner_email}>. (Vorzugsweise verschlüssele die Email mit dem Schlüssel dieser Adresse: %{list_fingerprint}). message_unencrypted: Emails an diese Adresse müssen OpenPGP-konform verschlüsselt sein. message_unauthenticated: Emails an diese Adresse müssen verschlüsselt und mit einem OpenPGP-Schlüssel signiert sein, der für ein Abo eingetragen ist. message_sender_not_subscribed: Nur Absender mit Abo dürfen Emails an diese Adresse schicken. message_not_from_admin: Nur Admins dürfen Emails an diese Adresse schicken. message_empty: | Deine Email enthielt keinen Text, daher wurde sie nicht über die Liste verteilt. Falls du ausschließlich Schlüsselwörter gesendet hast beachte, dass administrative Schlüsselwörter an die "request"-Adresse (<%{request_address}>) geschickt werden müssen um berücksichtigt zu werden. list_not_found: "Fehler: Keine Liste zu dieser Adresse gefunden: '%{email}'." no_linebreaks: "Darf keine Zeilenumbrüche enthalten" invalid_characters: "enthält ungültige Zeichen" invalid_listname: "Fehler: '%{email}' ist kein gültige Listen-Adresse." list_exists: Es existiert bereits eine Liste mit der Adresse '%{email}'. listdir_problem: message: "Problem mit dem Listen-Verzeichnis: '%{dir}' %{problem}." not_existing: existiert nicht not_a_directory: ist kein Verzeichnis not_empty: ist nicht leer not_writable: ist nicht beschreibbar not_readable: ist nicht lesbar keyword_admin_only: Das Schlüsselwort '%{keyword}' darf nur von Listen-Admins verwendet werden. key_generation_failed: Das Erzeugen des OpenPGP-Schlüsselpaares für %{listname} ist aus unbekannten Gründen fehlgeschlagen. Bitte prüfe das Listen-Verzeichnis ('%{listdir}') und die Log-Dateien. key_adduid_failed: "Das Hinzufügen einer User-ID zum OpenPGP-Schlüssel ist mit folgender Meldung fehlgeschlagen:\n%{errmsg}" too_many_keys: "Fehler: In %{listdir} existieren mehrere OpenPGP-Schlüssel für %{listname}. Bitte lösche alle bis auf einen." unknown_list_option: "Unbekannte Option in %{config_file}: '%{option}'." loading_list_settings_failed: "%{config_file} konnte nicht eingelesen werden, bitte Formatierung auf gültiges YAML prüfen." message_too_big: "Deine Email war zu groß. Erlaubt sind für diese Liste %{allowed_size}KB." must_be_boolean: "muss true oder false sein" must_be_greater_than_zero: "muss größer als null sein" file_not_found: "Die Datei existiert nicht: '%{file}'." not_pgp_mime: "Deine Email war nicht im pgp/mime-Format verschlüsselt." delivery_error: "Beim Versenden einer Email an %{email} ist der folgende Fehler aufgetreten: %{error}" plugins: unknown_keyword: Unbekanntes Schlüsselwort '%{keyword}'. plugin_failed: Das Schlüsselwort '%{keyword}' verursachte einen unbekannten Fehler. Die System-Administratoren wurden benachrichtigt. keyword_admin_notify: "%{signer} schickte das Schlüsselwort '%{keyword}' und erhielt dies als Antwort:" key_management: import_result: "Import-Ergebnis:" key_import_status: imported: importiert updated: aktualisiert unchanged: unverändert resend: not_resent_no_keys: Resending an <%{email}> fehlgeschlagen (%{num_keys} Schlüssel gefunden und unverschlüsseltes Senden verboten). encrypted_to: Verschlüsselt an unencrypted_to: Unverschlüsselt an subscription_management: forbidden: "Fehler: Du bist nicht berechtigt, das Abo für %{email} zu löschen." is_not_subscribed: Kein Abo für %{email} gefunden. unsubscribed: Abo für %{email} wurde gelöscht. unsubscribing_failed: | Abo für %{email} nicht gelöscht: %{errors} subscribed: | Abo für %{email} mit diesen Werten eingetragen: Fingerabdruck: %{fingerprint} Admin? %{admin} Email-Zustellung aktiv? %{delivery_enabled} subscribing_failed: | Abo für %{email} nicht eingetragen: %{errors}. list_of_subscriptions: Abos fingerprint_set: Fingerabdruck für %{email} auf %{fingerprint} gesetzt. setting_fingerprint_failed: | Fingerabdruck für %{email} konnte nicht auf %{fingerprint} gesetzt werden: %{errors}. signatures_attached: Die Signaturen hängen an. list_public_key_attached: Der Schlüssel zu dieser Adresse hängt an. no_output_result: Deine Email ergab keinen Ausgabe-Text. owner_forward_prefix: Die folgende Email ging für die Listen-Besitzer/innen ein. no_keywords_error: Deine Email enthielt keine Schlüsselwörter, daher gab es nichts zu tun. missing_listname_keyword_error: Deine Email enthielt nicht das notwendige X-LISTNAME-Schlüsselwort, daher wurde sie zurückgewiesen. wrong_listname_keyword_error: Deine Email enthielt ein falsches X-LISTNAME-Schlüsselwort. Der Wert dieses Schlüsselworts muss der Emailadresse dieser Liste gleichen. bounces_drop_all: Die angehängte Email hätte zurückgewiesen (bounced) werden sollen, wurde aber stillschweigend fallen gelassen, weil die Konfiguration dieser Liste definiert, dass für diese Liste nie Email zurückgewiesen werden soll. bounces_drop_on_headers: "Die angehängte Email hätte zurückgewiesen (bounce) werden sollen, wurde aber stillschweigend fallen gelassen, weil diese Kopfzeile gefunden wurde: %{key}: %{value}" bounces_notify_admins: "Die angehängte Email wurde mit folgender Nachricht zurückgewiesen:" notice: Hinweis incoming_message: Eingehende Email forward_all_incoming_to_admins: Die angehängte Email ging ein. forward_bounce_to_admins: Die angehängte Email ging als zurückgewiesen (bounce) ein. bounce: Zurückgewiesene Nachricht check_keys: Schlüsselprüfung check_keys_intro: "Bitte kümmere dich um die folgenden Schlüssel für Liste %{email}." key_expires: "Läuft in %{days} Tagen ab:\n0x%{fingerprint} %{email}" key_unusable: "Ist %{usability_issue}:\n0x%{fingerprint} %{email}" missed_message_due_to_unusable_key: "Du hast eine Email von %{list_email} verpasst weil mit deinem Abo kein (benutzbarer) OpenPGP-Schlüssel verknüpft ist. Bitte kümmere dich darum." refresh_keys: Schlüsselaktualisierung refresh_keys_intro: "Die Aktualisierung aller Schlüssel des Schlüsselrings für Liste %{email} ergab dies:" key_updated: Schlüssel %{fingerprint} wurde aktualisiert (%{states}). import_states: new_keys: neue Schlüssel new_uids: neue User-IDs new_subkeys: neue Unterschlüssel new_signatures: neue Signaturen schleuder-3.0.1/locales/en.yml000066400000000000000000000163441304235634100162510ustar00rootroot00000000000000en: errors: attributes: language: inclusion: "must be one of: en, de" log_level: inclusion: "must be one of: debug, info, warn, error" openpgp_header_preference: inclusion: "must be one of: sign, encrypt, signencrypt, unprotected, none" public_footer: invalid: "includes non-printable characters" invalid_email: "is not a valid email address" invalid_fingerprint: "is not a valid OpenPGP-fingerprint" list_fingerprint_missing: "List has no fingerprint configured, cannot run!" list_key_missing: "List-key is missing in keyring, cannot run!" list_secret_key_missing: 'Secret key of list is missing in keyring, cannot run!' list_admins_missing: "List has no admins configured, cannot run!" fatalerror: | A fatal error happened. Administrators have been notified. Please try again later. signoff: | Kind regards, Your Schleuder system. decryption_failed: | Decrypting your message failed. Messages to this address must be encrypted with the following key: %{key} To receive it send an email to <%{email}>. message_unsigned: Messages to this address must be OpenPGP-signed. message_signature_unknown: | Messages to this address must be OpenPGP-signed by the key that is configured for your subscription. If you don't know which one that is, ask an administrator of this list. You can contact the administrators by sending a message to <%{owner_email}> (preferably encrypt it with this addresses' public key: %{list_fingerprint}). message_unencrypted: Messages to this address must be encrypted conforming to OpenPGP. message_unauthenticated: Messages to this address must be encrypted and signed by the key associated with a subscribed address. message_sender_not_subscribed: Only subscribed addresses may send messages to this address. message_not_from_admin: Only admins may send messages to this address. message_empty: | Your message was found empty and wasn't passed on to the list. In case you only sent keywords please note that administrative keywords must be sent to the "request"-address (<%{request_address}>) in order to be respected. no_linebreaks: "must not include line-breaks" list_not_found: "Error: No list found with this address: '%{email}'." invalid_listname: "Error: '%{email}' is not a valid address." invalid_characters: "contains invalid characters" list_exists: A list with address '%{email}' is already present. listdir_problem: message: "There's a problem with the list-directory: '%{dir}' %{problem}." not_existing: does not exist not_a_directory: is not a directory not_empty: is not empty not_writable: is not writable not_readable: is not readable keyword_admin_only: The keyword '%{keyword}' may only be used by list-admin. key_generation_failed: Generating the OpenPGP key pair for %{listname} failed for unknown reasons. Please check the list-directory ('%{listdir}') and the log-files. key_adduid_failed: "Adding a user-ID to the OpenPGP key failed with this message:\n%{errmsg}" too_many_keys: "Error: In %{listdir} there's more than one matching OpenPGP-key for %{listname}. Please delete all but one." unknown_list_option: "Unknown option in %{config_file}: '%{option}'." loading_list_settings_failed: "%{config_file} could not be parsed, please check its formatting to be valid YAML." message_too_big: "Your message was too big. Allowed are up to %{allowed_size}KB." must_be_boolean: "must be true or false" must_be_greater_than_zero: "must be a number greater than zero" file_not_found: "File not found: '%{file}'." not_pgp_mime: "Message was not encrypted in the pgp/mime-format." delivery_error: "The following error occurred while sending a message to %{email}: %{error}" plugins: unknown_keyword: Unknown keyword '%{keyword}'. plugin_failed: Running keyword '%{keyword}' caused an unknown error. System-admins have been notified. keyword_admin_notify: "%{signer} sent keyword '%{keyword}' and received this response:" key_management: import_result: "Import result:" key_import_status: imported: imported updated: updated unchanged: unchanged resend: not_resent_no_keys: Resending to <%{email}> failed (%{num_keys} keys found and unencrypted sending disallowed). encrypted_to: Encrypted to unencrypted_to: Unencrypted to subscription_management: forbidden: "Error: You're not allowed to unsubscribe %{email}." is_not_subscribed: "%{email} is not subscribed." unsubscribed: "%{email} has been unsubscribed." unsubscribing_failed: | Unsubscribing %{email} failed: %{errors} subscribed: | %{email} has been subscribed with these attributes: Fingerprint: %{fingerprint} Admin? %{admin} Email-delivery enabled? %{delivery_enabled} subscribing_failed: | Subscribing %{email} failed: %{errors}. list_of_subscriptions: Subscriptions fingerprint_set: Fingerprint for %{email} set to %{fingerprint}. setting_fingerprint_failed: | Setting fingerprint for %{email} to %{fingerprint} failed: %{errors}. signatures_attached: Find the signatures attached. list_public_key_attached: Find the key for this address attached. no_output_result: Your message resulted in no output. owner_forward_prefix: The following message was received for the list-owners. no_keywords_error: Your message didn't contain any keywords, thus there was nothing to do. missing_listname_keyword_error: Your message didn't contain the mandatory X-LISTNAME-keyword, thus it was rejected. wrong_listname_keyword_error: Your message didn't contain a wrong X-LISTNAME-keyword. The value of that keyword muss match the email address of this list. bounces_drop_all: The attached message should have been bounced but was dropped without further notice because the list's configuration defines that no message should ever be bounced. bounces_drop_on_headers: "The attached message should have been bounced but was dropped without further notice because it matched this header-line: %{key}: %{value}" bounces_notify_admins: "The attached message was bounced with the following notice:" notice: Notice incoming_message: Incoming message forward_all_incoming_to_admins: The attached message was received. forward_bounce_to_admins: The attached message was received as bounce. bounce: Bounced message check_keys: Keys check check_keys_intro: "Please take care of these keys for list %{email}.\n" key_expires: "Expires in %{days} days:\n0x%{fingerprint} %{email}" key_unusable: "Is %{usability_issue}:\n0x%{fingerprint} %{email}" missed_message_due_to_unusable_key: "You missed an email from %{list_email} because your subscription isn't associated with a (usable) OpenPGP key. Please fix this." refresh_keys: Keys update refresh_keys_intro: "Refreshing all keys from the keyring of list %{email} resulted in this:" key_updated: Key %{fingerprint} was updated (%{states}). import_states: new_keys: new keys new_uids: new user-IDs new_subkeys: new subkeys new_signatures: new signatures schleuder-3.0.1/man/000077500000000000000000000000001304235634100142455ustar00rootroot00000000000000schleuder-3.0.1/man/schleuder-api-daemon.8000066400000000000000000000033631304235634100203310ustar00rootroot00000000000000.\" generated with Ronn/v0.7.3 .\" http://github.com/rtomayko/ronn/tree/0.7.3 . .TH "SCHLEUDER\-API\-DAEMON" "8" "January 2017" "" "" . .SH "NAME" \fBschleuder\-api\-daemon\fR \- provides the API of schleuder(8) . .SH "SYNOPSIS" \fBschleuder\-api\-daemon\fR . .SH "DESCRIPTION" schleuder\-api\-daemon provides the HTTP\-API of \fBschleuder(8)\fR to clients\. . .SH "ENVIRONMENT" . .SS "Configuration" \fBschleuder\-api\-daemon\fR reads configuration out of the \fBapi\fR section of \fBschleuder\fR\'s configuration\. Please see \fBschleuder\fR(8) for details about the configuration file\. . .P The available options are: . .TP \fBhost\fR The hostname/IP to listen at\. . .TP \fBport\fR The port to listen at\. Default: 4443\. . .TP \fBtls_cert_file\fR Path to the file that contains the TLS\-certificate to use\. You can generate a new one with \fBschleuder cert generate\fR\. . .TP \fBtls_key_file\fR Path to the file that contains the TLS\-key to use\. . .TP \fBvalid_api_keys\fR List of api_keys to allow access to the API\. . .SS "Clients" Available clients using the API are \fBschleuder\-cli\fR(8) and \fBschleuder\-web\fR\. URLs to their websites are listed below (\fISEE ALSO\fR)\. . .SH "BUGS" Known bugs are listed on the Schleuder bugtracker at \fIhttps://0xacab\.org/schleuder/schleuder\fR . .SH "SEE ALSO" \fBschleuder\fR(8), \fBschleuder\-cli\fR(8) . .TP Website of \fBschleuder\fR \fIhttps://schleuder\.nadir\.org/\fR . .TP More extensive documentation for \fBschleuder\fR \fIhttps://schleuder\.nadir\.org/docs/\fR . .TP \fBschleuder\-cli\fR, the command line interface for list\-management \fIhttps://0xacab\.org/schleuder/schleuder\-cli/\fR . .TP \fBschleuder\-web\fR, the web interface for list\-management \fIhttps://0xacab\.org/schleuder/schleuder\-web/\fR schleuder-3.0.1/man/schleuder-api-daemon.8.ron000066400000000000000000000030041304235634100211160ustar00rootroot00000000000000schleuder-api-daemon(8) -- provides the API of schleuder(8) =========================================================== ## SYNOPSIS `schleuder-api-daemon` ## DESCRIPTION schleuder-api-daemon provides the HTTP-API of `schleuder(8)` to clients. ## ENVIRONMENT ### Configuration `schleuder-api-daemon` reads configuration out of the `api` section of `schleuder`'s configuration. Please see `schleuder`(8) for details about the configuration file. The available options are: * `host`: The hostname/IP to listen at. * `port`: The port to listen at. Default: 4443. * `tls_cert_file`: Path to the file that contains the TLS-certificate to use. You can generate a new one with `schleuder cert generate`. * `tls_key_file`: Path to the file that contains the TLS-key to use. * `valid_api_keys`: List of api_keys to allow access to the API. ### Clients Available clients using the API are `schleuder-cli`(8) and `schleuder-web`. URLs to their websites are listed below ([SEE ALSO][]). ## BUGS Known bugs are listed on the Schleuder bugtracker at ## SEE ALSO `schleuder`(8), `schleuder-cli`(8) * Website of `schleuder`: * More extensive documentation for `schleuder`: * `schleuder-cli`, the command line interface for list-management: * `schleuder-web`, the web interface for list-management: schleuder-3.0.1/man/schleuder.8000066400000000000000000000143671304235634100163270ustar00rootroot00000000000000.\" generated with Ronn/v0.7.3 .\" http://github.com/rtomayko/ronn/tree/0.7.3 . .TH "SCHLEUDER" "8" "January 2017" "" "" . .SH "NAME" \fBschleuder\fR \- an email hub for groups . .SH "SYNOPSIS" \fBschleuder\fR work \fIlistaddress\fR < \fIemail\fR . .P \fBschleuder\fR help . .P \fBschleuder\fR \fIother\-command\fR [<\.\.\.>] . .P For descriptions of the other commands see the output of the \fIhelp\fR\-command\. . .P This manual page is written for system administrators\. For other information please read the Schleuder documentation online (\fISEE ALSO\fR)\. . .SH "DESCRIPTION" Schleuder is an email hub for groups\. Subscribers can communicate encryptedly and pseudonymously among themselves, receive emails from non\-subscribers and send emails to non\-subscribers via the list\. . .P Schleuder takes care of all de\- and encryption, stripping of headers, formatting conversions, etc\. Further Schleuder can send out its own public key and receive administrative commands by email\. . .P Email cryptography is handled by using GnuPG\. . .SH "ENVIRONMENT" . .SS "Configuration" Schleuder reads its basic settings from a file that it by default expects at \. To make Schleuder read a different file set the environment variable \fISCHLEUDER_CONFIG\fR to the path to your file when running schleuder\. E\.g\.: . .IP "" 4 . .nf SCHLEUDER_CONFIG=/usr/local/etc/schleuder\.yml /path/to/bin/schleuder \.\.\. . .fi . .IP "" 0 . .P For explanations of the possible settings read the default config file\. . .P The default settings for new lists are read from another config file\. By default Schleuder looks at \. To make Schleuder read a different file set the environment variable \fISCHLEUDER_LIST_DEFAULTS\fR analogous to above\. The possible settings are explained in the default config file\. . .SS "Connect to MTA" Schleuder behaves like an email\-filter: it reads email from standard\-input, and reports errors to standard\-error\. If all goes well Schleuder closes the initial connection to the Mail Transport Agent (MTA) only after it sent out all outgoing emails\. . .P In case of an error the MTA is expected to include Schleuder\'s error message into a bounce\-email that is sent back to the sender (this is default behaviour of most MTAs)\. . .P To connect the MTA with Schleuder it must pipe the incoming message into Schleuder\'s STDIN, and give it two arguments: first one: "work", second one: the full recipients email address\. . .P For more information on how to integrate Schleuder with your existing mail setup, please read the Schleuder documentation online (\fISEE ALSO\fR)\. . .SS "Data storage" The keyrings for each list are standard GnuPG keyrings and sit in the filesystem under \fIlists_dir\fR/\fIhostname\fR/\fIlistname\fR/ (\fIlists_dir\fR is read from schleuder\.yml, by default it is )\. They can be used manually using gpg2\. Please be careful to maintain proper file permissions if you touch the files\. . .P In the list\-directory there’s also a list specific log\-file (might be missing if the log\-level is high and no error occurred yet)\. . .P Other logging is sent to syslog\. Where that ends up depends on the operating system and the system administration\. . .P All other list\-related data is stored in the SQL\-database\. Most data is unserialized, only some values are JSON\-encoded\. . .SH "SPECIAL FEATURES" Schleuder features some special funtionality\. For more detailed information read the Schleuder documentation online (\fISEE ALSO\fR)\. . .SS "Getting the public key of a list" Each Schleuder\-list replies with its public key to any email sent to \fIlistname\-sendkey@hostname\fR\. E\.g\. to receive the key for the contact address of the Schleuder project write an email to . .br \fIschleuder\-sendkey@nadir\.org\fR\. . .SS "Email commands" Schleuder knows some special keywords that trigger different behaviour\. You can e\.g\. subscribe someone, or resend an email to a non\-subscriber using keywords\. . .P Keywords require that: . .IP "\(bu" 4 they start the line and begin with "x\-", . .IP "\(bu" 4 they are written into the beginning of the \fIfirst text\-part\fR of the email (usually that’s just the normal body of the email), . .IP "\(bu" 4 possible arguments must be written \fIon the same line\fR as the keyword (exceptions are mentioned in the descriptions below), . .IP "\(bu" 4 the email must be \fIencrypted and signed\fR by a list\-member’s key\. . .IP "" 0 . .P Keywords can be repeated within one email at will\. Letter case doesn’t matter\. . .P There are two types of keywords: those to enhance messages sent over the list (“list\-keywords”), and those to request something from Schleuder (“request\-keywords”)\. . .P Find detailed descriptions of all available keywords in the Schleuder documentation online (\fISEE ALSO\fR)\. . .SS "Contact list\-owner" Write to \fIlistname\-owner@hostname\fR to contact the list\-owner(s) even if you don\'t know who they are\. Use the list\'s key to encrypt the email! . .SH "EXIT STATUS" . .TP 0 Incoming email was processed without errors\. . .TP 1 Internal failure in incoming email processing\. . .SH "FILES" . .IP "\(bu" 4 \fB/etc/schleuder/schleuder\.yml\fR: default path of global Schleuder configuration . .IP "\(bu" 4 \fB/etc/schleuder/list\-defaults\.yml\fR: default path of default list settings . .IP "\(bu" 4 \fB/var/lib/schleuder/lists\fR default path of lists_dir . .IP "\(bu" 4 \fB\fR/\fB\fR/`\fIlistname\fR: list internal data . .IP "\(bu" 4 \fB\fR/\fB\fR/\fB\fR/list\.log`: log\-file for list . .IP "" 0 . .P All configuration files are formatted as YAML\. See \fIhttp://www\.yaml\.org/\fR for more details\. . .SH "BUGS" Known bugs are listed on the Schleuder bugtracker at \fIhttps://0xacab\.org/schleuder/schleuder\fR . .SH "SEE ALSO" \fBschleuder\-cli\fR(8), \fBgnupg\fR(7)\. . .TP Website of \fBschleuder\fR \fIhttps://schleuder\.nadir\.org/\fR . .TP More extensive documentation for \fBschleuder\fR \fIhttps://schleuder\.nadir\.org/docs/\fR . .TP \fBschleuder\-cli\fR, the command line interface for list\-management \fIhttps://0xacab\.org/schleuder/schleuder\-cli/\fR . .TP \fBschleuder\-web\fR, the web interface for list\-management \fIhttps://0xacab\.org/schleuder/schleuder\-web/\fR schleuder-3.0.1/man/schleuder.8.ron000066400000000000000000000132131304235634100171110ustar00rootroot00000000000000schleuder(8) -- an email hub for groups ======================================= ## SYNOPSIS `schleuder` work < `schleuder` help `schleuder` [<...>] For descriptions of the other commands see the output of the -command. This manual page is written for system administrators. For other information please read the Schleuder documentation online ([SEE ALSO][]). ## DESCRIPTION Schleuder is an email hub for groups. Subscribers can communicate encryptedly and pseudonymously among themselves, receive emails from non-subscribers and send emails to non-subscribers via the list. Schleuder takes care of all de- and encryption, stripping of headers, formatting conversions, etc. Further Schleuder can send out its own public key and receive administrative commands by email. Email cryptography is handled by using GnuPG. ## ENVIRONMENT ### Configuration Schleuder reads its basic settings from a file that it by default expects at . To make Schleuder read a different file set the environment variable to the path to your file when running schleuder. E.g.: SCHLEUDER_CONFIG=/usr/local/etc/schleuder.yml /path/to/bin/schleuder ... For explanations of the possible settings read the default config file. The default settings for new lists are read from another config file. By default Schleuder looks at . To make Schleuder read a different file set the environment variable analogous to above. The possible settings are explained in the default config file. ### Connect to MTA Schleuder behaves like an email-filter: it reads email from standard-input, and reports errors to standard-error. If all goes well Schleuder closes the initial connection to the Mail Transport Agent (MTA) only after it sent out all outgoing emails. In case of an error the MTA is expected to include Schleuder's error message into a bounce-email that is sent back to the sender (this is default behaviour of most MTAs). To connect the MTA with Schleuder it must pipe the incoming message into Schleuder's STDIN, and give it two arguments: first one: "work", second one: the full recipients email address. For more information on how to integrate Schleuder with your existing mail setup, please read the Schleuder documentation online ([SEE ALSO][]). ### Data storage The keyrings for each list are standard GnuPG keyrings and sit in the filesystem under /// ( is read from schleuder.yml, by default it is ). They can be used manually using gpg2. Please be careful to maintain proper file permissions if you touch the files. In the list-directory there’s also a list specific log-file (might be missing if the log-level is high and no error occurred yet). Other logging is sent to syslog. Where that ends up depends on the operating system and the system administration. All other list-related data is stored in the SQL-database. Most data is unserialized, only some values are JSON-encoded. ## SPECIAL FEATURES Schleuder features some special funtionality. For more detailed information read the Schleuder documentation online ([SEE ALSO][]). ### Getting the public key of a list Each Schleuder-list replies with its public key to any email sent to . E.g. to receive the key for the contact address of the Schleuder project write an email to
. ### Email commands Schleuder knows some special keywords that trigger different behaviour. You can e.g. subscribe someone, or resend an email to a non-subscriber using keywords. Keywords require that: * they start the line and begin with "x-", * they are written into the beginning of the *first text-part* of the email (usually that’s just the normal body of the email), * possible arguments must be written *on the same line* as the keyword (exceptions are mentioned in the descriptions below), * the email must be *encrypted and signed* by a list-member’s key. Keywords can be repeated within one email at will. Letter case doesn’t matter. There are two types of keywords: those to enhance messages sent over the list (“list-keywords”), and those to request something from Schleuder (“request-keywords”). Find detailed descriptions of all available keywords in the Schleuder documentation online ([SEE ALSO][]). ### Contact list-owner Write to to contact the list-owner(s) even if you don't know who they are. Use the list's key to encrypt the email! ## EXIT STATUS * 0: Incoming email was processed without errors. * 1: Internal failure in incoming email processing. ## FILES * `/etc/schleuder/schleuder.yml`: default path of global Schleuder configuration * `/etc/schleuder/list-defaults.yml`: default path of default list settings * `/var/lib/schleuder/lists` default path of lists_dir * ``/``/`: list internal data * ``/``/``/list.log`: log-file for list All configuration files are formatted as YAML. See for more details. ## BUGS Known bugs are listed on the Schleuder bugtracker at ## SEE ALSO `schleuder-cli`(8), `gnupg`(7). * Website of `schleuder`: * More extensive documentation for `schleuder`: * `schleuder-cli`, the command line interface for list-management: * `schleuder-web`, the web interface for list-management: schleuder-3.0.1/schleuder.gemspec000066400000000000000000000037331304235634100170230ustar00rootroot00000000000000# encoding: utf-8 $: << File.expand_path('../lib', __FILE__) require 'schleuder/version' Gem::Specification.new do |s| s.name = "schleuder" s.version = Schleuder::VERSION s.authors = 'schleuder dev team' s.email = "schleuder@nadir.org" s.homepage = "https://schleuder.nadir.org/" s.summary = "Schleuder is a gpg-enabled mailinglist with remailing-capabilities." s.description = "Schleuder is a group's email-gateway: subscribers can exchange encrypted emails among themselves, receive emails from non-subscribers and send emails to non-subscribers via the list.\n\nSchleuder takes care of all decryption and (re-)encryption, stripping of headers, and more. Schleuder can also send out its own public key upon request and process administrative commands by email." s.files = `git ls-files lib locales etc db/schema.rb README.md Rakefile`.split s.executables = %w[schleuder schleuder-api-daemon] s.platform = Gem::Platform::RUBY s.require_path = 'lib' s.rubyforge_project = '[none]' # TODO: extend/replace expired cert #s.signing_key = "#{ENV['HOME']}/.gem/schleuder-gem-private_key.pem" #s.cert_chain = ['gem-public_cert.pem'] s.license = 'GPL-3.0' s.add_runtime_dependency 'mail-gpg', '~> 0.3.0' s.add_runtime_dependency 'activerecord', '~> 4.1' s.add_runtime_dependency 'rake', '~> 10' s.add_runtime_dependency 'sqlite3', '~> 1' s.add_runtime_dependency 'sinatra', '~> 1' s.add_runtime_dependency 'sinatra-contrib', '~> 1' s.add_runtime_dependency 'thor', '~> 0' s.add_runtime_dependency 'thin', '~> 1' s.add_development_dependency 'rspec', '~> 3.5.0' s.add_development_dependency 'hirb' s.add_development_dependency 'factory_girl' s.add_development_dependency 'database_cleaner' s.post_install_message = " Please consider additionally installing schleuder-cli (allows to configure lists from the command line). To set up Schleuder on this system please run `schleuder install`. " end schleuder-3.0.1/spec/000077500000000000000000000000001304235634100144245ustar00rootroot00000000000000schleuder-3.0.1/spec/factories/000077500000000000000000000000001304235634100164035ustar00rootroot00000000000000schleuder-3.0.1/spec/factories/lists.rb000066400000000000000000000025651304235634100200760ustar00rootroot00000000000000FactoryGirl.define do factory :list do sequence(:email) {|n| "list#{n}@example.org" } fingerprint "59C71FB38AEE22E091C78259D06350440F759BD3" log_level "warn" subject_prefix nil subject_prefix_in nil subject_prefix_out nil openpgp_header_preference "signencrypt" public_footer nil headers_to_meta ["from", "to", "cc", "date"] bounces_drop_on_headers "x-spam-flag" => true keywords_admin_only ["subscribe", "unsubscribe", "delete-key"] keywords_admin_notify ["add-key"] send_encrypted_only true receive_encrypted_only false receive_signed_only false receive_authenticated_only false receive_from_subscribed_emailaddresses_only false receive_admin_only false keep_msgid true bounces_drop_all false bounces_notify_admins true include_list_headers true include_openpgp_header true max_message_size_kb 10240 language "en" forward_all_incoming_to_admins false logfiles_to_keep 2 after(:build) do |list| FileUtils.mkdir_p(list.listdir) gpghome_upstream = File.join "spec", "gnupg" FileUtils.cp_r Dir["#{gpghome_upstream}/{private*,*.gpg,.*migrated}"], list.listdir end trait :with_one_subscription do after(:build) do |list| create(:subscription) end end factory :list_with_one_subscription, traits: [:with_one_subscription] end end schleuder-3.0.1/spec/factories/subscriptions.rb000066400000000000000000000003431304235634100216370ustar00rootroot00000000000000FactoryGirl.define do factory :subscription do list sequence(:email) {|n| "subscription#{n}@example.org" } fingerprint "129A74AD5317457F9E502844A39C61B32003A8D8" admin true delivery_enabled true end end schleuder-3.0.1/spec/fixtures/000077500000000000000000000000001304235634100162755ustar00rootroot00000000000000schleuder-3.0.1/spec/fixtures/example_key.txt000066400000000000000000000060441304235634100213450ustar00rootroot00000000000000-----BEGIN PGP PUBLIC KEY BLOCK----- Version: GnuPG/MacGPG2 v2 mQINBFhOqPgBEADCCueSgLSUeYgDfj+z5JBeeUSKeDnaAocAPHPRysPg4De3J3uk 3VgORCJuYfIxPgt+Bu6HmWEBLerD51ML5bIQks79YXf2tgK8Is5ICeVEinF9KL3M 3czi47QJKvz0WEb38gtunbqX+JkMs4EC54M7vOpRapEXHa7yQ41lpppPBn+xx4g0 JMByTA2crtmJNdTZ4hRSP8CH+lVCDQUaqH2A70f+4+GBOUu2Rs0xoHdIfHKN7b4p pegxhUT9+bmG0Ofp5SN0ntQH/px2hz/ilXucxWEZ6Wx6QmEAy3phNgaIP/L02q9f f2XSypNiiehj8SmKcTtfb2u7Ru9ThpJ07RG+yRYSPC9qru2IuPh4JFRJMwT9k3eb ArbU3YR0ovdBr8lxrA7mr5OMtRAAbnNOehdDOLxTdukNOHsLGoEEyfIm2A5ChBwb O3BjPtnVAFTzdOkiZ6HbGNVBcP/4KtTNMPj+jL64beZhWHXwEvDrY3aaahXo/KZt tn0zvrWxPG7M56UTF2+wluDM9mh8w1LmI1hFhV5vNe0RoMPsjxT0RJz0aavil3w7 A5HFIbkryCSi/y+7gaycpBGOlSbClJDoA1PK4DbQaUaceTfUdTUbh9Xy04DegBlX th4A5VS/5xv9HqEpsw3dwnljtLnJEHobgmfRhosxPtBQtnyKNJfGzavXbQARAQAB tClBbm90aGVyIFRlc3R1c2VyIDxzY2hsZXVkZXIyQGV4YW1wbGUub3JnPokCOAQT AQIAIgUCWE6o+AIbAwYLCQgHAwIGFQgCCQoLBBYCAwECHgECF4AACgkQ0/+mYTqx Ds56ow/6A2QK9gyrFzmUAszEfmxefKvnNeAStKs1+S+fwEonOyxzDekNEZ4Hp/mU 9VahhhZ+WUHJp17Kf7d6aHv9Q/AdsQ0aGL8lsft+bxmuDhvEa0lZDlw/WHRulmf4 o2IjXUol5xadg4tEK/sjXjz+EUQsTubZgQ2TTG5CE4RHTXIysDtxC3t/9HaFSsxr D9iFdW4Yo/PmvrlgCatrk0lXdQ4xSd6rzRV4fM5WguOnZc84FxVK47DRFevcqjLu uZXt7VBZ/FuDYgaoBnrekeBHqSkR9D7l9RKseCvNtGchZm9GAa7U91hgDOkYIqjG Vrkfqkkb8fz53Z1OWA+Pm8vR2EWw9+N+ixtifj4ireQWJXLmDs4xYc0ZhWTRWghU j6lyrTFdpGTmFKXrpQUiKIjXUlHPn90FrI+446omwAWID694EX4FwjwsBbaYOyNF GgP4402SEG4BaLIaklBcN1GzyvNBSuTSgoBWzLVU3VO2nz0taRZk1T8yJ3bEPCH+ zYQF3nT1Ftp/zF1OGyFji3l0jxyUDGNIdbJODEUsfSPxeHqOdA5l+d3k6V0yVuvh v+f1GC3GEk8OK/4lW11Nhp+0+qzX/aRUgE0qHCHveCrv1zdyPVoi5IAitBK2+RSd gfn25HMr9jOSG/CaPX5GKemXPK2X38Q0l0tMDJKB3/MNh1A1rx65Ag0EWE6o+AEQ AKpbAgbD53eB0vAFdVNITI1ptvxnJezdHW8DVrJkxJyAJKV3qJhRMu5ma/RCxvLS 0U/cxcm9uyq0UW2d5L/XxMAmih1Uw25VYDsXIuODYNRr5VX7od8/Jnft6MuXxIXq U37SAAd8DWppRMZvRcFbqWQN8cd25q7yypuyYYdapYnLDuTtlNwvWy86lEA5cPmc McIFomJqBoASg8Cvn/ab5Crjkff/g4W1tLLVmzseoNP6+bGCsVEuxVw8MNfwx2vb l52/io3RzxWzCcqPaVyFRH/0gvBjic91PufwiZqSDXorfcR+Ua9NIqIqE+zRO8nC RHUitncCYV/gcCb41Z+9DrW/Zc61LJsh6KRuUmXQi3ygPdhWnabxBKeyVgQeTWzI u2zQXrkrEs5H9b1m85T00ENgZ9nUulCsNGKd0/7D4nidQt6+H6FOGtp+DAYbYQA1 xwTryHcce6m25wvtXUe2CC1ymQQK3FjuQ3sguMcJnRgdozkNhMoUYgAEWSmxYv+w sy9AaC2a8bKQc7rmFrmPI/eMjrEuhDguEHO4RqR/7ZwZrcPqZXEMNslSq+sMQlCu htrTZjg/+Snp0jMQkTrd3rLlpuvjz3w6ghyfCtx4LLM72HpNlDHnK2JaUlVdCa7w uQQdR0tHNr8AgMnvl+D8f1VAvbYuppVaV8eRPe5wXN/nABEBAAGJAh8EGAECAAkF AlhOqPgCGwwACgkQ0/+mYTqxDs4t1w//el/YMyZRhIXJ2Sk+YvUll7vlZVlKxZPq 3f9JlgC0bmB9d1YehliDTNyzNZtwuODilXVJG7pWSJK5sFrdTIUsRVljNp5XTmer x+15Q1KEUTuajKZxPNJgGL8q2ZMYEeCl5/IWBCS2rzwzZYF4biZ/TEL494+wLxZ0 /JqbMyfUiW2eYnSGqqOmETWw84wr+Oxq1FRa/lvhqRRvnDMP2lwqDP5Cg2VHeeri G12vye8u9Jmc4MI0DizafVKM47iCIdXbX7OTGhiDwM5z7ObrwyakxgVAusCEsLsg wC5Afgez85SX5VTLfERR+WXpEHbtUsbOeX8+Ipb79AK6fjEPksqrJ4erqkyU31nX ghqP4YHLO9ur3wZZ7qauCwBk9mv4tE/zltzAGFUF7eoO7cl6+ZnnFmgaZI5wfExm JmPuG7ZIuh/NjR149Zf5EZhJWV8vyXfBlN2USGa00MktVsQyNvtDUDLQmI7JXBkN ia4iAF9LfSBNgb0OYcTjShlMKmCv5RRCGUM/Dmds3tSIT1DbMVxzQyZt13d1RDGv Gd3K/JxcFl+Na4OCk4Jg0jh80I/GShzrdqDTJbOymBwr2Rt52kuulvVAIbLCJ4Mc mZImolmIiOHXoABLezW9wv+lMkcME88xAsybj6VoQBp3rawUyldqKQA1yg7F5m6/ gpCMrbUUdX4= =H2Gw -----END PGP PUBLIC KEY BLOCK----- schleuder-3.0.1/spec/fixtures/expired_key.txt000066400000000000000000000032201304235634100213430ustar00rootroot00000000000000-----BEGIN PGP PUBLIC KEY BLOCK----- mQENBExlilkBCACb2AQyclf7latAIE1kCTfKQ9jmcKyf959ymyhzoeNmBDpKjILC 7MOXtICo/V/xAzhWBK/vT9+56brGUBTugnW3yK+zllQprI3kIYaRS1SrbmKVwVse 9qLVUL1BssohFaEeQqT4MNh62ziJymqCguGEGXpYlEqzEDTmmhTANiPKRBZDrdfq 3FU3OJUMTGzuG34mKmXMRr0azprF228LUujMMKyWhG1hxh3El04C4jPuMSbaVcwN E2rgIg8jaNAQuSyXkaprPZ8/nRG8UFGRtCMEIEh6Ou6KybF1NI9LQKCwcsGcLHKU 2u/8vOCExxdwl9Jjlqmof4FQV7bT++6SC0n3ABEBAAG0EWV4cGlyZWQgPGJsYUBm b28+iQE+BBMBAgAoBQJMZYpZAhsDBQkAAVGABgsJCAcDAgYVCAIJCgsEFgIDAQIe AQIXgAAKCRD3Gj+EEtg4iV6yB/4uDLoN1+TswtGjpUlu2CyjHe7pb05dAU4sWfTV I+fxBuyEo+cf/23nOeoGyltBDR0heSg3TIfXQrbWD4WoVsOXPaT0fq6UEzeadkmn A5NN3PGkv46o3ZSF1ltkY9ybMgnmRLHYCojSu5bSBMRVyurr0ozwNRPtFUTka8Lj wxiwDJ394D5y6PjL56FPkUdKydzFGV2ptSKsqyAJvMBeGlQ4I6TpiBx0Lz2A1Qn+ 4uXgTVPqgalC5YKTTTjOfQcieOOeqtI0LHqDpS/DIPLnwTUCN8OL2TQIeDudm3YI P8FCKvImh840vTbpgFSgQeaJzJFv9UrloNyyvbVtaeoxnxoBuQENBExlilkBCADD Gbf0TEs5HDpbUC78tJetGWipmQRTq8gS9dDoKjG5mvlpFARPTAJvewgI7DICXMtV Y8P8eFbsZDGMETduunadutDvyP9J/wuknYHJkE5jJeZjEKyofrWM1BHxHb2bkNU0 hr8EVNvEhVjAb62cJPj5emi/3UhynLoJrrO+AZSr9Bq2QW38ntSUxTXM7VbGUR1M WZSoJ+gEg/IeR2HJziCyb1mhlvo9pZqJT959bNVQ/xU4NHtYca5cV3X88Ald4Dwz 2HM+PIBbsiz3C3fIMNrRxRvMCU4PgsjSZFoRxcdDRT5OjBxNgQ4UmWQH0sTFw9Tx 8B2OtwuguGwaXIV3FpRDABEBAAGJASUEGAECAA8FAkxlilkCGwwFCQABUYAACgkQ 9xo/hBLYOImqngf/QQt0S6tlJ9OMknmAr2pNg+DQkCqTNaSk/iQj4leGGwkpRVoH 5VFTZ0nkmZjcDTTrCjj5rEDaRo8Q38KsB1po8P25ABoK0b28rHw8I3L2Byl1+IB7 +dNKVyFJVfHAYOQsbI/p/2KdtZZIbpxnRVHY+Vlu2p/fx3JqPmqCiaVMcUFw55Qj SKaI+omfnN0WGyrK1Rub925Lch0vZkxVwmTse7qufg0iwTREMy9VZfMavMhkAtM2 AsiEG8j3mwU9JQfBkXqtWxG2VvtsBJ0rLafh5sR3NgjtR2vbSdzJRCV2xO4z6Drh 3Pug3ReHmcLUFTDPE+vmeH+xpEZ2nhvNRFDhmQ== =Nao0 -----END PGP PUBLIC KEY BLOCK----- schleuder-3.0.1/spec/fixtures/expired_key_extended.txt000066400000000000000000000033421304235634100232300ustar00rootroot00000000000000-----BEGIN PGP PUBLIC KEY BLOCK----- Version: SKS 1.1.6+ Comment: Hostname: sks.spodhuis.org mQENBExlilkBCACb2AQyclf7latAIE1kCTfKQ9jmcKyf959ymyhzoeNmBDpKjILC7MOXtICo /V/xAzhWBK/vT9+56brGUBTugnW3yK+zllQprI3kIYaRS1SrbmKVwVse9qLVUL1BssohFaEe QqT4MNh62ziJymqCguGEGXpYlEqzEDTmmhTANiPKRBZDrdfq3FU3OJUMTGzuG34mKmXMRr0a zprF228LUujMMKyWhG1hxh3El04C4jPuMSbaVcwNE2rgIg8jaNAQuSyXkaprPZ8/nRG8UFGR tCMEIEh6Ou6KybF1NI9LQKCwcsGcLHKU2u/8vOCExxdwl9Jjlqmof4FQV7bT++6SC0n3ABEB AAG0EWV4cGlyZWQgPGJsYUBmb28+iQFVBBMBAgA/AhsDBgsJCAcDAgYVCAIJCgsEFgIDAQIe AQIXgBYhBJh2nooQkfNr2IQD7PcaP4QS2DiJBQJYgOG1BQkMHGNXAAoJEPcaP4QS2DiJxiUH /2xYCT+mldoaWMyJlBleSjx0wtWeGNayMuv0RjU2pIkBmslYp/ZZkt+JC3thpJneBW5pJuRB qeUi7yTigdtOrH47g+FfIDCY89ymTDbYW4vpNnnsV7s+ke8tbEmTtMpjFypoTvbnGYlq8VLz 87eRcsLwADOAJfFBdnDD0tyNCrUY/V+Ti/ZI4bHoFA14t8Hm7MIDkfB6sVfzpnZd1ACj+klv 1rfq+9m56lsavS/dM+BlhwfRORT9cenuBs++AXXWvh1CZW/J06kFECG+ptqU5246nQcjE5GX W8sC+TSq7OXSTQAJDF+aWqjA/JrbpSf/3r2/IU+mGH2Bwi7B5uBN6lG5AQ0ETGWKWQEIAMMZ t/RMSzkcOltQLvy0l60ZaKmZBFOryBL10OgqMbma+WkUBE9MAm97CAjsMgJcy1Vjw/x4Vuxk MYwRN266dp260O/I/0n/C6SdgcmQTmMl5mMQrKh+tYzUEfEdvZuQ1TSGvwRU28SFWMBvrZwk +Pl6aL/dSHKcugmus74BlKv0GrZBbfye1JTFNcztVsZRHUxZlKgn6ASD8h5HYcnOILJvWaGW +j2lmolP3n1s1VD/FTg0e1hxrlxXdfzwCV3gPDPYcz48gFuyLPcLd8gw2tHFG8wJTg+CyNJk WhHFx0NFPk6MHE2BDhSZZAfSxMXD1PHwHY63C6C4bBpchXcWlEMAEQEAAYkBJQQYAQIADwUC TGWKWQIbDAUJAAFRgAAKCRD3Gj+EEtg4iaqeB/9BC3RLq2Un04ySeYCvak2D4NCQKpM1pKT+ JCPiV4YbCSlFWgflUVNnSeSZmNwNNOsKOPmsQNpGjxDfwqwHWmjw/bkAGgrRvbysfDwjcvYH KXX4gHv500pXIUlV8cBg5Cxsj+n/Yp21lkhunGdFUdj5WW7an9/Hcmo+aoKJpUxxQXDnlCNI poj6iZ+c3RYbKsrVG5v3bktyHS9mTFXCZOx7uq5+DSLBNEQzL1Vl8xq8yGQC0zYCyIQbyPeb BT0lB8GReq1bEbZW+2wEnSstp+HmxHc2CO1Ha9tJ3MlEJXbE7jPoOuHc+6DdF4eZwtQVMM8T 6+Z4f7GkRnaeG81EUOGZ =4p8E -----END PGP PUBLIC KEY BLOCK----- schleuder-3.0.1/spec/fixtures/mails/000077500000000000000000000000001304235634100174025ustar00rootroot00000000000000schleuder-3.0.1/spec/fixtures/mails/encrypted+signed-inline/000077500000000000000000000000001304235634100241205ustar00rootroot00000000000000schleuder-3.0.1/spec/fixtures/mails/encrypted+signed-inline/thunderbird.eml000066400000000000000000000072571304235634100271440ustar00rootroot00000000000000Received: from [IPv6:::1] (localhost.localdomain [IPv6:::1]) by flutsch.local (Postfix) with ESMTP id 63585801DD for ; Thu, 29 Dec 2016 15:17:07 +0100 (CET) To: schleuder@example.org From: paz Subject: encrypted+signed-inline test Openpgp: id=52507B0163A8D9F0094FFE03B1A36F08069E55DE Message-ID: <216c8188-a773-fa94-d2e1-b2db4a309fed@nadir.org> Date: Thu, 29 Dec 2016 15:17:07 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:45.0) Gecko/20100101 Thunderbird/45.5.1 MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit -----BEGIN PGP MESSAGE----- Charset: utf-8 hQIMA691X8Gl2MArAQ//U47/ExT/T15q05GxT4HWcStkrzrjnRFOPs4x49YZRSaq 10oPuHxEId+WdYQpiN+ffBqsf2Wozb/fBTi/TJ/Q7eXaSr2soRHbR4WxtJbZhgtf o9w6g/3EGurx2hjBkq6dArwy7fiaD8+Ysh20WW/hT1UVYzXzesd1gYkSP8p0iQNy sflPCehJNNcHPPDIqDWeCF6WWaEsJuHPFpPIdJS+5VBtLFlO7UDeoXghTpmJwO3l /t9BYOIuHGhXLZ7DETJZFgYJSQg6hMuk9FpmgHq1mY+gZmyWPalJEaplXg6g42VD 5QnUSTKYIH4iBrcl0yTYSMktt3THOQiQUnhmP583ThJ0M19EMj3JZk/H98wsm06d yVqVKbPa3f8wqwmhjt9jFfN2dkPAHPc+4t7ROb8LWXTfsqMfbFh1+EfhGOVi5xIf Wd8QtFRwldgKuT5MHFWVuHy7vdcAF3bVrVasGs/hfdC1qoEDqjYrjRkNuCHeznDL DXquYI5UmulHYMghEcn8VKUUINEUVrcHuq1vkiUh6IML97x5PCljY6Dw/1Blpk2S YYqTyYFZOsiHmpHAvVF7bN7ru1mCmcsUKr9cvT/9e84dbSSTFiEIX3TtyEtU3HHA RLDxueKLYGTCfIt07DPiGV1C8/8Fy9a/hVGptjsatCMDucwqUqYVL/bYnO1p30KF AgwDAAAAAAAAAAABD/4qf50+CJiHw+vDYEjvsBmEHw/19DDG1SRUTG+OZI7DtpIa wIA/szIMT2J2WDCF+LT6gmTSFNx/y0XgoDUCOCieWdqQMl86sF48vPJpZJaQK9MP QjvXWJnuDrTviS4ZDYMLIXMd7tSGrvVd/aOR2aS7bGNWDQxLrpeulBXtqkgNbEWv C0cw8w1vewg9s3B6ffAWSG+casusMJ+/lmCApTYcH/swzMKR+bArcpYI/J0URiMZ OIoEPbkpBsoqtyzKeh/o5aeA4NTsEku2NzW1rVqK5SV9pwSfd8ITpMYe2+x8Xe9R xNnZ0GSzi2QrFSz1tHlxdMei6IK4ay/3eojZEklcvfcCnEOIQX/HTohQ9L0nx4hr eXboNS8FIqmM0jMjKjvJoogIzoWLp5sCLc8ZiIN5i1j73JCV1rI2lI4BwaKAdYEo g3p33ivsdydC3cSmUjfcEmVGywBj6K0AnO97D4VtzvNk53qG8l80T8pt3o8xL+Mc gGmZuwhLnfZEcbRTUleHOED2JcZUEIn5f98zIOQtsLT9k22qtFyNqrS3R1wLysT0 ZGNfbVVPnO5pUci8fIBaZbiorDUtu4HhkNSD0ufLR9SAmbljgLG04UGtlorXyvCn 5JyTp29igalo4E3uPNeCVEJZqIDKOiCS44H7fnZFNyc7A5MUj1mqCKsN5X1iu4UC DAOnLuUXmtC57QEP/0u6aeKohTmJBBQJ+2g/jWRIro+E2nrIS0UZTgFfvcYKshQe ZA4siNPejYqXJvJ7vTxoSgIU2htsDS6lAe7HyoYBoAWuVbEh4Wh3vITfUJyRofok YRNC067stRNhiMQWTsrkms9yBWh7Li2p51O50+l4GCcjh8gN4mwwxiiQmZ0iO4Kn Lzs7HESJwQjVsKSB0MHMibEJgtiQd0TssZ9EsY4IV4/2b0m910Mww7k0MPrNVMQx tiNzOL8VYZuJ0tiApk8gLdFbAeKfVPur7KsbsVcSg+qDUDlSfU0rxmPK8LhEatWC DI7rSlOKiH6939a+HjePjSjKdav+3j8v4WxSjG/1k2kKKwjthAbBOF/wjQUZFTi8 f2xJ778LtyXGBfRfSe5OuMJofiD6mcW/qxKzUaSycNSumwU3oMsy/7zILZ5T40+Z Jq6KRhr6Ysw1eE1AMi9egq1LpNJhXT5+7UZuuwGgsCMtclVr1nxYfzMKYf0sjXnk 2ZdIJ3RQF8IgSCpqgzw5cb193bH59ZPvcDhio76U5wUBziExrg/8titHvWy7gtBz GVEKytfSlhnvHykKu+piTwDUihgYtaDeQ1/t20KwQo/Zf/JD8pkRE1fzy33Slo2m FZWfJXmLUM91GYBmdx0hHbi3lhXNBTXl+TFcCUX91NefBcOfkFd2iZ+MQY8Q0ukB qx0FsLsMqxKTjtXqjM5TBOjyvpYmF3G5t/3U5tulqUrWZvWNEm18yQqkUwTf9IOz EDnJJL8QyQcsSovBIdCcIasplaO7IZu5R8MDh8t9qnzfkGSTFPRSmBi+xryXXR6S ZM36HFcyeNFF7C8Py89we00gOAT2wNS3897F3T2+Zq6V7dhNIz0XiYPRtnkLmsUx W+JPq+zfzYz9kJ18rE1k0HsjvCrEDSMeOkpl4bkJhlmYLSvarUevGe42b6nWU9mm 4CuM8DhL564OBvUpYCyqTJIDIGJjPtLQ2P/uDo4GdYnSpStIMmycsvpVlFytlbNp FWc4PF7uWEOu7p3zpbPYenJFETqIIGKmkKHBHyNseZfD67ceAoOBxr6yVZ6W0u0P EM8KgROhcQzP22Ob3aOc1LsrxqPEGuAkWq0vajmhPO8cCVfaOAbbD3dGYgmZu8Ol mZE7noGrA7vT/jB6PTZknl+b3X2Q1JITr01rfIeHfdZrderYVskhbzS3zqAGH/LL Qtc2oPRi5giZJb/9qmjld774Z8uDQ3P9WXW5G9LE+Nw29HPUrAJ4fMlDi09fiDP0 1XDcws+WT86LkvAy2yE/wj6Mdad7hwhceshDR4aOBHJKsdgiwUIj8cN6yRQuslr/ t7gyeFlu4haAH0hy5U0kxX8UzID3UlSWdJwlNLc54bL2qcpiFRHu5HI3j+W0PYFz /UIbVfgKBC2uf3PZ2lfV5oZsKDBOhiJnnqPHjC95fMxxlS/+03FvTZ7+Vr6OVBgi qEUnwdBfiIQJ/njT0TZKYajXyA2F7u+2Rq2O2Wz1fZ+oeN6Ep7eIPYAnfRyyDAhT p+8zpD4ibl6AILhpO30EwD8W/ntYXlD8hCNxIEcwPil2M/2IryN+H9aTdwENyl1J IRNo4dJ6xTzOYXQD0Wo+z5kV =gl5b -----END PGP MESSAGE----- schleuder-3.0.1/spec/fixtures/mails/encrypted+signed-mime/000077500000000000000000000000001304235634100235715ustar00rootroot00000000000000schleuder-3.0.1/spec/fixtures/mails/encrypted+signed-mime/thunderbird.eml000066400000000000000000000112001304235634100265740ustar00rootroot00000000000000Received: from [IPv6:::1] (localhost.localdomain [IPv6:::1]) by flutsch.local (Postfix) with ESMTP id 1DCDC801DD for ; Thu, 29 Dec 2016 15:09:43 +0100 (CET) To: schleuder@example.org From: paz Subject: encrypted+signed-mime test Openpgp: id=52507B0163A8D9F0094FFE03B1A36F08069E55DE Message-ID: Date: Thu, 29 Dec 2016 15:09:29 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:45.0) Gecko/20100101 Thunderbird/45.5.1 MIME-Version: 1.0 Content-Type: multipart/encrypted; protocol="application/pgp-encrypted"; boundary="V4nVnp5nddnPgg4bACDcs1kSu5wBuHpL9" This is an OpenPGP/MIME encrypted message (RFC 4880 and 3156) --V4nVnp5nddnPgg4bACDcs1kSu5wBuHpL9 Content-Type: application/pgp-encrypted Content-Description: PGP/MIME version identification Version: 1 --V4nVnp5nddnPgg4bACDcs1kSu5wBuHpL9 Content-Type: application/octet-stream; name="encrypted.asc" Content-Description: OpenPGP encrypted message Content-Disposition: inline; filename="encrypted.asc" -----BEGIN PGP MESSAGE----- hQIMA691X8Gl2MArAQ//WH7ld2syFOvYU0l0s5Mx+FyT74166+s1i5UK37HkzVTq /BPZcvB4IZ6KnKF/Gs67hs5n0I1r4o5ZgECLEso9Wpciw5uu9ES3nXm3x0C+tCZ1 aI0JgCnpq2kdY06/Zc7Tr3rvsn+xZxHo1SGiaS6sFt2dyFCFZpX8xidlOe13+vG7 29IMKoW2eZeF62W60MXy7HHoohWj0/bp3jB50G/kYcpka/10NYQkBWLm+DQ74Hxa CvN/WHO6W8srnJy+KnzJ3BsRTr4Js5sYIPnqao6UcGfr6iZQF1fDGUTlypKIoBkR DyuFXBGs+XW+Mk9S9X7DNTAPvTedciPSR3+TM0kjQmsam5e2Sm5k4W+wtdlFYlOP BqpYigAwMylQfQsTJ+M9Ds/0TtMWmPURzw15MI5a9fXGFT8DqZp9H9yIqZBoIkn2 c3cFJe7v9nVpnxVXVt81cM6+etYNeH7hX+bUxlrbHzJ+kLDCFYFoS/xIUCou8Eq3 z2nvsTV8CCcj+ao8ANU1Dxa7otvi4nCrR+kXvIB0YDpyBIYvbF/9WGeEY39rewWk Ooq7Uz3paJN+MPogkHgaLfmM4+AQbXG2STPmpPNpw2a+rxqVrbXWPexLGH79B1/n d29BvDNZ3xsuSRp36tyG+mFqzBTtDWunXXWD002b3a0xYQNyRfdUah6cpLpY4FaF AgwDAAAAAAAAAAABD/9bMI/4C+t+Rr4isBMNT2eqeJZuEuIt9RDOG/TEkilZbSx0 r8qACUiMxoHqEPpgSdbgRdjUkQCOlRd0LaPdBP8zbf7HRXtXY3ijLCYDGr4JebIQ M1wcW9YFRbWVJxKX5cM4VanojbbwBWDI+Z/xLQk942npxNm0P//Ol1gLxrqsPO/p FWUyBJvvXvx0cgLonjs9r/vc9iJxFIhfjaL+o7yQ8oYzbytiIIFFbgPr7TcvcPKv yeTfitJ7wcSxipGvNhWMoGBoIBYm3j/2/7irPXC1I3sNHgBggDGSDrWGfrj2gH51 MGRmZ0dBpERmmF8ynUK9HllW2xhNYIrA+bqyBunr+qLCS4zQHo0Uyn1xTZDohVtJ BZXcM9FHbOgRgfoHvbtKVcMhJ1PS7KjMF3/nhWrriGLXN783nm5pl4UceoMyKRR3 M1avmdKPvqP+2AyD/BQDKYLY/VHNjopYQ1EajW1tW7FSXf0A7j831Ir1/VdtU1w8 /Jb7xQ17HB8/zQFxdpXT+VM92KC1zVNMaOMuKWnQTdNDI26gjIumVzlYEpGlSX2w 52FgBBWeIvN5AygPy9UOQ1AdKgl/61G8A7znLt8cIfPZVZnJRL92AjGSsaYzVG3r 8X1FIprq5YV22tZI/Hx4XOQaan3T6SZB185jQCNnQgQ/kAcdXblrWSnrJjPCxYUC DAOnLuUXmtC57QEQAJPaOiE0wISLJkXx2c3jphvhCTRKaxPWf3vG6hUiWLzLNlWO 5Jk4Q5eTAgkYY/SYgy8yLYzi+Z5CSLNwZ62YFp8Dgu4HoLOc2DBlqvdF4HADNx8j HJdPHpGloEo1jJLVX58AnRi14WOb8VyG/a8DBRZFIj6leKPqDVHsizx4+8sJPHKg rgMK73JcsjgBP+h1fuAJ9smvPnmvO/QmWGyJ7p0OXHTIICbu2wWxhZxEVMkJPYQ7 9N4Hs9AUP45ZaGkB7+MfPyYpM27MpUQNgyuYIQk3bbkdPw/al/LgImYv65481GDK QoGch/EJ8fsagaEeFiAv72v3mndqhNvDG2eYdFN9VbAtN/8jH0uDKAdqLaUGGsUM mT64C1jJHivQf+YKsShKNwNSuruJr4HiQpn9MggV0zFLMyzZ5ufH2vRgoLWz8bHw s/pMo9YBLJ5LYjSkOQZeVakTplB7c5M9SGlqIrBfrmfttnJWU6In+co5OekGJKAp C73yKgaJK82RNdtujNY55gNa6UQjyILDFeXyvRowepMD866KjSOFxT9uy1+jV9pO AFXDsduMlZTSD0tYp14qsbJvgFzcrLYQSngMWVzR6+dMwj5AYdcHGNjoRYOHoQRq ISVfkfVz0HL/PVvRD0oFsPJPGhlCWLEcqiNQvo9oK6rNcbjEFcfFE4euV/AH0uoB GcoO41Y2XoE3jxiHYB5rO93B40IgZVJ0euFe5RcNCzB/ZNoAbOXEEvXP0KLVk9JQ XwutL7ToE4lx43dC8yxUQTqx3SiyneFz85giRkx/XfGaJ+Yn9PDqMbMCryVuWcUU nqM5uVzY5LtXdPOcfs2++ZF5OflWCe2ossPIRegRHvbhKEbBU2NlSEcvD0CVaGHL RyG+KymFrl+/jm8YBMpWIcYG9ofEhFQny0nLS4SDN/4HEL0g51b9G/ItyKWHaEXw dzBU4R0kl9LCe0mlle43Q4YU5QlwY/7glnVu0xaJ1PIw/4vTvRfeIFzbufE33CQS 59T9Lo5HDT+RuzAC1WbLQqaJon6sj7js2Hrwuh7gpYLA25REPOOHwig5+ZG2NoYd YEvpeWwG+vjO1fV5gpj5QRzx7qpfHc2V5mJHzy+1dmx5eg5/ZVCZvMQO84B38bJa KmC55g2u3YVYoELefEwZMq61IR8ECLjMCsdcvuqh1gNX6EmOG9uPvvKqVWcpXGud 2QWUAmRYBaCQumObwtnbf8JT2bo1PQrXn1yoJ95aWSteiBASK3y9N8s7T44FEZKj NFi+jOXo5aaUKOUp/2KD14sRXvU1PoTd9F/Ln6XGU1EIul2e1halMtnTSS3Ro2xM lOo9WVIoIJdBqdtgiCOujShuKzifktixw+QYuv8SSDh4/5GDcT4hR6gZ6YdGXbdG yAN/HuIAnHWPd4OmiCV026OlVTqgMv6QZfvvkMu4W7jPyqurLQd/3cro8QZYACAy K3YvB/qrdA6FJTFnSYffj2MpdbfRDj84sfn7jK8Knci+d27kucRVQPynkmmsNWXZ IWV5TMOw6FIiB+oP4mfO6otSD9uBZGaLzIgKsMO4W2NXBVykZpZ1rB+o7f1wtLcB k5Qqxzm847T6OmCIBVeBgTmUsdvf2X4rktIAtMjceaod2HpUUYryrCFZGxfLf/q0 0c7EoiNUGXMeKE+YncT4vZmqY6AvQH1kOj5O7BgqDdLD+Qr16n4hX24Ulkh/edAD DTI24s/hBthUdQ/XWkElMp3A9K1UQiex20mTeUReEyYBNQuhMbz8JAF6gkr77UyI t+Ol7OCxA/b+qxu/5uxDyFrUdI9h6R1CiSLV7sPgK0soQvDSfni0dCNOsyR1cpzn EH19SEGct0AypQvTljU25izTXbdCFqQFz1wNy7zznOCKJMgkNumWCJe7Xx00/rhN aVQb3L3HH6LfwoAosiwLm8gfaB+3nFWRm1Bj8pD1PTtodZfxI7rUujhu4kMfd2Xp GNTnClLCTomgPMRWS6Xt+II5Dihdd3Wwf2jyAPVi/1uvLqNooL8jZE0n28JiTH11 S5gzMbCimvgRyC9Q8yY+JXIILTNbK7ZUPq71+/SV19f+QO3fYX7a0DP9BNEkw/aW xdiqE90= =FY19 -----END PGP MESSAGE----- --V4nVnp5nddnPgg4bACDcs1kSu5wBuHpL9-- schleuder-3.0.1/spec/fixtures/mails/encrypted-inline/000077500000000000000000000000001304235634100226535ustar00rootroot00000000000000schleuder-3.0.1/spec/fixtures/mails/encrypted-inline/thunderbird.eml000066400000000000000000000056141304235634100256720ustar00rootroot00000000000000Received: from [IPv6:::1] (localhost.localdomain [IPv6:::1]) by flutsch.local (Postfix) with ESMTP id C4826801DD for ; Thu, 29 Dec 2016 15:19:35 +0100 (CET) To: schleuder@example.org From: paz Subject: encrypted-inline test Openpgp: id=52507B0163A8D9F0094FFE03B1A36F08069E55DE Message-ID: Date: Thu, 29 Dec 2016 15:19:35 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:45.0) Gecko/20100101 Thunderbird/45.5.1 MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit -----BEGIN PGP MESSAGE----- Charset: utf-8 hQIMA691X8Gl2MArAQ/+OQczLE7CgyUgZAg3dRWeTrNIkqlo7KMWxCyVfH310vKz rrTVFWbBeS0sOmMpN4cJSvJns2W+hJ9FnAdNtCPLC2zWhnN/4/hlWOSoE5A7cgHQ oqKcddbyCeOk0um869zL+O7GavQd3GhjwmFb9gOQVPUVGzNjkvlS/wMLGCM2287/ Fkh7TsFgmOWIY6hxZ1xI7wsk9CV33CVu4KnTUh/u+R76E1EROoPN/E5N6MYOGN0k DZ4i/qZHrnVnauFM4CfZnszY7JE6nY3QNIQohg/bMuZBeFIzacDruluIJQAhVGGf Le7W6uKPCUbvyQbJscq4wQiOA3fbdlCeScIVuR+pligZQHyCW6CVCLPlgxYnQUE+ vGOKFRsMXpjRfk/laSg+6v9r1WqaxleOW7XMUhvoQ0bya5DNnEPMhufSTCGZUv1y z11PFK+eeYWYRv+IpADRq0Bs7VxjYH4pe8iCRirboEH5F+ATW9PHSeuDQZb8e7Fw pu2oc/Zz/y9loT7UNbKyFQ1wTNNNlh/LEqXc1/KoSRAkgkLDfHD7BRG7SbXSLVIi yBD6hnQSqtgHpt0seXdUc4NRKYwJqeuTtC821YBHGFIVvqRZ6W9mHEfb+wqrHAdz OECSt0Nfn1OUQ8wcsdVv7Kv1cKVuH4VW483vj8dlipLRY+T6SqqQcM5V3buEGXaF AgwDAAAAAAAAAAABD/9AH8fdSTd1GiSOlArB9a3d+/MQ80uZQSQZZk1mqYWPS2+W FQH/8GuNDgXBtoUoVu4tR9FZsYhzSWvSXYF6wNP+OyatlZjVYxYbRfv0pgtlrmiD vtmFIJYAQpxwvta+CfKzQjM2UZeYbcPOVrA/t0AfscWdwX8E9FrhvoHzT1wfU7BR dGqj+IV2EJ3+8K6mpjLIvcGkhai8rbCF1vvWgMBMffUaNmCVuXaWPvoZ4kjZOjio TkN6cCmDul9z77XMUCMROTExTIkZseoSbzH6SD2bQcWRMvVHoWxJ0CdLh0nb0nsD jYFR9NT1mVLYedqNAfrR1xdos+Hcs8YbVikFH4ZJziHfbbFN4HkMNEABI6X38rsE NaDE8ea85IVJIhQKqrf3wOUB0VlqfZasfzXPKrYsynk+qil6py3NqebpBy0vuJs+ Esr5tiBoQGZp0U4Z3XKuR2yspNwVZE4ysWfVXfF2KI5/iTrowsqug5YK5iJw+fM3 OPX0o+bQoi0nWt9okCRRCISez/FNEDytebYdGX98trmJA+UDboTKj+yf12vpZd47 JYma/F8Bb/kXhKFAetIRv7q69I8P6wrCbBEEeMBR/aXVBLaYYgkDP74xPrggONCO 0BD7CBHH85y/BYLBMTeH1aOCjv7gXM+gOwFHnNtxJgPhfhwma2Sx6Ttfm6k9roUC DAOnLuUXmtC57QEQAKBKg7cKZKaFgBOys/2DAsqUJiHqnvAyDW7LerncA7yx3WWV cFeZCa+ecRcO1iLnJa6GO/SVex9UNJrLXiYKEYKD9hIIBFRuMIWuTmp9eU4QW0E9 /kjXCJxfN8gpDlnKzV6uK77JHuI4qr/ZpMLIYdJBJcRKLB3ufP5ryKTbZ50MjnZn YYvjIM/28hB0MIhw8y0WC4LFt2B8uCCdw6YmC0rchVyn4ByX9UJa+lOtxecHYps+ wH0FgncjRJF5KhmDYEIJhZ96R1fWfm6SC2jjWBxJzu0SYd9AX/6nnYV2mbH7WxB5 F0uDlm8MTx9I2dIypfhdkcPMXnuS8t4UY/RSA2JiGMIfTcZ31POIIXl2dmH+/74z jjq0qYyHrzF+U7uX1LN2EJBtDQVI19wcgGRUUB2ouJjIKv/iZYOIvg2YC46hBV9G 7W8k7yAUdW1sPDAQMSjLmaQIqK0Ou/UQJyxhuiy21BJAQWTFk+ikweoIWclYziKa Zlnkl4IywPmUB2TywUnNh9H9yWW+OQDWFaWEPRVpSY2SiBZpfzq5AQKy3rOVUS91 JwiQAW6WGobtHG+84IxblfGxFSGuDOzCcN5FTkMRK/H/6evYTioKTh9XrvnaKwkf HHuk6WF8sNP0GjxdYgi6C9iTK4ZzLfrVb9XQ/cuBxhmtR3ahGxgX7BG7AfNk0mcB hUiZoD55KEYRkCLEa3OTcg8HCDiqGn9TeLqL0Q5ZqSYydxlLxhFAOc57SmznzWRD wuW2uo0nN6EgrKrWe8MvKXyE2/0tbKqersCXEV0SnozBlom/zCs0zZ4AKChN1fYc gIXCntFc =7wno -----END PGP MESSAGE----- schleuder-3.0.1/spec/fixtures/mails/encrypted-mime/000077500000000000000000000000001304235634100223245ustar00rootroot00000000000000schleuder-3.0.1/spec/fixtures/mails/encrypted-mime/thunderbird.eml000066400000000000000000000074271304235634100253470ustar00rootroot00000000000000Received: from [IPv6:::1] (localhost.localdomain [IPv6:::1]) by flutsch.local (Postfix) with ESMTP id DAFE5801DD for ; Thu, 29 Dec 2016 15:13:34 +0100 (CET) To: schleuder@example.org From: paz Subject: encrypted-mime test Openpgp: id=52507B0163A8D9F0094FFE03B1A36F08069E55DE Message-ID: <51db1a44-b9b7-1390-b8ce-a0980101842d@nadir.org> Date: Thu, 29 Dec 2016 15:13:34 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:45.0) Gecko/20100101 Thunderbird/45.5.1 MIME-Version: 1.0 Content-Type: multipart/encrypted; protocol="application/pgp-encrypted"; boundary="9JN8w93dvNGWNV5ifxvV0OtHWs5PxOc8A" This is an OpenPGP/MIME encrypted message (RFC 4880 and 3156) --9JN8w93dvNGWNV5ifxvV0OtHWs5PxOc8A Content-Type: application/pgp-encrypted Content-Description: PGP/MIME version identification Version: 1 --9JN8w93dvNGWNV5ifxvV0OtHWs5PxOc8A Content-Type: application/octet-stream; name="encrypted.asc" Content-Description: OpenPGP encrypted message Content-Disposition: inline; filename="encrypted.asc" -----BEGIN PGP MESSAGE----- hQIMA691X8Gl2MArAQ//cRgrJgxEfj5+bld6ygNpf2COjffzI21YfhDUnR2WZTZ8 EqG22c0DMaLZ6SdQWhWHxRWKYs7y8chYWgoEb18FyLGYwGhalgAIccCta3PAjShJ loiw/Xjj2/x4crtJn1poXwVieZbmRp6Qf2QumAgtmTbBKphXH6ANSzzIQ0UyAcrg vbStsM3BzIdc4Ls+z9AYK06se1TU+Nf/MKrCaWoSVv538aUByr03GGtVDmmI9x5l GF7Di/AJBLUKNCJ0XCV/9j/QWY+mDo2xETlPemES2urXbSIY3uqIM5zsJERWvLck MPLb2p7Y472ZLnbzHSG/u/bhVBej7ngma5TkWbMfFNuP+u3FxsGTQYH+jchpSysj a/XsPrVVH8EvOSLG6yMH+1OERQ8YfVXbe+CwWQ6SsW4+61dRd3hzfFq0/9kkBOfM Zj9j7SsAdWgFB6jZPNsyGuf8BWwHSr2SGDH4QQL/yL6yC1MdREeebHHDbh1b9Khu qHWl4oZm5ZgJEHJOTI6dmwdSiOhOgNL0oZM9WfYxipxZsvHqEV+P15vVpzIvIOqE 7XJ259e3CQb9NdxQvd8/hxFttTy7NJyZDHdoGCT5AoKJj8TPSueH1rdhZHKPKwSE VdwGtBsvRW7Bls2628Z51b9tAzfUjdVPDHcvirq5o5tyGEt+QD3wSW/1t6oW9Y6F AgwDAAAAAAAAAAABD/0SrAtG0R4GFnn9ABEiylicBudYsZ1wNGrAHPQyT8rEik+8 XDGXx50+8+prHBraxvhSZjHA3mWZFmDrkvPJcXH7h/rLMYX/paJfR/0kCuE1wvKq nfjrN0IZOU3O6tKcvrZtgMvGo+CcDiIwaj+8MNQwLqe4Ni7SHnWUQKo8eEFeDBIR a3vJ6hY3rzmauoy9ybom+TVHbhUmZSVEN3P63qHH/caSyngml5yuAKEygvF4Azwn G/cvmGmdGjQdQ7THgB3AwOMagBC27UTCmk3RsW8ds1X4jcqiPvECnG7sd1angReE r1niZnpk62VTaKuAjWCVqGvQByjkEvfUgP6DAktBDHYAvRBYsBBkEvo40Lw0nDS8 Wny1vARq1ZODvpcExd7E8emse/aXlXl1LYvqciTEengeKlwZiBsyFTWyOzQuzbDB 1kgzJKfwWaCywj3syatU2hQerA3zIz1/QyFraJvKLN9iE9cSWzVpdoEQbHvg7Brd lYwqgAPza0sDzAL6sU2jMzPa2dle3hD6oT6o9flesv7DHqlne8QGjvw7mpXpGAjR on6uOsDka5Umd110VDdKRnn+pZRm8ZgMXwFfVofdhkRCFmDgpkYsbKYamiuGUfbc ZKB0FsSjnk9180MKhwHbkC70RigDXyyDdvNnb6cRyn87LiQ9Gjy3O4dcLGnxnYUC DAOnLuUXmtC57QEP/3+76B1RamNhN6RANCk6x4DE7D/yeeup0OP14ZIuGUz8ZzS0 E9mZH3+R5magQL1XmO+zBSRf5h781bEDqKdFa1JoBFBe7sNCIRGzf0SvqEsJRr18 I9wuXBPsAmNrn/MXhLwAeZLUq6EL0Qu0E0SiHGfwzM3en0Hy1gxpXsQz0B1v/Ebs 6tlXfp5nbNMNJi7Xl5kbT0QUycQrvJJ3QT2fyurGIurmMKAMgqWxlyZu5rrGBf6b VgWzF6Oau8EQ+9n0W470CZtyBL8L9j4qRLun6/LztgHX9zq37jzf/48Htj73yOio Oy722fxkrNUlZ2wGXnnM1AsrEDJ+bPvkx8MPCXihVCP2GyzQgC0E9iQdQlRmrrAN C3ayneRLDWD4+07x7323j5vdQbS25JQz+IOb1ikLlJXJDTlouVYn2XQEYSzTE5yk 2OyShsSDuTO43KtcLeo54iZhMZfoIdW6Lxqf/xS+x1SEVgZ6muF7/w2oqa2l3YTV lWfb1g75sq0XXHu4V95erVGUAcP2sTL5GA4jsw5yRRCWsLfiH0sqljQL2lnbo5bj n5F9RsjwHFkx8htm+mZBIsONBfFTjSw1ybofewaYiemXZIDtinEYxE91vPdvuFFn OEtUmRYWwPbqe+nWWx0d18LSJ8gl2fNkG7AghU9fpbe+FDwmB9SKDVmvEdkJ0sDm AYQn9GNMyq2bBurltTww3nb+D+zUdJovNWhMwRBZYRfP78e23pqZg7Y3/W8Q9rrg ZQznc9jLq/kBJ46lkwuA0M5zx68qQRavAiiZNMvTaU53kZA0D9i7XWHqET1yZyF0 PiCv5ni1gThKA+MvLKWUE/0y1cOJ2dpQVel1mf8mk8mmYTxrErlTbKGNea7G9wkB TRfUAurq95aRPkHbA8TY4XUN5C2qFUIps1ebynLTFOOBKJv/7DL4pl6cfGALkCO+ vIFsuT9uKwMzBJ50NFIu4UcX+Y/3EUIIxldN+gsule1xVzujLBPN/6GZvxOqy/Bc IphuBdLtroOzUFp3wyUMZHJ9A4SBC4Pc/OpI8yquSc7aPr0mWOAq+v1H8ZFYTvo1 QTq//vbVpQfSHcAKvssL/08OUMihL/z+aXyr2XN2BQzcJ6P9tn9uRRVXwbWF8rp5 UGGEE/kkmkC0DQEoSojFbpxFzycSZ8xT/+vTHyKyeK/YuDBBSnH3FaO6lhxsRA6Y SCO58jLsro2Pyaf/TsdwPzl/dqmbz90YU6QYa/Jm4DRa6jQDFPc= =jj1e -----END PGP MESSAGE----- --9JN8w93dvNGWNV5ifxvV0OtHWs5PxOc8A-- schleuder-3.0.1/spec/fixtures/mails/plain/000077500000000000000000000000001304235634100205055ustar00rootroot00000000000000schleuder-3.0.1/spec/fixtures/mails/plain/thunderbird.eml000066400000000000000000000055771304235634100235340ustar00rootroot00000000000000Return-Path: Delivered-To: n.siessegger@zeromail.org Received: from smtpin.nadir.org (smtpin.nadir.org [217.114.68.218]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by snail.zeromail.org (Postfix) with ESMTPS id D7C8EC001D for ; Tue, 27 Dec 2016 17:18:59 +0100 (CET) Received: from localhost (localhost [127.0.0.1]) by smtpin.nadir.org (Postfix) with ESMTP id AB2BDE60C1 for ; Tue, 27 Dec 2016 17:18:59 +0100 (CET) Received: from smtpin.nadir.org ([127.0.0.1]) by localhost (smtpin-na.nadir.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id GbNqpozJuesw for ; Tue, 27 Dec 2016 17:18:57 +0100 (CET) Received: from mout.web.de (mout.web.de [212.227.15.4]) (using TLSv1.2 with cipher DHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtpin.nadir.org (Postfix) with ESMTPS id A91EAE604F for ; Tue, 27 Dec 2016 17:18:57 +0100 (CET) Received: from nna.local ([80.187.107.60]) by smtp.web.de (mrweb004 [213.165.67.108]) with ESMTPSA (Nemesis) id 0McT8i-1c4NZw3xE8-00Hgam for ; Tue, 27 Dec 2016 17:18:57 +0100 To: n.siessegger@zeromail.org From: Nina Siessegger Subject: Test Message-ID: <8db04406-e2ab-fd06-d4c5-c19b5765c52b@web.de> Date: Tue, 27 Dec 2016 17:18:57 +0100 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.12; rv:45.0) Gecko/20100101 Thunderbird/45.5.1 MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 7bit X-Provags-ID: V03:K0:q07lv8kyV5vZ2Bkz3y99DthdSlg2NU0SQbMMZtb6PkyKzuO3TqS O2/qixJf4THt+J1OEiMuWOG71sYXBENA7fUZzy25Xy3mpDLgOJj55qE8+KOFuLfWPyb2OeI 39NYZ0+mLzIuJEiq4JnfYnF7s1SN5jv3CadFuO206MV7recIxXOjpxHPDvoyfzLMyxqRb5b jM6SATIl6pRdymPUNFsjQ== X-UI-Out-Filterresults: notjunk:1;V01:K0:9gbmm2iZtw4=:psOpZ/aY5zv6agYRXPOnce fJ6S+HVb03oKnQICo4EZZxwCuxBpd1xUHzJFid+KUGgvVNXPwpi5Z0hg57WQQYwhopWhY2eCm o9nJ6xMVS8CV8uX0lEXsoNM/JRt5oM1OvIIQuuuAzUDw7F1nnmGQPOMleAMAQ7GyvfirSZfx4 VrLOsF0vIZJOwoP5rZusgqrCteOJn5TC+Wy5UDb0w3ogzJQRsNLTN2Q6f5b7mzuT1zEVPdpU2 HMHvoRTVQpMYtfTjoVJlVKfh5Zf6eurPDFa980+/h5xQKf0+W+u1Z1JCe8zI45628TPPzQNN9 VvugURsiPDP3h3zxj/joo6O2l4Vk/30Mxr7k+PVhSLno4GNjS5oL52o+AG0ZRjD3fKWrnArXr j0emey1AI1EZij+FwwWyf0JF7ubRvN2qXRovU+ZYZ3fV1x56S5ZXdiuOqImHzgYcCdKQ1Mbj3 HX+jleuL6Gkgv2hdHcq++zErqiSbBhJKxPfDGAIwRpb/kAf3/sEGGhdLAlzlagXbbNgScVNsa PQIRuXvDim+eTk8Wb0Wh17flIzpgtz/bU8ZA61WLN8yt1v3aGevuwbMbO75dO/QOU4s4Yaaln 2LUsTYwtLKuqOY+reg6J3dZYyRwMTIl8961GcGXI3xHyHlKORKPk36b0/H0kHRi337qNl5mKF Z4WiQdpohcsGg0plEuZRLdxJ7knXQX3kZxO2FlTAhfPdWN1MDuQ+CiWi8MRwApOTQeR0nzRuR 2RAcnGeDuEgC3L/e6jkVJTvg45eulIeiIQPtEmx7eC3xs+wnifTCXqI4Mi9SDWtQxnPmWPPrh QAox8QKjkrSq/JyqvmWV7fCOJur8Wmms+oyr8g/MpOBqTMGbZumCNBa4UaGnSDTFon8Qg8djv c4C7eaiiU7Z6bS9xU/qA== Test schleuder-3.0.1/spec/fixtures/mails/signed-inline/000077500000000000000000000000001304235634100221275ustar00rootroot00000000000000schleuder-3.0.1/spec/fixtures/mails/signed-inline/thunderbird.eml000066400000000000000000000027501304235634100251440ustar00rootroot00000000000000Received: from [IPv6:::1] (localhost.localdomain [IPv6:::1]) by flutsch.local (Postfix) with ESMTP id 777D3801DD for ; Thu, 29 Dec 2016 15:21:42 +0100 (CET) To: schleuder@example.org From: paz Subject: signed-inline Openpgp: id=52507B0163A8D9F0094FFE03B1A36F08069E55DE Message-ID: Date: Thu, 29 Dec 2016 15:21:42 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:45.0) Gecko/20100101 Thunderbird/45.5.1 MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit -----BEGIN PGP SIGNED MESSAGE----- Hash: SHA512 This is a test. Umlauts: öäß. ♥★ -----BEGIN PGP SIGNATURE----- iQIzBAEBCgAdFiEEUlB7AWOo2fAJT/4DsaNvCAaeVd4FAlhlG/YACgkQsaNvCAae Vd4g5A/+Joc1sst26EGHhYL/MrYICBljcvFHWYHo81sr6ED1ek18eWiHtHGFhWvO HyJ0Ccu1ktdcyay7K70gpRNrjvs2d3l5sAAfgMyDPsvBrvWHKYUpiypcVG/7FRrD 1RVsQroh4xTo2wzWOjn47dT0EMhVZtg4jITSQn25dj8/D9viUeE3fiGFLtG5KLhU B1l+3A5cYrzaSRy9p6VoCPSEOCToZ34LJd9RkG/QKMD9JT/HcZN89sRVL0e4qI8e wQWsI6Oi7WNGiUA+p8Q5un90KNCqqumjkVxIiiFk5wSB4egba6JIBW43pKYrklRz wIXrNCk/RWcPJMTqIH9n+2IrDlKeYO/u+h/uh1y0SOTnImkmpfcgYsG3ggPnVask T2J8CCQ5Xy0HecyEFt5GO9pYG73vG9bX/YQ3cGN6yUJxmXzlQ02iS6UVx5g8Ypy2 NuZwQKFUGUeFta2mRlkKn8VZfqXrWv3VtKoaa1Zm0gZydTDA/37W5A2xrGk9IvjZ CUGx4jLqXbOFJ+zOthI9JJmaPP4sc7hUmegAjV1PJP6AaIZ+6TLwn+gY1z7SaRd2 59bA6Bnm4S7p8nV7oPwW/WaOUu3mF7y5w4Yd8DAS5BKC5UiBexrhY6mH71jXb+J9 VZOIwSEI9QvBKQM/7wULApVGq1kPR3K6XKAMvWiez3ayqsYUflk= =TSUJ -----END PGP SIGNATURE----- schleuder-3.0.1/spec/fixtures/mails/signed-mime/000077500000000000000000000000001304235634100216005ustar00rootroot00000000000000schleuder-3.0.1/spec/fixtures/mails/signed-mime/thunderbird.eml000066400000000000000000000043651304235634100246210ustar00rootroot00000000000000Received: from [IPv6:::1] (localhost.localdomain [IPv6:::1]) by flutsch.local (Postfix) with ESMTP id E276680329 for ; Thu, 29 Dec 2016 15:14:42 +0100 (CET) To: schleuder@example.org From: paz Subject: signed-mime test Openpgp: id=52507B0163A8D9F0094FFE03B1A36F08069E55DE Message-ID: Date: Thu, 29 Dec 2016 15:14:42 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:45.0) Gecko/20100101 Thunderbird/45.5.1 MIME-Version: 1.0 Content-Type: multipart/signed; micalg=pgp-sha512; protocol="application/pgp-signature"; boundary="DnUG3PvpPDcqa5kwpXHvXR1RjOgf17M3b" This is an OpenPGP/MIME signed message (RFC 4880 and 3156) --DnUG3PvpPDcqa5kwpXHvXR1RjOgf17M3b Content-Type: multipart/mixed; boundary="L98FCUdRgUPMMRg5CUqPXDjjv0kGAXPf0"; protected-headers="v1" From: paz To: schleuder@example.org Message-ID: Subject: signed-mime test --L98FCUdRgUPMMRg5CUqPXDjjv0kGAXPf0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable This is a test Umlauts: =C3=B6=C3=A4=C3=9F =E2=99=A5=E2=98=85 --L98FCUdRgUPMMRg5CUqPXDjjv0kGAXPf0-- --DnUG3PvpPDcqa5kwpXHvXR1RjOgf17M3b Content-Type: application/pgp-signature; name="signature.asc" Content-Description: OpenPGP digital signature Content-Disposition: attachment; filename="signature.asc" -----BEGIN PGP SIGNATURE----- iQIzBAEBCgAdFiEEUlB7AWOo2fAJT/4DsaNvCAaeVd4FAlhlGlIACgkQsaNvCAae Vd5VQQ/7BfL7kQA30QfQMoOLqnww/jX2aCeOIAisuPE0CU1oqxn00ntSIl7vMYIl Gu16gfwXrftbNxLfEwlLN6xZbzPJg+JefumOZglAqP9zHONxuwhO3QkaN0+K2Gfl ECDVAOxVZX52APoFkkgJjkUcHmCa2GeFROhgmDtCxeGjBTQlRg6WNu+xeJmR9GUG MQSaaMxHHSFxTmXQonRa5C1ATw9ZXekDOHK8LEO5hq04WEus0zio0a6fi+/xgTUS rJb+9el+pSOa9pZ5ZFfWWqFYuG5d4GNQpNeZQZjnUKKt0PvSw8g6Sqe0UvAeyjyg HRjDAsCijMaMql4+w6Ko7T8vl/C2By0bBeJfpZ1YkR+wa28+v2u3G8l2Mk7azkzT a8QHMzyTITv3D3MunpXSrp6Blh9X2u5PmkD9BkxHduuz/J7kgvufini8oqc3WP4U zZ8ZfU3ruon2le4UCRE/kWtDgCEK8+ppYqF/GSJZ6j1lO+tOfuWjwhotdtdG88/x bRS2GXecp7Jy8aosC0c0MHqZEMRUCKfN9lQLFf3oi+7f1AhDZbTzVnI+KGduZU3h /gk3kwLHFUd2epIjiWOygQyfpMQCqNvaskz8md3uH9P2F1mfHi1CaUB5Nq1gLegP GNmgErDQLDCoBnEW3aNsEM/BzPy2JRMi9k/sPXQ0GsTZhH62MV0= =CSzt -----END PGP SIGNATURE----- --DnUG3PvpPDcqa5kwpXHvXR1RjOgf17M3b-- schleuder-3.0.1/spec/fixtures/schleuder_at_example_public_key.txt000066400000000000000000000057441304235634100254330ustar00rootroot00000000000000mQINBFhGvz0BEADXbbTWo/PStyTznAo/f1UobY0EiVPNKNERvYua2Pnq8BwOQ5bS qvmWTb+9Fe9PRpmmqqKKeKjMX9yNjYZweqZ2Tda6C9B6shLme/bWotoXYCEjmP4t g9uWJmu2x+UHH+SSH752eDlTOtz9mZqNjcKlwvZtHcfu3FwvPQ7xqYt3f2Q/e8ES T2f02oI6uEuiBbuO0ZtLX2IMeygPc8ErBY+EAqJ9Q41SpO9rwGf3vKs7NZnE1Jjz 6myvVGf+NTdzpuk0tWxNSgESBeL86nhoKxwKSoCT12vcprMhZ5SPhkMed1nhLE31 rHiK7L9md85rzC5QD20T9HYhsjMcVrsC3v1u1UsfWI3TWi47S6P7XbWEunnMmDlJ g8xijEl2Em93YusMn+Yue2lASpwyB8yHJSn2iRvP3mX+JhKV6r+PNk4PuRzm/Qnu LCeljEllIyc4tnvEtVcl4SyVw8tkM8WMt8d5oAJtiP5CKndUhjR05F9VinS/T4Wq hQemigQsLOlYS9v1+xOlMWIPqkZenOZyjyY+qRHySN+NByzRUpQ6ruBsQrG3mwQV ddhlbLOH4YBl6v2rLAOOLfa+f+T2pZD/ogp6R0oy1ViJoQvZaL3aDviJ8+rSMgxu y0KnXwLxIQUGJFTUI/V8blHQXL/aaMl0G8GNehXWq4gzhiJCHq4suo93nQARAQAB tCpTY2hsZXVkZXIgVGVzdFVzZXIgPHNjaGxldWRlckBleGFtcGxlLm9yZz6JAjgE EwECACIFAlhGvz0CGwMGCwkIBwMCBhUIAgkKCwQWAgMBAh4BAheAAAoJENBjUEQP dZvTHBUP/0OTg+8oJV8O3nYN/ADK8OzVScK4jJhnEtmwZPvkhjZ2iiANaBmVK1Ll jZ5dEImwhGOsblYy2ZC+N3ZrgYmSJkBYcCmCKxwnBrDGozJOwtFg+68JMTn2tkfA bVKgNoBOVvvtd/dshPEBDl32NUiK/U5VWiie6lLRkMI/2ltpWgX8RannfX8Atmwc Wtycw2bLQaAJGGdTISdSo2wpw5D0ZM/Ud5+V4hiOkEGSsbabRwAdqLslZnEtC99n b3orR4ABeIDnifxFyIlOKX5lhAbNgYG7W33AyXFYuYiIaD2WDYmaccWKxbsx07Ed vHQ5AMvaVgtuMg8WXZXnGreFvZXg2ZYdNlElzt6b/GzPJ3OYcWizDVzbZF8Mlopr eBCW5aaGLQkGP5FlNuivMcai7xTUw+gB2lRDqpB2hP0zNrv7L7M/W5UhMf6MccVE WYJx28Bb+jy7jcJNkg34lO3ff1Pqw9j+h8W9//z7dA4FaZwMQD+pugjQ2a+xgpEQ 1M5JYrTg143xoK1ZZXH1x2HuebdpWqfc98gTo9foVdQbVe1FwSfrqm2c8uN8lmey vbU/mjEdixrSFf4uft0qK+dgswVyFQliwzQRT8cr9QIlOoCkcdvoW/MvQ9FaiF26 rGOJjjlB5/tsPpdY2V8Cz7Ej0iK9FlpYi3UtHSHCGLn710x8jg7WuQINBFhGvz0B EAC7MOUHnfgDEMyWV/R16sfprQ6ThqrFio3kHHzFQ2pg9jW3xFTzqiiiTKsVVua4 NJlweMMMxlzzj3r8fA6Ao5FmnVIHOkK3eUfcRRSoPRvubHPnIjdEek3AyR3WnixA lLx+shY1ZHQyaTKOlVk+7etii3wSRIB7p9J6qXCRbvgi4cKM/UcrEfWXtDvWISMW Cum88+tJ5TH4uKsl8iSgTCh6haqtPTc1c0mmacEAmmQq43J+s4FLvvj3f9kkWQir iFedulAtniQi+fQe3/G3U+BGegvCY9KcXQJsMgwV2m02G4zATrE5RFQq7hz8u0Xg nP+CT+yLRg339WwLZG20y8eKK2rngoeg+IUc1Bmjl25XMKLPYjye75DfVxAV0hH3 nVgpOTEXVTBYEcI6I/D+X8vNdHMK0xp1bjKAcWW6UgnToMVFuRfkRVfZYSWCJIMS 4X6icZb+VVRoy9Fflu9xAiApHIf/c7t1kC7Q0LfgMgcbYJwzBUu442U1RpnZ8WLy b+hJ+IakrcsCw9SZgtuJhYcWLb7Sb5SJfldxv0gTnOzkwOd01PolG/ASbPndk0hs HOsy+ijtrnciVDz3exwfvP6QY6cGIxJ6vUx57VfPzsPSS7MTd6Yyv3BYQn3MkIbA t+L6nHFLnZAwb6KWk6dHhZuSHiBJ0QdLu95MhhOzvOJ2swARAQABiQIfBBgBAgAJ BQJYRr89AhsMAAoJENBjUEQPdZvTHrYP/AvoY6qEsVBkN2N3O/6TMfJic8BH7TIg g5L+QrdreHFWvMGMjG6VwyFbSOK/3U9Y7TR3IKKHdvknrHGn4dT5bHAcCKmpV3jo PjDlo+UcwSW0gi7YITghHwVJ1AoK0yw3wD5N+Eq/xMUYw7tyGyipoQML5keauw4u sU/TMwFcGYQLrQ5c4CSDmfORHC34h0nNnG3olNWAkAloXTSOys5P6BZAr1B5WnFX 2wdxj0HkodBrE6OG8ZtDm7EE50iKKUO5sJMbfamesPVfWQFM4Rx08OdqnV/mmcy1 IcJFf4xsrC5u9fZsG3ovtTDWKyGVrST/g3JeVmvVWfMJfdwb838rp9fhAgqfO4lF L2kCGlZB0iW16DpAs22HOsJgUTtkf7TTvr/DXdGoamuTfckrcJESC7HBi8QDZL8S 9iNjgjr8zwmO35evJ/0JgoVhOjknwFzUAR9RGtYCT+IdZqmVcxIkeULjMzJkIwt5 J3W4uxiy6E9uAsZC9srg9sUZvYd1vavRZ/r55jFA8PdyzpITNPmZ3XrceGoV8T4N Qs7Zp5WOthe7oLoPP+UU17lDXHuH9rIUhzKl5QL2Z59H214VDRi5VcQLkn6OpzqW 6T/ikr8tewq5VLEY1G35G9XH1VHTS5VNpuoi/imJKl187AYCzA+EZQlnLvmk6WE6 /J2/tBYro55u =lep5 -----END PGP PUBLIC KEY BLOCK----- schleuder-3.0.1/spec/fixtures/v2list/000077500000000000000000000000001304235634100175205ustar00rootroot00000000000000schleuder-3.0.1/spec/fixtures/v2list/list.conf000066400000000000000000000021241304235634100213410ustar00rootroot00000000000000--- headers_to_meta: - :from - :to - :cc - :date receive_from_member_emailaddresses_only: false keep_msgid: true log_level: WARN log_syslog: false keywords_admin_only: - ADD-MEMBER - DELETE-MEMBER - DELETE-KEY - SAVE-MEMBERS - DEL-KEY myname: v2 List default_mime: MIME receive_authenticated_only: false receive_admin_only: false bounces_drop_all: false include_list_headers: true myaddr: v2list@example.org key_fingerprint: 0392CF72B345256BB730049789226FD6A42B2A7A log_file: list.log archive: false prefix_out: "[out]" log_io: false openpgp_header_preference: signencrypt prefix: "[v2]" bounces_drop_on_headers: x-spam-flag: "yes" receive_encrypted_only: false bounces_notify_admin: true max_message_size: 10240 gpg_password: te=65k:3N4*leKo[js:=[+p[DGFd%6ui send_encrypted_only: false receive_signed_only: false public_footer: "-- \nfooter" dump_incoming_mail: false include_openpgp_header: true admins: - key_fingerprint: C4D60F8833789C7CAA44496FD3FFA6613AB10ECE mime: MIME email: schleuder2@example.org encrypted_only: false prefix_in: "[in]" keywords_admin_notify: - ADD-KEY - UNSUBSCRIBE schleuder-3.0.1/spec/fixtures/v2list/list.log000066400000000000000000000000001304235634100211640ustar00rootroot00000000000000schleuder-3.0.1/spec/fixtures/v2list/members.conf000066400000000000000000000002061304235634100220170ustar00rootroot00000000000000--- - key_fingerprint: C4D60F8833789C7CAA44496FD3FFA6613AB10ECE mime: MIME email: schleuder2@example.org encrypted_only: false schleuder-3.0.1/spec/fixtures/v2list/pubring.gpg000066400000000000000000000141601304235634100216670ustar00rootroot00000000000000 XuDo)?jEFfńpH䆐mmH>RSUMbMG֜,k*'wǣ& ȅ^ncZo+őC?;5Uv*y~>`1luU{H>]XnY]bcA $Ӯn S_vXf :D(+^R 'p{u⽮er o¤15Lev%)5c1fj/[7/`€]j,^,<7SB'>A6dxއu <Ԗ9 pEpvqm!t Bf>q2nYXVg5_-zK'?::v;n;ﻄo>7Hs΅:Ӥ>1-]u`HU-qHV,@w})c sDW|i @vg(!d"'JzJ8/3v2 List (schleuder list) 8"XuD/   "o֤+*zOhudX[07{-y,ry|1R*q$VQtٓO"eQ:Ǐ5?PJ`"Mq$ӳ}fD%Ezaֱ" ZęŤ-'WtWo. ȕ36Nq!X6S[u[Ӥq_yl v8hfpoQ4'<>8GhcĤPՐOP}9NZ&U\>} [m֏V*'RIK2dv&d z~*(rEWPmo-+)d *7utq!o4ׯ0 ' ,8)gb>*2>kLɒctU"wdCnPx1tG֙}@UAT<;NLl5FI-qU"c|b댷VuґkbIV4f-v2 List (schleuder list) ;%/  XuD "o֤+*zLyB`A8(rP5r7ɥ͆\0#ځ mfQ'.WN8P:ԁ<_J%/t`J.胔ؿ)eW)&'CY,JcCts'k \Z!n [d*f09KR}_s"h}FGp%YUJ8'G$8"XuD/   "o֤+*zk8o''%Oih|/d~*Xh˃rW3:Nhnk7#M"|~'2yZx6J~ӵyq$(LqP}6~K?@!}zW%I8 WQ5wWrzdQÅxH%Z&K^3w^rJsudV-S^e?s? gbDr=ғ:"r)qQЬgcS[asK԰]X%'@B8#1[=OZŽN>|~M9[\Nt"Gyr<;)|Iqܥ>BڬeOr!y(ܾ9)C XuD ]LD-zN LR,B t(_ w[ǂP&!P^}7O6` 0gTM8لRB *P4I8W;~ Y'J_o.Kf ଇZL 3az'o-`{%q)qY-08Ä'H˪gX,kJX|ɒWI)D/kJ m+{d^|H-H!( Ϋa1~,D?҂(4*-j?*doyif)ݵPʞ7AwS=VKtr,*7bKqer 9?>^7y-ࠝaKZ O#o6kqL^~-chwhA)`S&7tܕ΅"֔&+`l/[k·VZ>Ts/G` QlTڀay^l2N>E(^gHĤ5#P-dKzP`i6P\> XuD.) "o֤+*z] XuD ŷ'B!o1g^"۝rV4)%l n24%#RKJcմ}o} :<nN)!X{1߽5LGXg(R3'7MV4Lmd+Kݱm^W/JM~cy%Beѷ\䇞rB֧p> 8ܯ+Yv8Llaj]Խ_ h'gS/$[g%5݇UEȵiF4*i Ubrp2Y ~a-S aw"H Dq}( *XF n ;QjCeOLj4$rL ى5R?UB }G9KF1wH|r)1D#tv?{alzBaza6?گ_eʓbc)q;_okFStTt"gAp*0maXucvjm}3P|4ͫm)Another Testuser 8"XN   a:zd 9~l^|55/J';,s V~YAɧ^zh{C %~okIY\?Xtngb#]J%D+#^<D,Nف LnBGMr2;q {vJk؅un澹` kIWu1Iޫx|Ve8Jܪ2PY[bzޑG)>x+ʹg!foFX` "VIݝNXE~b~>"%r1adZTr1]d"(RQϟ&x~<,;#EMnhP\7QAJ҂V̵TS=-id?2'v z+}~QM"*;Du"wa_p&՟eε,!nReЋ|=VVMlȻl^+GfC`gԺP4bxB޾N~ a5w{ ]G-r XC{ 9 bY)b/@h-s#.8.sFeq 6R BPf8?)3:޲|: x,;zM1+bZRU] GKG6U@.ZWǑ=p\ XN a:-z_3&Q)>b%eYJœIn`}wVXLܳ5puIVHZL,EYc6WNgyCRQ;q<`*ٓ$<3exn&LB/t3'ԉmbt5+jTZ[o3\* BeGy].4,}R㸂!_s&@ .@~T|DQevRy>"~1ʫ'LYׂ;۫Y dkOUzhdp|Lf&cH͍xIY_/wݔHf-V26CP2И\ "_K} MaJL*`BC?glԈOP1\sC&mwuD1\_k`8|ЏJv%+yK@!'&YנK{52G 1̛h@wWj)5nu~schleuder-3.0.1/spec/fixtures/v2list/random_seed000066400000000000000000000011301304235634100217160ustar00rootroot00000000000000Dw3!"\޴t^2e8+\l`~ucԇc{mPχQ#a[ qYز[,KR %M )94n2LdT  fdE}H1c:ߗ2T=ʙL6"k"h/!&JS8)=EH-&D]f TTf+Lc j`Y$Q/H/O/xz7q]8{ltST{ۢdy15`O斢/g-N,GdF'pYa!\feX,RM>K]ehH;r#$(S OHschleuder-3.0.1/spec/fixtures/v2list/secring.gpg000066400000000000000000000150361304235634100216560ustar00rootroot00000000000000=XuDo)?jEFfńpH䆐mmH>RSUMbMG֜,k*'wǣ& ȅ^ncZo+őC?;5Uv*y~>`1luU{H>]XnY]bcA $Ӯn S_vXf :D(+^R 'p{u⽮er o¤15Lev%)5c1fj/[7/`€]j,^,<7SB'>A6dxއu <Ԗ9 pEpvqm!t Bf>q2nYXVg5_-zK'?::v;n;ﻄo>7Hs΅:Ӥ>1-]u`HU-qHV,@w})c sDW|i @vg(!d"'JzJ8/.y:ʦ)`?^Jx n|S2;oQ'j}|Xrp~&1OwARI\5P D'-Ag9;wK9rVvlwi }UI# Fq- SSך-Rԉl*#+n2HoXBR ®" 2]ZBLJL#+ᰝo n,?eTʩEz2oO_5ioǽ=ԋ~4qFfכ> ^[ˉ&( )nTa9ק~9n>rRѳ:ͽчPXvȿάY'aAFTFuv"㸇, z,E1px]dG@c DTJ_[bY;k "{i3[z ifʌ6σF|-ڲkķ&^&c~PNyW|I;B*x첵Z7,,0!SMύEbNfKsrw[WVn]Z|o%3)Ub`Sgela§CgOi7hZƬH3t}H<5pԈYd\Hukް;bR}>[˖Yb*PfA#.RVD# 8] v?BIRSwqΧ02݁pt<K^V̶ Dj6KW0$CI޹S5L|z N.kEJlzF¶#аU@H&L[fk; u[MaAO/qchfn-rΪҘչ&KoGE ڕ{64`pn/U@wn2&xb2}pߌ5vky/$ ۛaqnL'v^x#Sܑ~qUt/.ɩ͇GH.+o[f g荝KGxNA~&v{:"B&z8"XuD/   "o֤+*zBb7L^ 9iH,@. Ae>.*d%Cv VnOc::|{'[[ڢz\ lH'0jF̘m15{QaX 1Ҭ/Xs;9;w1l"dXPªQ ;/@e&)S{KTТYl'NGC+\y+bsOD@?&<2}d_ᛥݓ/|ktB1 9n5g DFC@TgD3<;MYV.>XXoeА9c#Z1r>Mu_Iid%s$ϛN`~T89 LL?%M;0];`ڐ/pOQ6t r8p`(eP^Td9XCJfFm:5v2 List (schleuder list) 8"XuD/   "o֤+*zk8o''%Oih|/d~*Xh˃rW3:Nhnk7#M"|~'2yZx6J~ӵyq$(LqP}6~K?@!}zW%I8 WQ5wWrzdQÅxH%Z&K^3w^rJsudV-S^e?s? gbDr=ғ:"r)qQЬgcS[asK԰]X%'@B8#1[=OZŽN>|~M9[\Nt"Gyr<;)|Iqܥ>BڬeOr!y(ܾ9)C3v2 List (schleuder list) 8"XuD/   "o֤+*zOhudX[07{-y,ry|1R*q$VQtٓO"eQ:Ǐ5?PJ`"Mq$ӳ}fD%Ezaֱ" ZęŤ-'WtWo. ȕ36Nq!X6S[u[Ӥq_yl v8hfpoQ4'<>8GhcĤPՐOP}9NZ&U\>} [m֏V*'RIK2dv&d z~*(rEWPmo-+)d *7utq!o4ׯ0 ' ,8)gb>*2>kLɒctU"wdCnPx1tG֙}@UAT<;NLl5FI-qU"c|b댷VuґkbIV4f>XuD ]LD-zN LR,B t(_ w[ǂP&!P^}7O6` 0gTM8لRB *P4I8W;~ Y'J_o.Kf ଇZL 3az'o-`{%q)qY-08Ä'H˪gX,kJX|ɒWI)D/kJ m+{d^|H-H!( Ϋa1~,D?҂(4*-j?*doyif)ݵPʞ7AwS=VKtr,*7bKqer 9?>^7y-ࠝaKZ O#o6kqL^~-chwhA)`S&7tܕ΅"֔&+`l/[k·VZ>Ts/G` QlTڀay^l2N>E(^gHĤ5#P-dKzP`i6P\.y:ʦ)`tlv90GGQFax_5p!XE,>XI**.ַ%oB0”{PmP wCBߡ%hVa1 rC`@۳U#)a.\ܦii>`C$vT:*l m/9KWپ,*#]ҍ%"p`ՏgS*fǯ"x{Ը}:5C80D`0$  mPD7 cel-(!L?eb[Ơ/'!L2ϵށ1w6cۓ_ nD$ 3v+&(TY&iu t砥)ȓw=Iaʷ$8Ѳ38ȇDGT{~:O^rWnNUAa[9${ '~w?ـkT oa`\9V tmS>}um4-J a>콉!L %sL7Z%ߚ>W;oݽq@` e3xa'w8tѰ)GO`SfSaUb%pT9kwU'b џd~bSpe|}vg6oRQ] ܙ;{B鯨܉8d`x-.8%C>7*z*gj(}fKcU LN&O-VH׫KOXt˥V,6M1|;d^P"cR_/Ŗrqae)?sMb$g'4̇!4  4A '.! 㯙g`0CT0:s,aܥ¸(#a` O|0 1xW h,/ b ԝ,Nw nx(o>_۰%:)h]&PDBUtt]aF> XuD.) "o֤+*z] XuD ŷ'B!o1g^"۝rV4)%l n24%#RKJcմ}o} :<nN)!X{1߽5LGXg(R3'7MV4Lmd+Kݱm^W/JM~cy%Beѷ\䇞rB֧p> 8ܯ+Yv8Llaj]Խ_ h'gS/$[g%5݇UEȵiF4*i Ubrp2YHߍ,R:lBuele,- zGJ2X h2 nB_!$T#|nQ\htz֫3"B,w)(1:e3:)(1:d512:S҂3LaZT)+!:fSG$$;$:[ ;_u\nnhfu>tl*Z{}:w,tdĘz,rGx6+nGaiB{"ؗm fo "ݯC;BKqп4* v 5lp I{L'˜v SM!cWs4ǜFL.;άF NW8E2J@yWP*gh}H~L._$(S"µ˜;irͣ:UX1KdQEQ(? է>T)bӐ_aG;"vihI/ QЀ 22-aii ~(х&M$7xs_|7Y}mC>Ay[_slٞDgRJvrhAjF2H14xs&A<Ϟ4RS)(1:p257:x*]nR؁FCʩ}CU~6iJk#YDŽJ4Be. } bV}|W),qJyM߂:Y@!W/?0CDgCgd Cnװ|߁oO3*)"g8=e-Tt{1C%}r#zsy zge{;fa/ 瘑@?9'pi갗ݓ|6)(1:q257:B3"7GM>sec)CsR`fGt55|D YקՇu`0ygR=$8RhIa(mS(}yNf [ cHM] Awj?k"R!R5Ɲ 4i.3MTx`^*S;LS [5M12>G&T 礙c#\}Kix*Ib]zxmĊAԁr@E҅RGj@K)(1:u257:ºhJg!>Rx TfГ¿5y\"b|D{zpn"ŒG+;!# I1%$L(z=75sIid*r~K$YWP-$"SFz cҜ]l2 m6N9DT*EOF l dmNJ+j炇nW0bb|D{zpn"ŒG+;!# I1%$L(z=75sIid*r~K$YWP-$"SFz cҜ]l2 m6N9DT*EOF l dmNJ+j炇nW0b94w!_ڱ D0?ކS7Z6锄NvX|]ct1H,=~]u %cy5D6d]Yp1قx?gI(R7Y!)j^6 6뫺,,8)θWge?,9 W8K;}KZ?0IdUmseh8).QmNEy2NkI=:i*w\xjWhD&E[p^gN1pYbk{h Y6v`0ߚgL3? %"/ό1:_257:cUZM,O&h1^iX"G7VjA+S+6ȸp)9@</d`{x{p)"9BH9wrBLVRّGJx /ISiW<8fg=Ls61Q9t%UI>xLE_{:x2sHcȴo~~u_@1Or8^=ֳ׵3G5IeYb) NFdVо/5@r"n3g#_A[1:_257:*͌KKBo*䎳k.`%$Zd[\T۷p ˨U zqqh]2}FͤZ N:2 #Z\-l'R}{W}R>Ng~UFJ#jQpt/`axKHuRU/= Chx*:BVPQ@E:ZyV*Ѣ!"ZEqփרVCkY篘I*ހIHߍ,R:lBuele,- zGJ2X h2 nB_!$T#|nQ\htz֫3"B,w*Schleuder TestUser 8"XF=   cPDuC(%_v I¸gٰd6v h+R卞]cnV2ِ7vk&@Xp)+'ƣ2N` 19GmR6NVwl]5HNUZ(Rѐ?[iZE}lZܜfA gS!'Rl)ÐdwAG%fq- goz+GxEȉN)~é[}qXh= qŊŻ1ӱt9V n2]ٖ6Q%ޛl'sqh \d_ kx妆- ?e61ƢTCv36/?[!1qDYq[X_ϱ#"ZXu-!L|ְ XF=0̖WuŊ|Cj`5T(LV4px \z|fR:ByGE=ls"7DzM֞,@~5dt2i2Y>b|D{zpn"ŒG+;!# I1%$L(z=75sIid*r~K$YWP-$"SFz cҜ]l2 m6N9DT*EOF l dmNJ+j炇nW0b0%.!8!I ,7>MJûr( G.O3\ \$-I͜mՀ h]4O@PyZqWqAkCH)C}_YLtj_̵!El.nlz/0+!$r^VkY }+ ;E/iVA%:@m:`Q;dӾ]Ѩjk}+p d#c: ߗ' a:9'\QOfs$yB32d# y'uOnBug1@rΒ4zxj> B٧?׹C\{2gG^ U ~:?Ⓙ-{ TmQKM")*]|e g.a:+nschleuder-3.0.1/spec/gnupg/random_seed000066400000000000000000000011301304235634100177420ustar00rootroot00000000000000&~)|ie/^wFQ|8$٭lad>"hȪf -d`!Qcwvc rm zi e T} W n,ʮi>riD?5b󢾭hlD0K'<5sccxYMȺA.)ƅ`6/&Y@1M)dC.Ã~~=W=,/V u)w9d%1QX JA "FA)]lMtaXL,`OXK=+3+B:|Dko^k9Ű_n, (|&r8Hߍ,R:lBuele,- zGJ2X h2 nB_!$T#|nQ\htz֫3"B,wS҂3LaZT)+!:fSG$$;$:[ ;_u\nnhfu>tl*Z{}:w,tdĘz,rGx6+nGaiB{"ؗm fo "ݯC;BKqп4* v 5lp I{L'˜v SM!cWs4ǜFL.;άF NW8E2J@yWP*gh}H~L._$(S"µ˜;irͣ:UX1KdQEQ(? է>T)bӐ_aG;"vihI/ QЀ 22-aii ~(х&M$7xs_|7Y}mC>Ay[_slٞDgRJvrhAjF2H14xs&A<Ϟ4RSx*]nR؁FCʩ}CU~6iJk#YDŽJ4Be. } bV}|W),qJyM߂:Y@!W/?0CDgCgd Cnװ|߁oO3*)"g8=e-Tt{1C%}r#zsy zge{;fa/ 瘑@?9'pi갗ݓ|6B3"7GM>sec)CsR`fGt55|D YקՇu`0ygR=$8RhIa(mS(}yNf [ cHM] Awj?k"R!R5Ɲ 4i.3MTx`^*S;LS [5M12>G&T 礙c#\}Kix*Ib]zxmĊAԁr@E҅RGj@KºhJg!>Rx TfГ¿5y\"8"XF=   cPDuC(%_v I¸gٰd6v h+R卞]cnV2ِ7vk&@Xp)+'ƣ2N` 19GmR6NVwl]5HNUZ(Rѐ?[iZE}lZܜfA gS!'Rl)ÐdwAG%fq- goz+GxEȉN)~é[}qXh= qŊŻ1ӱt9V n2]ٖ6Q%ޛl'sqh \d_ kx妆- ?e61ƢTCv36/?[!1qDYq[X_ϱ#"ZXu-!L|ְXF=0̖WuŊ|Cj`5T(LV4px \z|fR:ByGE=ls"7DzM֞,@~5dt2i2Y>b|D{zpn"ŒG+;!# I1%$L(z=75sIid*r~K$YWP-$"SFz cҜ]l2 m6N9DT*EOF l dmNJ+j炇nW0b94w!_ڱ D0?ކS7Z6锄NvX|]ct1H,=~]u %cy5D6d]Yp1قx?gI(R7Y!)j^6 6뫺,,8)θWge?,9 W8K;}KZ?0IdUmseh8).QmNEy2NkI=:i*w\xjWhD&E[p^gN1pYbk{h Y6v`0ߚgL3? %"/όcUZM,O&h1^iX"G7VjA+S+6ȸp)9@</d`{x{p)"9BH9wrBLVRّGJx /ISiW<8fg=Ls61Q9t%UI>xLE_{:x2sHcȴo~~u_@1Or8^=ֳ׵3G5IeYb) NFdVо/5@r"n3g#_A[*͌KKBo*䎳k.`%$Zd[\T۷p ˨U zqqh]2}FͤZ N:2 #Z\-l'R}{W}R>Ng~UFJ#jQpt/`axKHuRU/= Chx*:BVPQ@E:ZyV*Ѣ!"ZEqփרVCkY篘I*ހI0%.!8!I ,7>MJûr( G.O3\ \$-I͜mՀ h]4O@PyZqWqAkCH)C}_YLtj_̵!El.nlz/0+!$r^VkY }+ ;E/iVA%:@m:`Q;dӾ]Ѩjk}+p d#c: ߗ' a:9'\QOfs$yB32d# y'uOnBug1@rΒ4zxj> B٧?׹C\{2gG^ U ~:?Ⓙ-{ TmQKM")*]|e g.a:+nschleuder-3.0.1/spec/gnupg/trustdb.gpg000066400000000000000000000025201304235634100177310ustar00rootroot00000000000000gpgXFH  5^*/H_n[ `mEGρ7-xt Y"ǂYcPDu! KM'L \ 9[܇schleuder-3.0.1/spec/schleuder.yml000066400000000000000000000003051304235634100171230ustar00rootroot00000000000000database: test: adapter: sqlite3 database: db/test.sqlite3 lists_dir: /tmp/schleuder-test/ listlogs_dir: /tmp/schleuder-test/ smtp_settings: port: 2523 keyserver: hkp://127.0.0.1:11371 schleuder-3.0.1/spec/schleuder/000077500000000000000000000000001304235634100164025ustar00rootroot00000000000000schleuder-3.0.1/spec/schleuder/integration/000077500000000000000000000000001304235634100207255ustar00rootroot00000000000000schleuder-3.0.1/spec/schleuder/integration/cli_spec.rb000066400000000000000000000113341304235634100230350ustar00rootroot00000000000000require "spec_helper" describe 'cli' do context "migrates a v2-list to v3.0" do it 'creates the list' do v2list_path = 'spec/fixtures/v2list' output = run_cli("migrate #{v2list_path}") list = Schleuder::List.by_recipient('v2list@example.org') expect(output).to be_present expect(list).to be_present end it "imports the public keys" do v2list_path = 'spec/fixtures/v2list' output = run_cli("migrate #{v2list_path}") list = Schleuder::List.by_recipient('v2list@example.org') expect(output).not_to match('Error:') keys = list.keys.map(&:fingerprint) expect(list.key.fingerprint).to eq '0392CF72B345256BB730049789226FD6A42B2A7A' expect(keys).to include 'C4D60F8833789C7CAA44496FD3FFA6613AB10ECE' end it "imports the secret key" do v2list_path = 'spec/fixtures/v2list' output = run_cli("migrate #{v2list_path}") list = Schleuder::List.by_recipient('v2list@example.org') expect(output).not_to match('Error:') expect(list.secret_key).to be_present expect(list.secret_key.fingerprint).to eq '0392CF72B345256BB730049789226FD6A42B2A7A' signed = GPGME::Crypto.new(:armor => true).clearsign('lala').read expect(signed).to match(/^-----BEGIN PGP SIGNED MESSAGE-----\n.*\n\nlala\n-----BEGIN PGP SIGNATURE-----\n.*\n-----END PGP SIGNATURE-----\n$/m) end it "imports the config" do v2list_path = 'spec/fixtures/v2list' output = run_cli("migrate #{v2list_path}") list = Schleuder::List.by_recipient('v2list@example.org') expect(output).not_to match('Error:') expect(list.to_s).to eq 'v2list@example.org' expect(list.log_level).to eq 'warn' expect(list.fingerprint).to eq '0392CF72B345256BB730049789226FD6A42B2A7A' expect(list.keywords_admin_only).to eq %w[subscribe unsubscribe delete-key] expect(list.keywords_admin_notify).to eq %w[add-key unsubscribe] expect(list.send_encrypted_only).to eq false expect(list.receive_encrypted_only).to eq false expect(list.receive_signed_only).to eq false expect(list.receive_authenticated_only).to eq false expect(list.receive_from_subscribed_emailaddresses_only).to eq false expect(list.receive_admin_only).to eq false expect(list.keep_msgid).to eq true expect(list.bounces_drop_all).to eq false expect(list.bounces_notify_admins).to eq true expect(list.include_list_headers).to eq true expect(list.include_openpgp_header).to eq true expect(list.openpgp_header_preference).to eq 'signencrypt' expect(list.headers_to_meta).to eq %w[from to cc date] expect(list.bounces_drop_on_headers).to eq({'x-spam-flag' => "yes"}) expect(list.subject_prefix).to eq '[v2]' expect(list.subject_prefix_in).to eq '[in]' expect(list.subject_prefix_out).to eq '[out]' expect(list.max_message_size_kb).to eq 10240 expect(list.public_footer).to eq "-- \nfooter" end it "imports the subscriptions" do v2list_path = 'spec/fixtures/v2list' output = run_cli("migrate #{v2list_path}") list = Schleuder::List.by_recipient('v2list@example.org') subscription_emails = list.subscriptions.map(&:email) expect(output).not_to match('Error:') expect(subscription_emails).to eq ['schleuder2@example.org'] end end context '#refresh_keys' do it 'updates one key from the keyserver' do list = create(:list) list.subscribe("admin@example.org", nil, true) list.import_key(File.read("spec/fixtures/expired_key.txt")) with_sks_mock do Cli.new.refresh_keys end mail = Mail::TestMailer.deliveries.first expect(Mail::TestMailer.deliveries.length).to eq 1 expect(mail.to_s).to include("Refreshing all keys from the keyring of list #{list.email} resulted in this") expect(mail.to_s).to include("98769E8A1091F36BD88403ECF71A3F8412D83889 was updated (new signatures)") teardown_list_and_mailer(list) end it 'reports errors from refreshing keys' do list = create(:list) list.subscribe("admin@example.org", nil, true) list.import_key(File.read("spec/fixtures/expired_key.txt")) Cli.new.refresh_keys mail = Mail::TestMailer.deliveries.first expect(Mail::TestMailer.deliveries.length).to eq 1 expect(mail.to_s).to include("Refreshing all keys from the keyring of list #{list.email} resulted in this") if GPGME::Ctx.sufficient_gpg_version?('2.1') expect(mail.to_s).to include("keyserver refresh failed: No keyserver available") else # The wording differs slightly among versions. expect(mail.to_s).to match(/gpgkeys: .* error .* connect/) end teardown_list_and_mailer(list) end end end schleuder-3.0.1/spec/schleuder/integration/keywords_spec.rb000066400000000000000000000220541304235634100241360ustar00rootroot00000000000000require "spec_helper" describe "user sends keyword" do it "x-subscribe without attributes" do list = create(:list) list.subscribe("schleuder@example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true) ENV['GNUPGHOME'] = list.listdir mail = Mail.new mail.to = list.request_address mail.from = list.admins.first.email gpg_opts = { encrypt: true, keys: {list.request_address => list.fingerprint}, sign: true, sign_as: list.admins.first.fingerprint } mail.gpg(gpg_opts) mail.body = "x-listname: #{list.email}\nX-SUBSCRIBE: test@example.org" mail.deliver encrypted_mail = Mail::TestMailer.deliveries.first Mail::TestMailer.deliveries.clear begin Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address) rescue SystemExit end raw = Mail::TestMailer.deliveries.first message = raw.setup(list.request_address, list) subscription = list.subscriptions.where(email: 'test@example.org').first expect(message.to).to eql(['schleuder@example.org']) expect(message.to_s).to include("test@example.org has been subscribed") expect(message.to_s).to match(/Fingerprint:\s*$/) expect(message.to_s).to include("Admin? false") expect(message.to_s).to include("Email-delivery enabled? true") expect(subscription).to be_present expect(subscription.fingerprint).to be_blank expect(subscription.admin).to eql(false) expect(subscription.delivery_enabled).to eql(true) teardown_list_and_mailer(list) end it "x-subscribe with attributes" do list = create(:list) list.subscribe("schleuder@example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true) ENV['GNUPGHOME'] = list.listdir mail = Mail.new mail.to = list.request_address mail.from = list.admins.first.email gpg_opts = { encrypt: true, keys: {list.request_address => list.fingerprint}, sign: true, sign_as: list.admins.first.fingerprint } mail.gpg(gpg_opts) mail.body = "x-listname: #{list.email}\nX-SUBSCRIBE: test@example.org 0x#{list.fingerprint} true false" mail.deliver encrypted_mail = Mail::TestMailer.deliveries.first Mail::TestMailer.deliveries.clear begin Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address) rescue SystemExit end raw = Mail::TestMailer.deliveries.first message = raw.setup(list.request_address, list) subscription = list.subscriptions.where(email: 'test@example.org').first expect(message.to).to eql(['schleuder@example.org']) expect(message.to_s).to include("test@example.org has been subscribed") expect(message.to_s).to match(/Fingerprint:\s+#{list.fingerprint.downcase}/) expect(message.to_s).to include("Admin? true") expect(message.to_s).to include("Email-delivery enabled? false") expect(subscription).to be_present expect(subscription.fingerprint).to eql(list.fingerprint.downcase) expect(subscription.admin).to eql(true) expect(subscription.delivery_enabled).to eql(false) teardown_list_and_mailer(list) end it "x-add-key with inline key-material" do list = create(:list) list.subscribe("schleuder@example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true) ENV['GNUPGHOME'] = list.listdir mail = Mail.new mail.to = list.request_address mail.from = list.admins.first.email gpg_opts = { encrypt: true, keys: {list.request_address => list.fingerprint}, sign: true, sign_as: list.admins.first.fingerprint } mail.gpg(gpg_opts) keymaterial = File.read('spec/fixtures/example_key.txt') mail.body = "x-listname: #{list.email}\nX-ADD-KEY:\n#{keymaterial}" mail.deliver encrypted_mail = Mail::TestMailer.deliveries.first Mail::TestMailer.deliveries.clear begin Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address) rescue SystemExit end raw = Mail::TestMailer.deliveries.first message = raw.setup(list.request_address, list) expect(message.to).to eql(['schleuder@example.org']) expect(message.to_s).to include("C4D60F8833789C7CAA44496FD3FFA6613AB10ECE: imported") teardown_list_and_mailer(list) end it "x-add-key with attached key-material" do list = create(:list) list.subscribe("schleuder@example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true) ENV['GNUPGHOME'] = list.listdir mail = Mail.new mail.to = list.request_address mail.from = list.admins.first.email gpg_opts = { encrypt: true, keys: {list.request_address => list.fingerprint}, sign: true, sign_as: list.admins.first.fingerprint } mail.gpg(gpg_opts) mail.body = "x-listname: #{list.email}\nX-ADD-KEY:" mail.add_file('spec/fixtures/example_key.txt') mail.deliver encrypted_mail = Mail::TestMailer.deliveries.first Mail::TestMailer.deliveries.clear begin Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address) rescue SystemExit end raw = Mail::TestMailer.deliveries.first message = raw.setup(list.request_address, list) expect(message.to).to eql(['schleuder@example.org']) expect(message.to_s).to include("C4D60F8833789C7CAA44496FD3FFA6613AB10ECE: imported") teardown_list_and_mailer(list) end it "x-resend" do list = create(:list, public_footer: "-- \nblablabla") list.subscribe("schleuder@example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true) ENV['GNUPGHOME'] = list.listdir mail = Mail.new mail.to = list.email mail.from = list.admins.first.email gpg_opts = { encrypt: true, keys: {list.email => list.fingerprint}, sign: true, sign_as: list.admins.first.fingerprint } mail.gpg(gpg_opts) content_body = "Hello again!\n" mail.body = "x-listname: #{list.email}\nX-resend: someone@example.org\n#{content_body}" mail.deliver encrypted_mail = Mail::TestMailer.deliveries.first Mail::TestMailer.deliveries.clear begin Schleuder::Runner.new().run(encrypted_mail.to_s, list.email) rescue SystemExit end raw = Mail::TestMailer.deliveries.first resent_message = raw.verify resent_message_body = resent_message.parts.map { |p| p.body.to_s }.join raw = Mail::TestMailer.deliveries.last message = raw.setup(list.email, list) expect(message.to).to eql(['schleuder@example.org']) expect(message.to_s).to include("Resent: Unencrypted to someone@example.org") expect(resent_message.to).to include("someone@example.org") expect(resent_message.to_s).not_to include("Resent: Unencrypted to someone@example.org") expect(resent_message_body).to eql(content_body + list.public_footer.to_s) teardown_list_and_mailer(list) end it "x-resend without x-listname" do list = create(:list) list.subscribe("schleuder@example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true) ENV['GNUPGHOME'] = list.listdir mail = Mail.new mail.to = list.email mail.from = list.admins.first.email gpg_opts = { encrypt: true, keys: {list.email => list.fingerprint}, sign: true, sign_as: list.admins.first.fingerprint } mail.gpg(gpg_opts) content_body = "Hello again!\n" mail.body = "X-resend: someone@example.org\n#{content_body}" mail.deliver encrypted_mail = Mail::TestMailer.deliveries.first Mail::TestMailer.deliveries.clear begin Schleuder::Runner.new().run(encrypted_mail.to_s, list.email) rescue SystemExit end raw = Mail::TestMailer.deliveries.first message = raw.setup(list.email, list) expect(message.to).to eql(['schleuder@example.org']) expect(message.to_s).not_to include("Resent: Unencrypted to someone@example.org") expect(message.to_s).to include("Your message didn't contain the mandatory X-LISTNAME-keyword, thus it was rejected.") teardown_list_and_mailer(list) end it "x-resend with wrong x-listname" do list = create(:list) list.subscribe("schleuder@example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true) ENV['GNUPGHOME'] = list.listdir mail = Mail.new mail.to = list.email mail.from = list.admins.first.email gpg_opts = { encrypt: true, keys: {list.email => list.fingerprint}, sign: true, sign_as: list.admins.first.fingerprint } mail.gpg(gpg_opts) content_body = "Hello again!\n" mail.body = "x-listname: somethingelse@example.org\nX-resend: someone@example.org\n#{content_body}" mail.deliver encrypted_mail = Mail::TestMailer.deliveries.first Mail::TestMailer.deliveries.clear begin Schleuder::Runner.new().run(encrypted_mail.to_s, list.email) rescue SystemExit end raw = Mail::TestMailer.deliveries.first message = raw.setup(list.email, list) expect(message.to).to eql(['schleuder@example.org']) expect(message.to_s).not_to include("Resent: Unencrypted to someone@example.org") expect(message.to_s).to include("Your message didn't contain a wrong X-LISTNAME-keyword. The value of that keyword muss match the email address of this list.") teardown_list_and_mailer(list) end end schleuder-3.0.1/spec/schleuder/integration/send_encrypted_spec.rb000066400000000000000000000007351304235634100252770ustar00rootroot00000000000000require "spec_helper" describe "user sends an encrypted message" do it "from thunderbird" do start_smtp_daemon list = create(:list) list.subscribe("admin@example.org", nil, true) message_path = 'spec/fixtures/mails/encrypted-mime/thunderbird.eml' error = run_schleuder(:work, list.email, message_path) mails = Dir.glob("#{smtp_daemon_outputdir}/mail-*") expect(error).to be_empty expect(mails.size).to eq 1 stop_smtp_daemon end end schleuder-3.0.1/spec/schleuder/integration/send_plain_spec.rb000066400000000000000000000007241304235634100244030ustar00rootroot00000000000000require "spec_helper" describe "user sends a plain text message" do it "from thunderbird" do start_smtp_daemon list = create(:list) list.subscribe("admin@example.org", nil, true) message_path = 'spec/fixtures/mails/plain/thunderbird.eml' error = run_schleuder(:work, list.email, message_path) mails = Dir.glob("#{smtp_daemon_outputdir}/mail-*") expect(error).to be_empty expect(mails.size).to eq 1 stop_smtp_daemon end end schleuder-3.0.1/spec/schleuder/runner_spec.rb000066400000000000000000000146411304235634100212600ustar00rootroot00000000000000require "spec_helper" describe Schleuder::Runner do describe "#run" do context "with a plain text message" do it "delivers the incoming message" do list = create(:list, send_encrypted_only: false) list.subscribe("admin@example.org", nil, true) mail = File.read("spec/fixtures/mails/plain/thunderbird.eml") error = Schleuder::Runner.new().run(mail, list.email) expect(Mail::TestMailer.deliveries.length).to eq 1 expect(error).to be_blank teardown_list_and_mailer(list) end it "has the correct headerlines" do list = create(:list, send_encrypted_only: false) list.subscribe("admin@example.org", nil, true) mail = File.read("spec/fixtures/mails/plain/thunderbird.eml") Schleuder::Runner.new().run(mail, list.email) message = Mail::TestMailer.deliveries.first expect(message.to).to eq ["admin@example.org"] expect(message.header.to_s.scan("admin@example.org").size).to eq 1 expect(message.from).to eq [list.email] teardown_list_and_mailer(list) end it "doesn't have unwanted headerlines from the original message" do list = create(:list, send_encrypted_only: false) list.subscribe("admin@example.org", nil, true) mail = File.read("spec/fixtures/mails/plain/thunderbird.eml") Schleuder::Runner.new().run(mail, list.email) message = Mail::TestMailer.deliveries.first expect(message.to).to eq ["admin@example.org"] expect(message.header.to_s.scan("zeromail").size).to eq 0 expect(message.header.to_s.scan("nna.local").size).to eq 0 expect(message.header.to_s.scan("80.187.107.60").size).to eq 0 expect(message.header.to_s.scan("User-Agent:").size).to eq 0 teardown_list_and_mailer(list) end it "doesn't leak the Message-Id as configured" do list = create(:list, send_encrypted_only: false, keep_msgid: false) list.subscribe("admin@example.org", nil, true) mail = File.read("spec/fixtures/mails/plain/thunderbird.eml") Schleuder::Runner.new().run(mail, list.email) message = Mail::TestMailer.deliveries.first expect(message.header.to_s.scan("8db04406-e2ab-fd06-d4c5-c19b5765c52b@web.de").size).to eq 0 teardown_list_and_mailer(list) end it "does keep the Message-Id as configured" do list = create(:list, send_encrypted_only: false, keep_msgid: true) list.subscribe("admin@example.org", nil, true) mail = File.read("spec/fixtures/mails/plain/thunderbird.eml") Schleuder::Runner.new().run(mail, list.email) message = Mail::TestMailer.deliveries.first expect(message.header.to_s.scan("8db04406-e2ab-fd06-d4c5-c19b5765c52b@web.de").size).to eq 1 teardown_list_and_mailer(list) end it "contains the list headers if include_list_headers is set to true" do list = create( :list, email: "superlist@example.org", send_encrypted_only: false, include_list_headers: true, ) list.subscribe("admin@example.org", nil, true) mail = File.read("spec/fixtures/mails/plain/thunderbird.eml") Schleuder::Runner.new().run(mail, list.email) message = Mail::TestMailer.deliveries.first expect(message.header["List-Id"].to_s).to eq "" expect(message.header["List-Owner"].to_s).to eq " (Use list's public key)" expect(message.header["List-Help"].to_s).to eq "" teardown_list_and_mailer(list) end it "contains the open pgp header if include_openpgp_header is set to true" do list = create( :list, send_encrypted_only: false, include_openpgp_header: true, ) list.subscribe("admin@example.org", nil, true) mail = File.read("spec/fixtures/mails/plain/thunderbird.eml") Schleuder::Runner.new().run(mail, list.email) message = Mail::TestMailer.deliveries.first expect(message.header["Openpgp"].to_s).to include list.fingerprint teardown_list_and_mailer(list) end it "does not deliver content if send_encrypted_only is set to true" do list = create(:list, send_encrypted_only: true) list.subscribe("admin@example.org", nil, true) mail = File.read("spec/fixtures/mails/plain/thunderbird.eml") Schleuder::Runner.new().run(mail, list.email) message = Mail::TestMailer.deliveries.first expect(message.body).to eq "" expect(message.parts.first.body.to_s).to include "You missed an email from "\ "#{list.email} because your subscription isn't associated with a "\ "(usable) OpenPGP key. Please fix this." teardown_list_and_mailer(list) end end it "delivers a signed error message if a subscription's key is expired on a encrypted-only list" do list = create(:list, send_encrypted_only: true) list.subscribe("admin@example.org", nil, true, false) list.subscribe("expired@example.org", '98769E8A1091F36BD88403ECF71A3F8412D83889') key = File.read("spec/fixtures/expired_key.txt") list.import_key(key) mail = File.read("spec/fixtures/mails/plain/thunderbird.eml") Schleuder::Runner.new().run(mail, list.email) message = Mail::TestMailer.deliveries.first verified = message.verify signature_fingerprints = verified.signatures.map(&:fpr) expect(Mail::TestMailer.deliveries.size).to eq 1 expect(message.to).to include('expired@example.org') expect(message.to_s).to include("You missed an email from ") expect(signature_fingerprints).to eq([list.fingerprint]) teardown_list_and_mailer(list) end it "delivers a signed error message if a subscription's key is not available on a encrypted-only list" do list = create(:list, send_encrypted_only: true) list.subscribe("admin@example.org", 'AAAAAAAABBBBBBBBBCCCCCCCCCDDDDDDDDEEEEEE', true) mail = File.read("spec/fixtures/mails/plain/thunderbird.eml") Schleuder::Runner.new().run(mail, list.email) message = Mail::TestMailer.deliveries.first expect(message.to).to eq ['admin@example.org'] expect(message.to_s).to include("You missed an email from #{list.email} ") teardown_list_and_mailer(list) end end end schleuder-3.0.1/spec/schleuder/unit/000077500000000000000000000000001304235634100173615ustar00rootroot00000000000000schleuder-3.0.1/spec/schleuder/unit/list_builder_spec.rb000066400000000000000000000043471304235634100234110ustar00rootroot00000000000000require "spec_helper" describe Schleuder::ListBuilder do it "creates a new, valid list" do listname = "list-#{rand}@example.org" adminaddress = 'schleuder2@example.org' adminkey = File.read('spec/fixtures/example_key.txt') list, messages = ListBuilder.new({email: listname, fingerprint: nil}, adminaddress, adminkey).run expect(list).to be_an_instance_of Schleuder::List expect(list).to be_valid expect(messages).to be_blank end it "returns an error-message if given an invalid email-address" do listname = "list-#{rand}" adminaddress = 'schleuder2@example.org' adminkey = File.read('spec/fixtures/example_key.txt') list, messages = ListBuilder.new({email: listname, fingerprint: nil}, adminaddress, adminkey).run expect(list).to be_nil expect(messages).to be_an_instance_of Hash expect(messages.keys).to eq ['email'] expect(messages.values).to be_present end it "creates a listdir for the list" do listname = "list-#{rand}@example.org" adminaddress = 'schleuder2@example.org' adminkey = File.read('spec/fixtures/example_key.txt') list, _ = ListBuilder.new({email: listname, fingerprint: nil}, adminaddress, adminkey).run expect(File.directory?(list.listdir)).to be true end it "creates a list-key with all required UIDs" do listname = "list-#{rand}@example.org" adminaddress = 'schleuder2@example.org' adminkey = File.read('spec/fixtures/example_key.txt') list, _ = ListBuilder.new({email: listname, fingerprint: nil}, adminaddress, adminkey).run uids = list.key.uids.map(&:email) expect(uids).to include(list.email) expect(uids).to include(list.request_address) expect(uids).to include(list.owner_address) end it "subscribes the adminaddress and imports the adminkey" do listname = "list-#{rand}@example.org" adminaddress = 'schleuder2@example.org' adminkey = File.read('spec/fixtures/example_key.txt') list, _ = ListBuilder.new({email: listname, fingerprint: nil}, adminaddress, adminkey).run subscription_emails = list.subscriptions.map(&:email) keys_emails = list.keys.map(&:uids).flatten.map(&:email) expect(subscription_emails).to eq [adminaddress] expect(keys_emails).to include(adminaddress) end end schleuder-3.0.1/spec/schleuder/unit/list_spec.rb000066400000000000000000000351551304235634100217040ustar00rootroot00000000000000require "spec_helper" describe Schleuder::List do BOOLEAN_LIST_ATTRIBUTES = [ :send_encrypted_only, :receive_encrypted_only, :receive_signed_only, :receive_authenticated_only, :receive_from_subscribed_emailaddresses_only, :receive_admin_only, :keep_msgid, :bounces_drop_all, :bounces_notify_admins, :include_list_headers, :include_list_headers, :include_openpgp_header, :forward_all_incoming_to_admins ].freeze it "has a valid factory" do list = create(:list_with_one_subscription) expect(list).to be_valid end it { is_expected.to respond_to :subscriptions } it { is_expected.to respond_to :email } it { is_expected.to respond_to :fingerprint } it { is_expected.to respond_to :log_level } it { is_expected.to respond_to :subject_prefix } it { is_expected.to respond_to :subject_prefix_in } it { is_expected.to respond_to :subject_prefix_out } it { is_expected.to respond_to :openpgp_header_preference } it { is_expected.to respond_to :public_footer } it { is_expected.to respond_to :headers_to_meta } it { is_expected.to respond_to :bounces_drop_on_headers } it { is_expected.to respond_to :keywords_admin_only } it { is_expected.to respond_to :keywords_admin_notify } it { is_expected.to respond_to :send_encrypted_only } it { is_expected.to respond_to :receive_encrypted_only } it { is_expected.to respond_to :receive_signed_only } it { is_expected.to respond_to :receive_authenticated_only } it { is_expected.to respond_to :receive_from_subscribed_emailaddresses_only } it { is_expected.to respond_to :receive_admin_only } it { is_expected.to respond_to :keep_msgid } it { is_expected.to respond_to :bounces_drop_all } it { is_expected.to respond_to :bounces_notify_admins } it { is_expected.to respond_to :include_list_headers } it { is_expected.to respond_to :include_openpgp_header } it { is_expected.to respond_to :max_message_size_kb } it { is_expected.to respond_to :language } it { is_expected.to respond_to :forward_all_incoming_to_admins } it { is_expected.to respond_to :logfiles_to_keep } it "is invalid when email is nil" do # Don't use factory here because we'd run into List.listdir expecting email to not be nil. list = Schleuder::List.new(email: nil) expect(list).not_to be_valid expect(list.errors.messages[:email]).to include("can't be blank") end it "is invalid when email is blank" do list = build(:list, email: "") expect(list).not_to be_valid expect(list.errors.messages[:email]).to include("can't be blank") end it "is invalid when email does not contain an @" do list = build(:list, email: "fooatbar.org") expect(list).not_to be_valid expect(list.errors.messages[:email]).to include("is not a valid email address") end it "normalizes the fingerprint" do fingerprint = " 99 991 1000 10" list = build(:list, fingerprint: fingerprint) expect(list.fingerprint).to eq "99991100010" end it "is invalid when fingerprint is blank" do list = build(:list, fingerprint: "") expect(list).not_to be_valid expect(list.errors.messages[:fingerprint]).to include("can't be blank") end it "is invalid when fingerprint is nil" do list = build(:list, fingerprint: nil) expect(list).not_to be_valid expect(list.errors.messages[:fingerprint]).to include("can't be blank") end it "is invalid when fingerprint contains invalid characters" do list = build(:list, fingerprint: "&$$$$67923AAA") expect(list).not_to be_valid expect(list.errors.messages[:fingerprint]).to include("is not a valid OpenPGP-fingerprint") end BOOLEAN_LIST_ATTRIBUTES.each do |list_attribute| it "is invalid if #{list_attribute} is nil" do list = build(:list) list[list_attribute] = nil expect(list).not_to be_valid expect(list.errors.messages[list_attribute]).to include("must be true or false") end it "is invalid if #{list_attribute} is blank" do list = build(:list) list[list_attribute] = "" expect(list).not_to be_valid expect(list.errors.messages[list_attribute]).to include("must be true or false") end end [:headers_to_meta, :keywords_admin_only, :keywords_admin_notify].each do |list_attribute| it "is invalid if #{list_attribute} contains special characters" do list = build(:list) list[list_attribute] =["$from", "to", "date", "cc"] expect(list).not_to be_valid expect(list.errors.messages[list_attribute]).to include("contains invalid characters") end it "is valid if #{list_attribute} does not contain special characters" do list = build(:list) list[list_attribute] = ["foobar"] expect(list).to be_valid end end it "is invalid if bounces_drop_on_headers contains special characters" do list = build(:list, bounces_drop_on_headers: {"$" => "%"}) expect(list).not_to be_valid expect(list.errors.messages[:bounces_drop_on_headers]).to include("contains invalid characters") end [:subject_prefix, :subject_prefix_in, :subject_prefix_out].each do |list_attribute| it "is invalid if #{list_attribute} contains a linebreak" do list = build(:list) list[list_attribute] = "Foo\nbar" expect(list).not_to be_valid expect(list.errors.messages[list_attribute]).to include("must not include line-breaks") end it "is valid if #{list_attribute} is nil" do list = build(:list) list[list_attribute] = nil expect(list).to be_valid end end it "is invalid if openpgp_header_preference is foobar" do list = build(:list, openpgp_header_preference: "foobar") expect(list).not_to be_valid expect(list.errors.messages[:openpgp_header_preference]).to include("must be one of: sign, encrypt, signencrypt, unprotected, none") end [:max_message_size_kb, :logfiles_to_keep].each do |list_attribute| it "is invalid if #{list_attribute} is 0" do list = build(:list) list[list_attribute] = 0 expect(list).not_to be_valid expect(list.errors.messages[list_attribute]).to include("must be a number greater than zero") end end it "is invalid if log_level is foobar" do list = build(:list, log_level: "foobar") expect(list).not_to be_valid expect(list.errors.messages[:log_level]).to include("must be one of: debug, info, warn, error") end it "is invalid if language is jp" do list = build(:list, language: "jp") expect(list).not_to be_valid expect(list.errors.messages[:language]).to include("must be one of: en, de") end it "is invalid if public footer include a non-printable characters" do list = build(:list, public_footer: "\a") expect(list).not_to be_valid expect(list.errors.messages[:public_footer]).to include("includes non-printable characters") end describe ".configurable_attributes" do it "returns an array that contains the configurable attributes" do expect(Schleuder::List.configurable_attributes).to eq [ :bounces_drop_all, :bounces_drop_on_headers, :bounces_notify_admins, :forward_all_incoming_to_admins, :headers_to_meta, :include_list_headers, :include_openpgp_header, :keep_msgid, :keywords_admin_notify, :keywords_admin_only, :language, :log_level, :logfiles_to_keep, :max_message_size_kb, :openpgp_header_preference, :public_footer, :receive_admin_only, :receive_authenticated_only, :receive_encrypted_only, :receive_from_subscribed_emailaddresses_only, :receive_signed_only, :send_encrypted_only, :subject_prefix, :subject_prefix_in, :subject_prefix_out, ] end it "does not contain the attributes email and fingerprint" do expect(Schleuder::List.configurable_attributes).to_not include(:email) expect(Schleuder::List.configurable_attributes).to_not include(:fingerprint) end end describe "#logfile" do it "returns the logfile path" do list = create(:list, email: "foo@bar.org") expect(list.logfile).to eq File.join(Schleuder::Conf.listlogs_dir, "bar.org/foo/list.log") end end describe "#logger" do it "calls the ListLogger" do list = create(:list) expect(Listlogger).to receive(:new).with(list) list.logger end end describe "#to_s" do it "returns the email" do list = create(:list, email: "foo@bar.org") expect(list.email).to eq "foo@bar.org" end end describe "#admins" do it "returns subscriptions of admin users" do list = create(:list) admin_subscription = create( :subscription, email: "admin@foo.org", admin: true, list_id: list.id, ) _user_subscription = create( :subscription, email: "user@foo.org", admin: false, list_id: list.id, ) expect(list.admins).to eq [admin_subscription] end end describe "#key" do it "returns the key with the fingerprint of the list" do list = create( :list, fingerprint: "59C7 1FB3 8AEE 22E0 91C7 8259 D063 5044 0F75 9BD3" ) expect(list.key.fingerprint()).to eq "59C71FB38AEE22E091C78259D06350440F759BD3" end end describe "#secret_key" do it "returns the secret key with the fingerprint of the list" do list = create( :list, fingerprint: "59C71FB38AEE22E091C78259D06350440F759BD3" ) expect(list.secret_key.secret?).to eq true expect(list.secret_key.fingerprint).to eq "59C71FB38AEE22E091C78259D06350440F759BD3" end end describe "#keys" do it "it returns an array with the keys of the list" do list = create(:list) expect(list.keys).to be_kind_of Array expect(list.keys.length).to eq 1 end it "returns an array of keys matching the given fingerprint" do list = create( :list, fingerprint: "59C71FB38AEE22E091C78259D06350440F759BD3" ) expect(list.keys).to be_kind_of Array expect(list.keys.first.fingerprint).to eq "59C71FB38AEE22E091C78259D06350440F759BD3" end end describe "#keys_by_email" do it "returns an array with the keys matching the given email address" do list = create(:list, email: "schleuder@example.org") expect(list.keys_by_email("schleuder@example.org").length).to eq 1 expect( list.keys_by_email("schleuder@example.org").first.fingerprint ).to eq "59C71FB38AEE22E091C78259D06350440F759BD3" end end describe "#import_key" do it "imports a given key" do list = create(:list) key = File.read("spec/fixtures/example_key.txt") expect { list.import_key(key) }.to change { list.keys.count }.by(1) list.delete_key("C4D60F8833789C7CAA44496FD3FFA6613AB10ECE") end end describe "#delete_key" do it "deletes the key with the given fingerprint" do list = create(:list) key = File.read("spec/fixtures/example_key.txt") list.import_key(key) expect do list.delete_key("C4D60F8833789C7CAA44496FD3FFA6613AB10ECE") end.to change { list.keys.count }.by(-1) end it "returns false if no key with the fingerprint was found" do list = create(:list) expect(list.delete_key("A4C60C8833789C7CAA44496FD3FFA6611AB10CEC")).to eq false end end describe "#export_key" do it "exports the key with the fingerprint of the list if no argument is given" do list = create(:list, email: "schleuder@example.org") expected_public_key = File.read("spec/fixtures/schleuder_at_example_public_key.txt") expect(list.export_key()).to include expected_public_key end end it "exports the key with the given fingerprint" do list = create(:list, email: "schleuder@example.org") expected_public_key = File.read("spec/fixtures/schleuder_at_example_public_key.txt") expect( list.export_key("59C71FB38AEE22E091C78259D06350440F759BD3") ).to include expected_public_key end describe "#check_keys" do it "adds a mesage if a key expires in two weeks or less" do list = create(:list) key = double("key") allow_any_instance_of(GPGME::Key).to receive(:subkeys).and_return(key) allow(key).to receive(:first).and_return(key) allow(key).to receive(:expires).and_return(Time.now + 7.days) allow(key).to receive(:fingerprint).and_return("59C71FB38AEE22E091C78259D06350440F759BD3") expect(list.check_keys).to eq "Expires in 6 days:"\ "\n0x59C71FB38AEE22E091C78259D06350440F759BD3 schleuder@example.org" end it "adds a message if a key is revoked" do list = create(:list) allow_any_instance_of(GPGME::Key).to receive(:trust).and_return(:revoked) expect(list.check_keys).to eq "Is revoked:"\ "\n0x59C71FB38AEE22E091C78259D06350440F759BD3 schleuder@example.org" end it "adds a message if a key is disabled" do list = create(:list) allow_any_instance_of(GPGME::Key).to receive(:trust).and_return(:disabled) expect(list.check_keys).to eq "Is disabled:"\ "\n0x59C71FB38AEE22E091C78259D06350440F759BD3 schleuder@example.org" end it "adds a message if a key is invalid" do list = create(:list) allow_any_instance_of(GPGME::Key).to receive(:trust).and_return(:invalid) expect(list.check_keys).to eq "Is invalid:"\ "\n0x59C71FB38AEE22E091C78259D06350440F759BD3 schleuder@example.org" end end describe ".by_recipient" do it "returns the list for a given address" do list = create(:list, email: "list@example.org") expect(Schleuder::List.by_recipient("list-owner@example.org")).to eq list end end describe "#sendkey_address" do it "adds the sendkey keyword to the email address" do list = create(:list, email: "list@example.org") expect(list.sendkey_address).to eq "list-sendkey@example.org" end end describe "#request_address" do it "adds the request keyword to the email address" do list = create(:list, email: "list@example.org") expect(list.request_address).to eq "list-request@example.org" end end describe "#owner_address" do it "adds the owner keyword to the email address" do list = create(:list, email: "list@example.org") expect(list.owner_address).to eq "list-owner@example.org" end end describe "#bounce_address" do it "adds the bounce keyword to the email address" do list = create(:list, email: "list@example.org") expect(list.bounce_address).to eq "list-bounce@example.org" end end describe "#gpg" do it "returns an instance of GPGME::Ctx" do list = create(:list) expect(list.gpg).to be_an_instance_of GPGME::Ctx end it "sets the GNUPGHOME environment variable to the listdir" do list = create(:list) list.gpg expect(ENV["GNUPGHOME"]).to eq list.listdir end end end schleuder-3.0.1/spec/schleuder/unit/subscription_spec.rb000066400000000000000000000057031304235634100234510ustar00rootroot00000000000000require "spec_helper" describe Schleuder::Subscription do BOOLEAN_SUBSCRIPTION_ATTRIBUTES = [ :delivery_enabled, :admin ].freeze it "has a valid factory" do subscription = create(:subscription) expect(subscription).to be_valid end it { is_expected.to respond_to :list_id } it { is_expected.to respond_to :email } it { is_expected.to respond_to :fingerprint } it { is_expected.to respond_to :admin } it { is_expected.to respond_to :delivery_enabled } it "is invalid when list_id is blank" do subscription = build(:subscription, list_id: "") expect(subscription).not_to be_valid expect(subscription.errors.messages[:list_id]).to be_present end it "is invalid when email is nil" do subscription = build(:subscription, email: nil) expect(subscription).not_to be_valid expect(subscription.errors.messages[:email]).to include("can't be blank") end it "is invalid when email is blank" do subscription = build(:subscription, email: "") expect(subscription).not_to be_valid expect(subscription.errors.messages[:email]).to include("can't be blank") end it "is invalid when email does not contain an @" do subscription = build(:subscription, email: "fooatbar.org") expect(subscription).not_to be_valid expect(subscription.errors.messages[:email]).to include("is not a valid email address") end it "normalizes the fingerprint" do fingerprint = " 99 991 1000 10" subscription = build(:subscription, fingerprint: fingerprint) expect(subscription.fingerprint).to eq "99991100010" end it "is valid when fingerprint is empty" do subscription = build(:subscription, fingerprint: "") expect(subscription).to be_valid expect(subscription.errors.messages[:fingerprint]).to be_blank end it "is valid when fingerprint is nil" do subscription = build(:subscription, fingerprint: nil) expect(subscription).to be_valid expect(subscription.errors.messages[:fingerprint]).to be_blank end it "is invalid when fingerprint contains invalid characters" do subscription = build(:subscription, fingerprint: "&$$$$123AAA") expect(subscription).not_to be_valid expect(subscription.errors.messages[:fingerprint]).to include("is not a valid OpenPGP-fingerprint") end BOOLEAN_SUBSCRIPTION_ATTRIBUTES.each do |subscription_attribute| it "is invalid if #{subscription_attribute} is nil" do subscription = build(:subscription) subscription[subscription_attribute] = nil expect(subscription).not_to be_valid expect(subscription.errors.messages[subscription_attribute]).to include("must be true or false") end it "is invalid if #{subscription_attribute} is blank" do subscription = build(:subscription) subscription[subscription_attribute] = "" expect(subscription).not_to be_valid expect(subscription.errors.messages[subscription_attribute]).to include("must be true or false") end end end schleuder-3.0.1/spec/sks-mock.rb000077500000000000000000000007001304235634100165000ustar00rootroot00000000000000#!/usr/bin/env ruby require 'sinatra/base' class SksMock < Sinatra::Base set :environment, :production set :port, 11371 set :bind, '127.0.0.1' set :logging, true get '/status' do 'ok' end get '/pks/lookup' do case params['search'] when '0x98769E8A1091F36BD88403ECF71A3F8412D83889' File.read('spec/fixtures/expired_key_extended.txt') else 404 end end # Run this class as application run! end schleuder-3.0.1/spec/smtp-daemon.rb000077500000000000000000000032311304235634100171770ustar00rootroot00000000000000#!/usr/bin/env ruby # # This script is a very simple SMTP-daemon, that dumps every incoming email # into the given directory. It's meant to capture messages from schleuder-lists # during test-runs. require 'socket' require 'open3' trap ("INT") { exit 0 } def usage puts "Usage: #{File.basename(__FILE__)} portnum output-directory" exit 1 end # get args if ARGV.first.to_s.match('(-h|--help|help)') || ARGV.empty? usage end port = ARGV.first.to_i if port == 0 usage end outputdir = ARGV[1].to_s if outputdir.empty? usage elsif ! File.directory?(outputdir) puts "Not a directory: #{outputdir}" exit 1 end begin # run the server server = TCPServer.new("127.0.0.1", port) # receive input while (connection = server.accept) input = '' recipient = '' connection.puts "220 localhost SMTP" begin while line = connection.gets line.chomp! case line[0..3].downcase when 'ehlo', 'helo' connection.puts "250 localhost" when 'mail', 'rset' connection.puts "250 ok" when 'rcpt' recipient = line.split(':').last.gsub(/[<>\s]*/, '') connection.puts "250 ok" when 'data' connection.puts "354 go ahead" when 'quit' connection.puts "221 localhost" when '.' filename = File.join(outputdir, "mail-#{Time.now.to_f}") # puts "New message to #{recipient} written to #{filename}" IO.write(filename, input) connection.puts "250 ok" else input << line + "\n" end end rescue IOError end connection.close end rescue => exc $stderr.puts exc exit 1 end schleuder-3.0.1/spec/spec_helper.rb000066400000000000000000000052341304235634100172460ustar00rootroot00000000000000ENV['SCHLEUDER_ENV'] ||= 'test' ENV['SCHLEUDER_CONFIG'] = 'spec/schleuder.yml' ENV["SCHLEUDER_LIST_DEFAULTS"] = "etc/list-defaults.yml" require 'bundler/setup' Bundler.setup require 'schleuder' require 'schleuder/cli' require 'database_cleaner' require 'factory_girl' RSpec.configure do |config| config.expect_with :rspec do |expectations| expectations.include_chain_clauses_in_custom_matcher_descriptions = true end config.order = :random config.include FactoryGirl::Syntax::Methods config.before(:suite) do FactoryGirl.find_definitions end config.before(:suite) do DatabaseCleaner.strategy = :deletion DatabaseCleaner.clean_with(:truncation) end config.around(:each) do |example| DatabaseCleaner.cleaning do example.run end end config.after(:each) do |example| FileUtils.rm_rf(Dir["spec/gnupg/pubring.gpg~"]) end config.after(:suite) do cleanup_gnupg_home stop_smtp_daemon end # rspec-mocks config goes here. You can use an alternate test double # library (such as bogus or mocha) by changing the `mock_with` option here. config.mock_with :rspec do |mocks| mocks.verify_partial_doubles = true end def cleanup_gnupg_home ENV["GNUPGHOME"] = nil FileUtils.rm_rf Schleuder::Conf.lists_dir end def smtp_daemon_outputdir File.join(Conf.lists_dir, 'smtp-daemon-output') end def with_sks_mock pid = Process.spawn('spec/sks-mock.rb', [:out, :err] => ["/tmp/sks-mock.log", 'w']) sleep 1 yield Process.kill 'TERM', pid Process.wait pid end def start_smtp_daemon if ! File.directory?(smtp_daemon_outputdir) FileUtils.mkdir_p(smtp_daemon_outputdir) else # Try to kill it, in case it's still around (this occurred on some # systems). stop_smtp_daemon end daemon = File.join('spec', 'smtp-daemon.rb') pid = Process.spawn(daemon, '2523', smtp_daemon_outputdir) pidfile = File.join(smtp_daemon_outputdir, 'pid') IO.write(pidfile, pid) end def stop_smtp_daemon pidfile = File.join(smtp_daemon_outputdir, 'pid') if File.exist?(pidfile) pid = File.read(pidfile).to_i Process.kill(15, pid) FileUtils.rm_rf smtp_daemon_outputdir end end def run_schleuder(command, email, message_path) `SCHLEUDER_ENV=test SCHLEUDER_CONFIG=spec/schleuder.yml bin/schleuder #{command} #{email} < #{message_path} 2>&1` end def run_cli(command) `SCHLEUDER_ENV=test SCHLEUDER_CONFIG=spec/schleuder.yml bin/schleuder #{command} 2>&1` end Mail.defaults do delivery_method :test end def teardown_list_and_mailer(list) FileUtils.rm_rf(list.listdir) Mail::TestMailer.deliveries.clear end end