Amavisd-new Documentation Bits and Pieces

8/6/2019 Amavisd-new Documentation Bits and Pieces

1/29

amavisd-new documentation bits and pieces

The most recent version of this document is available athttp://www.ijs.si/software/amavisd/amavisd-new-docs.htmlPerforming mail checksActing on mail checks results

Tag, tag2 and kill levelsQuarantineReleasing from a quarantineRedirecting malware to a different mailbox -- plus addressingHard black- and whitelisting senders regarding spamSoft black- and whitelisting senders regarding spam -- @score_sender_mapsConfiguration variablesPolicy banksPutting policy banks to good use -- examples$max_requestsSetting up DKIM mail signing and verificationDKIM: For the impatient - signing from scratchDKIM: For the impatient - replacing signing by dkim-milter with signing by amavisdDKIM: Implementation and mail flow

DKIM: Configuring multiple mail paths in PostfixDKIM: Configuring multiple mail paths in amavisdDKIM: Hooking-in dkim-milter (optional)DKIM: Setting up DKIM signature verification in amavisdDKIM: Setting up DKIM signing in amavisdDKIM: Putting DKIM verification to good use in SpamAssassinDKIM: Some experience with DKIM and DomainKeysDKIM: LinksPerforming mail checks

The following checks on mail are availablemail header validity checksbanned names and types checks

virus checksspam checksis sender white- or blacklisted (regarding spam)

Although checks are presently not performed in parallel, it is best to consider the order of theirevaluation unspecified (unknown). Besides possible future parallel implementation, anotherreason is the caching of results, where subsequent mail with the same contents may benefitfrom earlier checks if validity of these check results has not yet expired -- so a check resultmay be instantly available, regardless of whether it has been asked for or not.

Using configuration variables @bypass_virus_checks_maps,@bypass_banned_checks_maps, @bypass_header_checks_maps and@bypass_spam_checks_maps each recipient (or administrator on their behalf) may suggestthat certain tests are not needed, primarily for performance reasons. Although the

@bypass_*_checks_maps pertain to individual recipients, a mail check is an operation doneon the whole message, regardless of the number of recipients and their individualpreferences. Suggestion by some of the recipients that certain check is not needed (is to bebypassed) does not guarantee the test will not be performed.

Similarly the (hard) blacklisting or whitelisting of sender address may make running spamcheck unnecessary, but it does not guarantee the spam check result will not be available forsubsequent decisions.

There are two primary reasons why a check result may still be available despite the bypasshint or a sender being black- or whitelisted:a check result from some previous mail with the same contents has been cached and is stillvalid;

when mail has multiple recipients and not all of them agree that a check should be bypassed.

The amavisd-new program is allowed to skip some check for performance reasons if all


2/29

recipients agree that a check is not necessary (that it may be bypassed), or if the outcome ofa check to be skipped could not influence further mail processing and delivery/non-delivery ofthe message (as is the case of a sender being black- or whitelisted regarding spam check).

For example spam checks may be skipped if it is already known that a mail is infected. This isan implementation and optimization issue, and no guarantee is given about interdependency

of checks. Future version may use a different strategy of performing checks (e.g. somechecks may be performed in parallel), as long as a change does not affect the final outcome.Acting on mail checks results

Based on the outcome of mail checks performed during mail analysis or cached from previousmail with the same contents, and based on global settings and individual recipientpreferences, the program now decides what action to perform next. As described in theprevious section, not all results of checks are necessarily known (e.g. if all recipients voted forsome check to be bypassed). For the purpose of deciding further actions, unknown results ofa check are considered equivalent to negative (false) results, i.e. skipped virus check istreated the same as non-infected mail, bypassed spam check is equivalent to low spam score(ham).

The following decisions are made at this stage:

whether a mail should be quarantined and how;whether an administrator (and which administrator) should receive a notification (and whichnotification);whether recipients should receive a notification;

and regarding mail delivery and/or sender (non)delivery notifications:whether a mail should be delivered to each recipient or not;whether delivered mail should be modified (header edits, defanging);whether a sender should receive a (non)delivery notification (bounce);what should be the final status code returned to the mailer (reject/pass).

For the purpose of deciding on these actions, a mail is classified based on all available checksresults. It is quite possible that more than one check results would be positive (e.g. virus and

banned and bad header, or spam and bad header, or virus and spam), yet a mail isconsidered to be only in one category. The logic is currently hard-wired into the program andcan not be influenced by configuration variables. The following order is used, the first conditionmet decides the outcome:a virus is detected: mail is considered infected;contains banned name or type: mail is considered banned;spam level is above kill level for at least one recipient, or a sender is blacklisted: mail isconsidered spam;bad (invalid) headers: mail is considered as having a bad header.

This decision order explains why amavisd-new is not free to skip (to optimize away) viruschecks if a presence of a banned name or a bad header is already known or can easily bedetermined. The order was chosen with the intention that a more informative or a strongerassertion is the one to base further mail delivery on, and to be quoted in notifications and in

the log. Even at the expense of possibly longer processing time, it is more important todeclare a mail infected than complain about a bad header, a banned executable or spamycontents.

The determined mail category now governs further action. Administrators are notified ifenabled for the category, mail is quarantined if quarantining if enabled for the category,recipients are notified if enabled for the category.

Next a mail delivery is attempted. A decision to deliver depends on mail category and onglobal and individual recipient preferences. The global setting $final_*_destiny=D_PASS or aper-recipient setting @*_lovers_maps ensure mail delivery for corresponding mail categoryeven if mail would otherwise be blocked for being infected or banned or spam or having a badheader.

A mail that is decided to be passed to an individual recipient undergoes some simple headerediting which happens on-the-fly during mail forwarding. Certain mail header fields may be


3/29

inserted or removed, or an existing header field (e.g. Subject) may be modified. This headerediting may be different for each recipient even in multi-recipient messages. If necessary, amulti-recipient mail is split into more than one forwarding transaction, grouping (clustering)recipients with same settings into one SMTP transaction.

Based on decisions to forward or to block mail to each recipient, and on the global setting for

the mail category ($final_*_destiny=D_BOUNCE or D_REJECT), the sender (non)deliverynotification is now prepared in case of D_BOUNCE, and MTA receives a 2xx status (success);or in case of D_REJECT the MTA receives a 5xx (reject) status and preparing sendernotifications is thus delegated to MTA (not recommended in post-queue or dual-MTA contentfiltering setup).

Even in cases of mail non-delivery when a (non-)delivery status notification (DSN) for thesender should have been prepared and sent, there are certain exceptions where the DSN issuppressed, which makes mail effectively lost as far as the sender and the recipient areconcerned (but quarantining is not affected):when $final_*_destiny=D_DISCARD;when mail is infected and the detected virus name matches the@viruses_that_fake_sender_maps (unconditionally true by default);when spam score exceeds level determined by @spam_dsn_cutoff_level_maps for all

recipients;when mail is coming from a mailing list, as determined by examining a mail headerPrecedence: for containing string 'bulk' or 'list' or 'junk';tag, tag2 and kill levels

When SpamAssassin is called upon to analyze a mail message, it returns a spam score(spam level, hits), which is a numeric representation of spaminess. The higher the number,the more spamy the message is considered. Small numbers near zero or negative indicate aclean message, colloquially called ham. Spam score is a characteristic of the whole message,and does not depend on recipient preferences. SpamAssassin is called only once for eachmessage regardless of the number of recipients.

To determine further course of action, amavisd-new compares the spam score to three

numeric values: tag level, tag2 level and kill level. These values may be different for eachrecipient, and further actions may be different for each recipient. If necessary, the mailforwarding is split into more than one transaction to cater for different recipient preferences.tag levelif spam score is at or above tag level, spam-related header fields (X-Spam-Status, X-Spam-Level) are inserted for local recipients; undefined (unknown) spam score is interpreted aslower than any spam score;tag2 levelif spam score is at or above tag2 level, spam-related header fields (X-Spam-Status, X-Spam-Level, X-Spam-Flag and X-Spam-Report) are inserted for local recipients, and X-Spam-Flagand X-Spam-Status bear a YES; also recipient address extension (if enabled) is tacked ontorecipient address for local recipients; for these actions to have any effect, mail must beallowed to be delivered to a recipient;kill level

if spam score is at or above kill level, mail is blocked; and sender receives a nondeliverynotification unless spam score exceeds dsn cutoff level.

The general idea is that kill level is what controls the main actions as far as MTA andamavisd-new is concerned (regardless of what recipients' MUA later does with the mail).

Reaching kill level for at least one recipient controls the following:mail gets quarantined (unless disabled)spam administrator gets a notification (unless disabled)ContentSpamMsgs counter is incrementedsender gets a notification if warnspamsender is true and $final_spam_destiny is D_PASSif message is not delivered, sender gets a nondelivery notification (suppressed under certainconditions)

the main log entry says: Passed/Blocked SPAM.

On the other hand the tag2 level just adds some mark to the passed mail (only for local


4/29

recipients), which recipient or his MUA may decide to act on or not. Specifically:Subject header field is modified (unless disabled)X-Spam-Flag and X-Spam-Status header field get a Yesaddress extension for spam gets tacked on the recipient addressspam defanging is done (unless disabled)the main log entry says: Passed/Blocked SPAMMY.

For mail below kill level, if a recipient (or his MUA) decides to discard a message based ontag2 marking, there is no way to retrieve it later from a quarantine, the sender is nevernotified, spam administrator is never notified. As far as the MTA and amavisd-new areconcerned, the message was successfully delivered. Whatever MUA does with the mail isentirely the responsibility and jurisdiction of the recipient and his LDA and MUA.Quarantine

Mail quarantining is attempted when enabled for a given contents category, which usuallyincludes infected, or banned, or spam mail with score for at least one of its recipients at orabove his kill level. It is also possible to enable quarantining of clean messages for archivingor troubleshooting purposes. The *quarantine_to for each recipient (when nonempty), alongwith a corresponding global *_quarantine_method, determines where the quarantine locationshould be.

quarantine_method

The *_quarantine_method can be considered a static and a site-wide setting, generallycontrolling a format and location of the quarantine on the system. The *quarantine_to can beconsidered a dynamic part of the quarantine location, possibly affected by per-recipientsettings and the type of malware (contents category). It serves to fully specify the finallocation, e.g. a file or a mailbox.

Depending on mail contents category (type of malware), the following variables specify thequarantine method: $virus_quarantine_method, $spam_quarantine_method,$banned_files_quarantine_method, and $bad_header_quarantine_method. One way toglobally disable quarantine is to specify undef or an empty string as a value of these variables.A nonempty string should follow a syntax:

local:filename-templatebsmtp:filename-templatesmtp:[IPv4-or-IPv6-address-or-hostname]:portsmtp:hostname:portsmtp:/path/to/a/unix/socketlmtp:[IPv4-or-IPv6-address-or-hostname]:portlmtp:hostname:portlmtp:/path/to/a/unix/socketpipe:argv=command args...sql:anything

The local:, bsmtp: and sql: methods are the usual methods for quarantining. The smtp: orlmtp: methods are only useful for quarantining if quarantine location is some dedicatedmailbox instead of a local file or directory. The smtp:, lmtp: and pipe: methods are more often

used for forwarding and notifications, and only rarely for quarantining. The following featuresbecame available with version 2.5.0: the lmtp: method, support for IPv6, and specifying a Unixsocket to a smtp: or lmtp: method.

When quarantine method starts with local:, the rest of the string is a filename-template, whichserves to specify a file name to store a quarantined message. The template may containplaceholders which are composed of a percent character, followed by exactly one character.The following expansions are recognized:%b is replaced by $msginfo->body_digest%P is replaced by $msginfo->partition_tag%m is replaced by $msginfo->mail_id%n is replaced by $msginfo->log_id%i is replaced by ISO 8601 timestamp of a mail reception time

%% is replaced by a single %

If a filename-template ends up in .gz, the resulting file will be gzip-compressed.


5/29

quarantine_to

Depending on the method specified (local/bsmtp/smtp/sql) a per-recipient setting*quarantine_to adopts different semantics and syntax, possibly modified by the configurationvariable $QUARANTINEDIR.method quarantine_to $QUARANTINEDIR effectanything empty or undef anything not quarantined

empty or undef anything anything not quarantinedlocal: pseudo-alias mapped through %local_delivery_aliases directory stored as anindividual file below the directory $QUARANTINEDIR, file name comes from the templatespecified in the *_quarantine_method; if a template file name ends in .gz the message will begzip-compressedlocal: pseudo-alias mapped through %local_delivery_aliases filename of a mailbox

appended to a file $QUARANTINEDIR in mbox formatlocal: pseudo-alias mapped through %local_delivery_aliases empty or undef notquarantinedlocal: e-mail address containing '@'-sign anything sent via SMTP to a mailerfor storage, uses $notify_method to specify how to deliver to MTA; much like a newer 'smtp:'entry belowsmtp: e-mail address anything sent via SMTP to a mailer for storage, uses thespecified IP address and port, or a Unix socket for delivery; formerly a 'local:' method was

used for this purposelmtp: e-mail address anything sent via LMTP to a mailer for storage, uses thespecified IP address and port, or a Unix socket for deliverybsmtp: anything (nonempty) anything stored in a file specified in the*_quarantine_method in BSMTP format (if file name is absolute, i.e. starts with a "/")bsmtp: anything (nonempty) directory stored in a file specified in the*_quarantine_method in BSMTP format (file name relative to $QUARANTINEDIR)sql: anything (nonempty) anything stored into SQL database specified by@storage_sql_dsnsql: empty or undef anything not quarantined

The *quarantine_to is currently quite limited in functionality, it is often used only to turn off the

quarantining for some user or local subdomain. The reason for this limited functionality is amore vulnerable nature of this value, as it may come from SQL or LDAP lookups where non-careful access controls to these databases might permit users to enter any value in the*quarantine_to field, which is why we do not let it control the directory or the exact file name ofthe quarantine file. This may be somewhat relaxed in the future.

In common setups the quarantine location (e.g. a directory or a dedicated mailbox) is thesame for all recipients. If at least one recipient specifies a nonempty *quarantine_to specifyingthis location, the message is quarantined (stored) there once, regardless of the number ofrecipients.

The general algorithm is: the *quarantine_to value associated with each recipient is looked up.Empty or undef values are ignored and duplicates are discarded. A mail to be quarantined isthen stored/sent to each unique location remaining on the list.

The "bsmtp:" quarantine method is somewhat special in that the quarantine file location isentirely determined by the *_quarantine_method setting, and the value of per-recipient*quarantine_to settings do not influence the quarantine location, as long as this value isnonempty.

When using the "bsmtp:" quarantine method and versions of amavisd-new earlier than 2.2.0,the *_quarantine_to was completely ignored, which made it impossible to turn off quarantiningselectively for certain users by specifying an empty or undef value. Since 2.2.0, an empty*_quarantine_to turns off quarantine for a recipient regardless of the quarantine method. Anonempty string in *_quarantine_to (the exact value is ignored) must now be used even with"bsmtp:" to enable quarantining.Releasing from a quarantine

The utility amavisd-release tells the amavisd daemon to fetch a mail from a local quarantine,and send it to MTA through its regular channels ($notify_method), bypassing re-checking.


6/29

By default it connects to socket /var/amavis/amavisd.sock, on which amavisd should belistening for AM.PDP protocol, but one can use inet socket instead of a Unix socket if there isa need to run amavisd-release from a remote host.

In the amavisd.conf the following should be added:

$unix_socketname = "$MYHOME/amavisd.sock"; # listen on Unix socket

# alternatively (less common):# $inet_socket_port = [10024, 9998]; # listen on listed inet tcp ports

# apply policy bank AM.PDP-SOCK on a Unix socket:# (note that this precludes the use of old amavis-milter# helper program (with sendmail) on the same socket)$interface_policy{'SOCK'} = 'AM.PDP-SOCK';

# apply policy bank AM.PDP-INET to some inet tcp socket, e.g. tcp port 9998:$interface_policy{'9998'} = 'AM.PDP-INET';

$policy_bank{'AM.PDP-SOCK'} = {

protocol => 'AM.PDP', # select Amavis policy delegation protocolauth_required_release => 0, # don't require secret_id for amavisd-release

};$policy_bank{'AM.PDP-INET'} = {protocol => 'AM.PDP', # select Amavis policy delegation protocolinet_acl => [qw( 127.0.0.1 [::1] )], # restrict access to these IP addresses

# auth_required_release => 0, # don't require secret_id for amavisd-release};

Setting of $auth_required_release decides whether the requestor needs to specify secret_id inaddition to mail_id to authorize a mail release. The secret_id is stored in SQL table msgswhen logging to SQL is enabled, otherwise this information is not accessible.

Note that turning off $auth_required_release check is safe as long as access to the socket isrestricted, like with file protections on a Unix socket, or restricted with inet_acl to specific IPaddresses. Enabling or disabling $auth_required_release is a management / setup decisionand convenience.

To release a mail message an exact quarantine location from a log file should be specified asan argument to amavisd-release, e.g.:amavis[29297]: (29297-01-6) Blocked SPAM,... -> ,quarantine: spam/U/UM3XM3XDbN52.gz,Message-ID:, mail_id: UM3XM3XDbN52, Hits: 13.365,

$ amavisd-release spam/U/UM3XM3XDbN52.gz250 2.6.0 Ok, id=rel-UM3XM3XDbN52,

from MTA([193.2.4.66]:10025): 250 2.0.0 Ok: queued as F137717B88B

The amavisd-release utility also accepts mail_id from STDIN if releasing more than onemessage in one go is more convenient:$ amavisd-release -spam/U/UM3XM3XDbN52.gzspam/g/gnwKVFKiuey3.gzspam/X/Xpkj9mLLBHTR.gzRedirecting malware to a different mailbox -- plus addressing

Amavisd-new can tag passed malware by appending an address extension to a recipientaddress. An address extension is usually a short string (such as 'spam') appended to the localpart of the recipient address, delimited from it by a single character delimiter, often a '+' (or

sometimes a '-'). This is why address extensions are also known as "plus addressing".Examples of such mail addresses belonging to user [email protected] are:[email protected], [email protected], [email protected],


7/29


8/29

which will collect all spam into one mailbox for each subdomain.

For the Postfix local(8) LDA, a presence of a file $HOME/.forward+spam can redirect mail foruser+spam to some dedicated file. For the Postfix virtual(8) LDA, a virtual_mailbox_maps maycontain entries like:user1 mbxfile1

user1+spam mbxspamfile1user2 mbxfile2user2+spam mbxspamfile2Hard black- and whitelisting senders regarding spam

The blacklisting and the whitelisting are ways of telling that we already know that a message isspam or is ham (non-spam) just by examining the envelope sender address and comparing itto lists of known spammers or to lists of known legitimate senders of ham. It is a quick check,potentially saving us the trouble of examining the mail contents. It has a big drawbackhowever in that the sender mail address can be (and often is) faked and there is no guaranteethat the claimed sender address represents the actual sender.

The sender address is usually faked for spam messages, so whitelisting some senderaddress is a of questionable value, and often lets in far more spam than it does good by

approving legitimate mail. For a reliable way of permitting certain sending clients to sendspamy mail see policy banks.

Blacklisting however is still useful: spammer has no desire to pretend to be some blacklistedsending address, when he can choose any other address. Genuine sender that is intentionallyblacklisted can only avoid being blocked by falsifying his address (joining spammers in hismethods) and sending non-spamy mail, the later being our objective anyway. Althoughamavisd-new does provide blacklisting, it is functionally equivalent but more effective toblacklist senders at the MTA, preventing such mail from even entering the mail system.

It should be emphasized that whitelisting (and blacklisting) only affects spam checks. It has noinfluence on other checks such as virus, banned or header checks. Infected mail fromwhitelisted sender would still be blocked if our policy is to block viruses.

Another point to bear in mind is that the sender address examined is the one from the SMTPprotocol, exactly as provide by MTA to amavisd-new. It is known as the envelope senderaddress or return path. This address does not necessarily match the mail author's addressfrom the mail header (From:) or the sender's address from the header (Sender:). This is mostobvious with mail from mailing lists, where the envelope sender address is usually the addressof a mailing list management service, while the author's address (From:) is the address of aperson sending the message. Using the envelope sender address in most cases makes iteasier to black- or whitelist mail from mailing lists, compared to guessing a sender address byparsing mail header.

To avoid surprises, whitelisted sender suppresses inserting/editing the tag2-level header fields(X-Spam-*, Subject), appending spam address extension, and quarantining, even if we knowthe message is spam (e.g. because the spam check result on the same mail contents has

been cached from some earlier mail or known from check on behalf of another recipient).

For mail from blacklisted senders, the effect is as if the spam level were artificially pushedhigh, resulting in 'X-Spam-Flag: YES', high 'X-Spam-Level' bar and other usual reactions tospam, including possible rejection. If the message nevertheless still passes (e.g. for spamloving recipients), it is tagged as BLACKLISTED in the 'X-Spam-Status' header field, but thereported spam value and set of tests in this report header field is not adjusted (if availablefrom SpamAssassin, which may or may not have been called)

If all recipients of a message either white- or blacklist the sender, amavisd is free to skip spamscanning (calling the SpamAssassin), saving on time. There is no guarantee however thatspam scanning will actually and always be skipped.

The following variables (lists of lookup tables) are available, with the semantics and syntax asspecified in README.lookups: @whitelist_sender_maps, @blacklist_sender_maps, whichimplement global policy applicable to all recipients. Similarly there are


9/29

$per_recip_blacklist_sender_lookup_tables and $per_recip_whitelist_sender_lookup_tables,which make possible for each recipient or subdomain to specify its own set of black- orwhitelisted senders. The per-recipient tables take precedence over global tables.

For SQL lookups, amavisd-new will first lookup the recipient in table users in order ofdescending priority, e.g. [email protected], user, @.sub.domain.org, @.domain.org,

@.org, and @. (which can be considered a catchall). Each matching recipient record mayhave a list of senders associated (through join on field users.id and wblist.rid). The senderaddress is then looked up in the associated list of senders (wblist) in order of descendingpriority, e.g. [email protected], @.sub.example.com, @.example.com, @.com, and@. . This search stops at the first matching sender record with a non-NULL field wblist.wb.The value of a field wblist.wb from the matched record determines if the sender is consideredwhitelisted ('W'), blacklisted ('B') or neutral (' ') for this recipient.

The neutral value is there just as a way to explicitly stop the search, which may be used by arecipient to overrule site-wide or static white- or blacklisting defaults for some specific sender,and to explicitly neither whitelist nor blacklist the sender, letting the normal spam checkdetermine the spaminess of a mail.

For recipient [email protected] and sender [email protected] the following

search is performed:[email protected]@sub.example.com @.sub.example.com @.example.com @.com @.

[email protected] @.sub.example.com @.example.com @.com @.

@[email protected] @.sub.example.com @.example.com @.com @.




Soft black- and whitelisting senders regarding spam -- @score_sender_maps

Instead of hard black- or whitelisting a sender address (unconditionally considering mail spamor ham solely based on sender address regardless of mail contents), a more gentle approachis to add score points (penalties) to the spam score for mail from certain senders or sendingdomains. Positive points lean towards blacklisting, negative towards whitelisting. This is muchlike adding SpamAssassin rules or using its white/blacklisting, except that here only envelopesender addresses are considered (not addresses in a mail header), and that score points canbe assigned per-recipient (or per-domain or globally), and that the assigned penalties are

customarily much lower than the default SpamAssassin white/blacklisting score.

The table structure of @score_sender_maps is similar to$per_recip_blacklist_sender_lookup_tables i.e. the first level key is recipient address, pointingto by-sender lookup tables. The essential difference is that scores from all matching by-recipient lookups (not just the first that matches) are summed to give the final score boost.That means that both the site and domain administrators, as well as the recipient can have asay on the final score.

For SQL lookups, the mechanism is much like the one described for hard black- orwhitelisting, with the following differences:the field wblist.wb is numeric, representing score points, instead of containing a character Wor B or space;

the search through matching recipients does not stop at the first match, but traverses allmatching recipients, summing up the corresponding wblist.wb field values.


10/29

Namely, amavisd will lookup the recipient, e.g. [email protected], user,@.sub.domain.org, @.domain.org, @.org, and @. . Since the search will not stop at the firstrecipient match, the search order in this case is unimportant, although it is actually the samedescending-priority order as with hard b/w listing. Each matching recipient record may have alist of senders associated (through join on field users.id and wblist.rid). The sender address isthen looked up in the associated list of senders (wblist) in order of descending priority, e.g.

[email protected], @.sub.example.com, @.example.com, @.com, and @. . Thissearch stops at the first matching sender record with a non-NULL field wblist.wb, but this doesnot terminate the outer recipients search. Numeric values of a field wblist.wb from matchedrecords are summed up across all matching recipients tables, and the result is added to thespam score as produced by SpamAssassin.

Unlike static tables, where hard and soft w/b-listing use separate tables, the SQL-based hardand soft w/b-listing uses the same SQL tables and the same field wblist.wb. Mixing the 'W','B' with numeric values is somewhat frowned upon, but is supported to facilitate transition. Thesearch goes like described above as long as only numeric field values are encountered,summing up the values and adding the accumulated sum to the final score. If a non-numericvalue of field wblist.wb is encountered during this search, its value (W or B or space) isinterpreted as described for hard w/b listing, and the search stops at this point.Configuration variables

The behaviour of the amavisd-new is controlled by a set of configuration variables, which arejust normal module-global Perl variables (in package Amavis::Conf). At daemon startup timethese variables are first assigned an initial value (often just an undefined value, the undef).The default values of configuration variables are documented in file amavisd.conf-defaults,which lists all configuration variables.

Next a configuration file amavisd.conf (or other file as specified by option -c) is read andinterpreted by the Perl interpreter itself. The amavisd.conf is just a normal Perl program, andcan in principle do whatever and however it pleases, but its main purpose is to assign valuesto configuration variables.

After execution of amavisd.conf is done, the daemon may correct some configuration variable

values (mainly to maintain backwards compatibility with earlier version of configuration file),and may assign a default value to certain variables which are still undefined -- these variablesand their default values are marked "after-defaults" in the documentation file amavisd.conf-defaults. The main reason for existence of the "after-defaults" concept is that some defaultvalues depend on other configuration variables and can not be computed before theamavisd.conf is finished. To force such variables to an off/false/disabled state, one needs toassign some false but defined value to them, such as '' (an empty string) or a 0 for booleans.

Perl variables always start with a character $, @ or % to indicate a type of variable. Thisleading character is part of the variable name for all practical purposes.$ (dollar character)indicates a scalar variable (a string, a number, a reference)@ (at sign)indicates an array variable (a list)

% (percent character)indicates an associative array (also known as hash), which maps keys to values

A couple of Perl syntactical elements deserve mention at this point, as they are often used inthe amavisd.conf configuration file."...", a double-quoted stringis a string; variables within are evaluated, e.g. "$MYHOME/tmp"'...', a single-quoted stringis a string; variables within are not evaluated, the $ and @ loose their special meaning, e.g.'[email protected]'(...)is a list of comma-separated expressions, e.g. (1,2,"test"); a list is normally assigned to anarray variable

qw(string)is an operator that interprets its argument as a single string, splits it on whitespace to words,and returns a list of words (strings); it is a convenience to avoid some typing, e.g. qw


11/29


12/29

client IP address is known (by XFORWARD SMTP extension command from MTA) and itmatches the current mynetworks_maps. See amavisd.conf-sample for examples.

When a new policy bank is overlaid over an existing set of configuration variables, thevariables not present in the new policy bank retain their value. This makes it possible tospecify new policy banks which carry only a minimal set of settings that need to be changed.

The built-in policy bank (with empty name) is predefined, and includes references to mostother variables (the dynamic config variables), which are accessed only indirectly through thecurrently installed policy bank. Overlaying a policy bank with another policy bank may bring inreferences to entirely different variables, possibly unnamed, and may remove references tolegacy variables if it so chooses.

Configuration variables are referenced from a policy bank (which is implemented as a perlassociative array, i.e. a hash) by keys of the same name, e.g. { log_level => \$log_level,inet_acl => \@inet_acl, ...}. For scalars one level of indirection is allowed, e.g. a policy bank {log_level => \$log_level }; $log_level=2; is equivalent to { log_level => $log_level } or to {log_level => 2 }, but in the first example with an indirect reference, the $log_level may beassigned to even _after_ the policy bank has already been formed.

A word of caution: the syntax of entries within a policy bank hash is slightly different fromassignments to configuration variables. This is because entries within policy bank are notassignments, but key=>value pairs as in any Perl associative array. And these pairs aredelimited by commas, unlike statements, which are delimited by semicolons. Value isseparated from its key by '=>' (or by a comma), whereas the assignment operator is '='. Keysof a policy bank are without leading $ or @ or %, unlike variable names. Values of anassociative array can only be scalars (e.g. strings or numbers or references to arrays orreferences to associative array).

Compare:value of a policy bank is a reference to a Perl associative array, e.g.:

{ log_level => 3,forward_method => 'smtp:[127.0.0.1]:10025',

spam_admin_maps => ["spamalert\@$mydomain"],blacklist_sender_maps => [ [qw(.example.org .example.net)] ],}

normal assignments look like:$log_level = 3;$forward_method = 'smtp:[127.0.0.1]:10025';@spam_admin_maps = ("spamalert\@$mydomain");@blacklist_sender_maps = ( [qw(.example.org .example.net)] );

And a final note: Perl can detect and report typing mistakes in variable names, but mistypedkey is just some unused associative array entry lurking in a hash, never used and neverreported as mistyped/useless.Putting policy banks to good use -- examples

The sender address can be faked, so comparing envelope sender address to@local_domains_maps or some other lookup table to base some important decisions onwould not be trustworthy. The only reliable information is the recipient's e-mail address andinformation about client SMTP session, such as the IP address of the sending SMTP clientand the server port number or the interface address. Such information can be made availableby MTA to amavisd-new through a feeding protocol (e.g. XFORWARD extension or viaAM.PDP), or separate MTA paths can be set up for mail that needs to be treated differently,such as internally originating and externally originating mail, or perhaps separatingauthenticated mail from the rest.

Amavisd-new has two ways of receiving such extra information from MTA:it can listen on more than one TCP port and apply different policy banks to each port(applicable to any dual-MTA setup including Postfix), and/or

it can accept SMTP client's IP address from MTA by XFORWARD extension to the SMTPprotocol (available in Postfix only), which can control loading of policy bank MYNETS. This isin addition to loading policy banks based on TCP port number. The MYNETS policy bank is


13/29

loaded (if applicable) after (on top of the) the port-assigned policy bank.

The following examples illustrate several ways of distinguishing between different mail origins.For most common purposes the only distinction that really matters is separating internallyoriginating mail from the rest, and for this purpose the use of policy bank MYNETS and asufficiently recent version of Postfix supporting XFORWARD suffices -- the complication with

multiple ports and multiple interfaces is needed only for more demanding sites which prefermaximum flexibility.Example 1

As stated earlier, a policy bank named 'MYNETS' is loaded (if it exists) whenever MTAsupplies an original SMTP client's IP address (e.g. via the Postfix XFORWARD extension)and that address matches the @mynetworks list. This covers most common needs todistinguish internally-originating mail from the rest, and allows them to be treated differently,as illustrated by the following example:$policy_bank{'MYNETS'} = { # mail originating from @mynetworksvirus_admin_maps => ["security\@$mydomain"], # alert of infected local hostsspam_admin_maps => ["abuse\@$mydomain"], # alert of internal spamspam_kill_level_maps => [7.0], # slightly more permissive spam kill levelspam_dsn_cutoff_level_maps => [15],

banned_filename_maps => [new_RE(# block double extensions in names:qr'\.[^./]*\.(exe|vbs|pif|scr|bat|cmd|com|cpl|dll)\.?$'i,

# allow any name or type (except viruses) within an archive:[ qr'^\.(Z|gz|bz2|rpm|cpio|tar|zip|rar|arc|arj|zoo)$' => 0],

# blocks MS executable file(1) types, unless allowed above:qr'^\.(exe-ms)$',

),],

};Example 2

In the following example some of the external mail is coming in via fetchmail, the rest of theexternally originating mail is coming in via normal SMTP at tcp port 25, and all internallyoriginating mail is coming to MTA via mail submission port 587 reserved for that purpose, orvia dedicated IP address accessible only from inside, or through a Postfix pickup service.We'll use Postfix in this example, although it does not rely on any particular Postfix capabilitythat wouldn't be available in any general purpose MTA in some form or another.

Only the specifics of this setup are described here. Missing bits like the MTA re-entry port10025 and other options are described in README.postfix and are assumed here. Specifyingadditional smtpd restrictions and options may be desired, and is omitted here for brevity.

To let amavisd-new be able to distinguish between all four mail entry routes, we let amavisdlisten on four TCP ports (the fifth is for good measure, to be used in the next example):$inet_socket_port = [10040,10041,10042,10043,10044]; (any unused non-privileged TCP

ports can be used)

In Postfix configuration file master.cf we attach different content_filter options to each of thePostfix services receiving mail. We'll assume the MTA host has two IP addresses 192.0.2.1and 192.0.2.2 assigned (IP aliases or separate physical interfaces), which makes it easier todistinguish between internally originating mail and the rest even if XFORWARD can not beused (older Postfix versions or some other MTA):# regular incoming mail, originating from anywhere (usually from outside)# the MX record (or backup mailers) should point to this IP address192.0.2.1:smtp inet n - n - - smtpd-o content_filter=amavisfeed:[127.0.0.1]:10040

# incoming mail from fetchmail, considered externally originating

# (add 'smtphost localhost/2345' to the poll section in .fetchmailrc)127.0.0.1:2345 inet n - n - - smtpd-o content_filter=amavisfeed:[127.0.0.1]:10041


14/29

-o smtpd_client_restrictions=permit_mynetworks,reject-o mynetworks=127.0.0.0/8

# IP address to be used by internal hosts for mail submission192.0.2.2:smtp inet n - n - - smtpd-o content_filter=amavisfeed:[127.0.0.1]:10042

-o smtpd_client_restrictions=permit_mynetworks,reject

# or, tcp port 587 to be used by internal hosts for mail submissionsubmission inet n - n - - smtpd-o content_filter=amavisfeed:[127.0.0.1]:10042-o smtpd_client_restrictions=permit_mynetworks,reject

# locally originating mail submitted on this host through a sendmail binarypickup fifo n - n 60 1 pickup-o content_filter=amavisfeed:[127.0.0.1]:10043

A global option content_filter in file main.cf could provide a convenient default, only servicesthat need a different setting would then need to override it.

Now let's make up names for policy banks which will cover all four cases. We'll pick namesEXT, EXT-FM, INT, INT-HOST for policy banks. The amavisd needs to be told to loadcorresponding policy when a request comes in on each of the listening ports:$interface_policy{'10040'} = 'EXT';$interface_policy{'10041'} = 'EXT-FM';$interface_policy{'10042'} = 'INT';$interface_policy{'10043'} = 'INT-HOST';$interface_policy{'10044'} = 'AUTH'; # to be used in the next example

Next we'll prepare each policy and specify there the options which should be different fromglobal options. Note that the following policies serve mostly as an example and to provideideas -- they should not be considered a recommendation. For example:# regular incoming mail, originating from anywhere (usually from outside)

$policy_bank{'EXT'} = {# just use global settings, no special overrides};

# incoming mail from fetchmail, considered externally originating$policy_bank{'EXT-FM'} = {log_level => 2,# no bounces for spam, not even for score below spam_dsn_cutoff_level_maps:

final_spam_destiny => D_DISCARD,};

# locally originating mail guaranteed to be from inside$policy_bank{'INT'} = {

# enable/redirect admin notifications for locally originating malware:

virus_admin_maps => ["virusalert\@$mydomain"],spam_admin_maps => ["virusalert\@$mydomain"],# be slightly more permissive on spam levels for mail from our hosts:

spam_kill_level_maps => [7.0],spam_dsn_cutoff_level_maps => [15],final_virus_destiny => D_BOUNCE, # (unless in viruses_that_fake_sender_maps)final_spam_destiny => D_BOUNCE, # (unless above spam_dsn_cutoff_level_maps)bypass_banned_checks_maps => [ 1 ], # allow sending any file type or name# provide customized sender notifications for spam from our users:

notify_spam_sender_templ => read_text("$MYHOME/notify_spam_sender.txt"),};

# mail locally submitted on the host on which MTA runs

$policy_bank{'INT-HOST'} = {# NOTE: this is just an example; ignoring internally generated spam# may not be such a good idea, consider zombified infected local PCs


15/29

bypass_spam_checks_maps => [ 1 ],bypass_banned_checks_maps => [ 1 ],final_spam_destiny => D_PASS,final_banned_destiny => D_PASS,

};

# authenticated mail (used by the next example)$policy_bank{'AUTH'} = {# enable admin notifications for malware originating from our users:

virus_admin_maps => ["virusalert\@$mydomain"],spam_admin_maps => ["virusalert\@$mydomain"],# be slightly more permissive on spam levels for mail from our users:

spam_kill_level_maps => 7.0,spam_dsn_cutoff_level_maps => 15,bypass_banned_checks_maps => 1, # allow sending any file type or namefinal_bad_header_destiny => D_BOUNCE; # block invalid headers

};

If not all four cases need to be distinguished, the same policy bank name (or none at all) canbe assigned to more than one port. Also the MTA configuration can use the same amavisd

port for more than one of its incoming services if there is no need for different settings.Example 3

Besides setting different content_filter options for different Postfix services, one may use theoption FILTER in Postfix lookup tables, as described in Postfix man pages access(5) andheader_checks(5), to specify different content_filter settings based on various conditions,such as sender domain name or IP address, mail header fields, etc.

Consider the next example which uses the FILTER settings to distinguish from internallyoriginating, authenticated external mail and the rest.# global default:content_filter=amavisfeed:[127.0.0.1]:10044

# note that permit_mynetworks only checks for key presence and ignores rhsmynetworks = cidr:/etc/postfix/mynetworks-filter.cidr

smtpd_recipient_restrictions =reject_unauth_pipelining, reject_non_fqdn_recipient, reject_non_fqdn_sender,reject_unknown_recipient_domain, reject_unknown_sender_domain,check_client_access cidr:/etc/postfix/mynetworks-filter.cidr,permit_mynetworks,permit_sasl_authenticated, permit_tls_clientcerts,reject_unauth_destination,check_sender_access regexp:/etc/postfix/filter-catchall.regexp

The check_client_access cidr:/etc/postfix/mynetworks-filter.cidr preceeds thepermit_mynetworks (which uses the same cidr table, but ignores the righthand side), and it

serves to override the global content_filter setting by the use of FILTER for each of thenetworks (presumably internal) listed in mynetworks-filter.cidr. The final effect is that mailmatching networks listed in mynetworks-filter.cidr will be sent for content filtering to tcp port10042 (the FILTER setting in access map), authenticated non-local mail will be sent forcontent filtering to port 10044 (the global setting), while all the rest will be sent to port 10040(as specified in catchall filter). If there are any other overrides in master.cf like in the previousexample, they take precedence over the global settings, but the FILTER rules take theultimate precedence.

/etc/postfix/mynetworks-filter.cidr :127.0.0.0/8 FILTER amavisfeed:[127.0.0.1]:1004210.0.0.0/8 FILTER amavisfeed:[127.0.0.1]:10042172.16.0.0/12 FILTER amavisfeed:[127.0.0.1]:10042

192.168.0.0/16 FILTER amavisfeed:[127.0.0.1]:10042

/etc/postfix/filter-catchall.regexp:


16/29

/^/ FILTER amavisfeed:[127.0.0.1]:10040

Note that in place of the last catchall entry: check_sender_access regexp:/etc/postfix/filter-catchall.regexp one would be tempted to do: check_sender_access static:FILTERamavisfeed:[127.0.0.1]:10040, but unfortunately spaces are not allowed within an option valuein master.cf, so we have to resort to a lookup table.

$max_requests

Amavisd-new runs under process control of Net::Server. This is a pre-forked environmentwhere $max_servers child processes are constantly kept alive and ready to accept new tasks(mail messages to be checked). Each amavisd child process is able to handle several tasks ina row, which helps to reduce startup (fork) costs. In case of SMTP or LMTP protocol, eachsession may consist of several SMTP/LMTP transactions. Each SMTP/LMTP transaction iscounted a one task, regardless of whether it came in from the same SMTP/LMTP client in amulti-transaction session, or as separate sessions, possibly from different SMTP/LMTPclients.

A configuration variable $max_requests (default value 20) controls the approximate number oftasks each child process is willing to handle. After that the child process terminates andNet::Server provides a new child process to take its place.

The exact value of $max_requests is not critical. There are two opposing needs, and some in-between value should be chosen.

On the low side, the number should not be too small in order for the startup cost to beaveraged out / sufficiently diluted over an entire child lifetime. A value above 5 or 10 meetsthis goal in most amavisd-new configurations.

On the high side, the value depends on the amavisd-new configuration. The amavisd daemonitself is conservative in its use of dynamically allocated memory and does not load mail intomemory, but keeps mail being processed and its components on files. Similarly, most of thecalled external virus scanners and decoders are rational in their use of memory (a notableexception was Archive::Tar which was used if a pax or cpio command was not available, but is

no longer supported). Unfortunately this is not true for Perl module Mail::SpamAssassin, whichexpects to have an entire decoded mail in memory in order to be able to run its large set ofrules on it in reasonable time. This is a design decision of SpamAssassin.

When amavisd-new is not configured to use SpamAssassin, the value of $max_requests canbe quite high without any known or expected problems. For general sanity reasons, an upperlimit could be a 100 for example, although anything above 20 or so would not bringmeasurable benefit to the maximum sustained mail throughput.

When amavisd-new is configured to use SpamAssassin however, the slurping of entire mail inmemory and decoding it may have implications, depending on the $sa_mail_body_size_limitvalue, on the maximum mail size allowed at the MTA (e.g. Postfix setting formessage_size_limit) and on the mail compression factor. Even though the allocated memoryis reclaimed by Perl after mail processing, and is reused for subsequent processing, the

process virtual memory footprint never shrinks, it can only expand as needed.

The $sa_mail_body_size_limit sets a limit on a mail size beyond which SpamAssassin is notcalled, so it can not contribute to memory usage much beyond this limit, times a small factor(2-5?, due to multiple internal representations of a message). If the $sa_mail_body_size_limitis large, and MTA mail size is not limited, or if mail has a huge mail header, the memoryfootprint can become noticable. For the rest of a lifetime the child process that processed themail stays at its high virtual memory size. If this happens frequently, host resources maybecome scarce. Limiting the number of tasks is very much desirable in this case.

The default value of 20 for $max_servers was chosen as a good compromise betweenaveraging-out the startup costs and not wasting too much resources on hosts with highmessage size limit and SpamAssassin enabled.

In the setup with Postfix where its lmtp client is chosen to feed amavisd-new, this client tries tokeep LMTP session open and submit several mail messages in multiple transactions. With


17/29

recent Postfix versions its SMTP client is capable and willing of using multiple transactionsessions as well, although it seems to be less persistent than the LMTP client.

According to SMTP and LMTP protocol specifications, dropping the session on the server sideis considered rude and should be used only as a last resort. In order to respect the$max_requests setting (which is not strictly enforced by amavisd, and is considered an

advisory value), the client side should preferably be configured with a comparable limit.Starting with amavisd-new-2.2.0 the amavisd daemon is more strict in enforcing the limit anddrops the SMTP or LMTP session after $max_servers is exceeded by one. This was arecommendation from the Postfix community, as the option of reducing Postfix max_usesetting is considered less appropriate.

Nevertheless, Postfix doesn't take session dropping lightly, it backs off a while after contentfilter forcibly drops the session, which is undesired. Better behaviour is achieved when Postfixvoluntarily terminates a SMTP session before amavisd would reach its $max_requests limit.This can be achieved by applying max_use to the Postfix smtp service feeding a content filter(typically this entry in master.cf is named 'amavisfeed').Setting up DKIM mail signing and verification

A DKIM standard (RFC 4871) states the following, which applies to its predecessor

DomainKeys (historical: RFC 4870) as well:

DomainKeys Identified Mail (DKIM) defines a mechanism by which email messages can becryptographically signed, permitting a signing domain to claim responsibility for theintroduction of a message into the mail stream. Message recipients can verify the signature byquerying the signer's domain directly to retrieve the appropriate public key, and therebyconfirm that the message was attested to by a party in possession of the private key for thesigning domain.

The DomainKeys specification was a primary source from which the DomainKeys IdentifiedMail [DKIM] specification has been derived. The purpose in submitting the RFC 4870document is as an historical reference for deployed implementations written prior to the DKIMspecification.

The main advantage of DKIM signing to sending domains is that it allows recipients to reliablyvalidate mail origin for purposes of whitelisting on spam checks and whitelisting reception ofotherwise banned mail contents. By signing outbound mail you give your correspondents achance to distinguish between your genuine mail, and fraud or spam mail which may happento carry your domain name as a sender address. Signing outbound mail is a kind gesturetowards recipients, making it much easier for them to treat your mail as important or desirableif they choose so.

The main advantage of DKIM signature verification to recipients is that it allows them toreliably distinguish genuine mail originating from a claimed sending domain from other(possibly faked) mail. It makes signature-based whitelisting a reliable mechanism. It alsomakes it possible to recognize and automatically discard fake mail claiming to be fromdomains which are known to always sign their outbound mail and to always send mail directly.

Coupled with reputation schemes (mostly manual/static at present, or dynamic in the future)makes it possible to assign score points (positive or negative) based on merit and pastexperience with each signing domain. A valid signature also offers non-repudiation: a domainwhich signed a message can not disclaim message origin, which offers recipient a strongargument when reporting abuse to the signing domain.For the impatient - signing from scratch

Here is a quick Spartanic setup of DKIM signing and DKIM/DK verification by amavisd for theimpatient, without much explanation, assuming all originating mail comes from internalnetworks (not from authenticated roaming clients), only one domain needs signing, usingdefault signature tags, no milters are in use and no mailing list manager needs signing. Nochanges in Postfix configuration is necessary for this simple setup. For more information andmore complex setups please see sections further on.

Generate a signing key:$ amavisd genrsa /var/db/dkim/example-foo.key.pem


18/29

add to amavisd.conf:$enable_dkim_verification = 1;$enable_dkim_signing = 1;dkim_key('example.com', 'foo', '/var/db/dkim/example-foo.key.pem');@dkim_signature_options_bysender_maps = (

{ '.' => { ttl => 21*24*3600, c => 'relaxed/simple' } } );@mynetworks = qw(0.0.0.0/8 127.0.0.0/8 10.0.0.0/8 172.16.0.0/12192.168.0.0/16); # list your internal networks

run:$ amavisd showkeys

add the public key (as displayed) to your DNS zone, increment SOA sequence number andreload DNS; then test signing and a published key:$ amavisd testkeys

if all went well:$ amavisd reload

For the impatient - replacing signing by dkim-milter with signing by amavisd

For sites already signing their mail by dkim-milter, most work of preparing signing keys andpublishing public keys in DNS has already been done. All it needs to be done is to declarethese signing keys in amavisd.conf and turn on $enable_dkim_signing.

To facilitate transition of DKIM signing from dkim-milter to amavisd-new, a new command-linetool is available with amavisd-new-2.6.2 (the extra utility code is not loaded during normaloperation), taking a file name as its argument, e.g.:$ amavisd convert_keysfile /var/db/dkim/keysfile.txt

and writing to stdout a set of lines that may be directly included into amavisd.confconfigurations file, matching semantics of a dkim-filter keys file. It can be useful duringtransition, or for those who prefer to specify signing keys and sender-to-key mappings as a file

in a syntax compatible with options -K -k of dkim-filter, and can live with limitations of suchsyntax. See dkim-filter(8) man page for details on the syntax.

The produced output consists of signing key declarations (calls to a procedure dkim_key),where each call normally corresponds to exactly one DNS resource record publishing acorresponding DKIM public key. When necessary output also produces an assignment to a listof lookup tables @dkim_signature_options_bysender_maps, which supplies non-defaultmappings of sender domains to signing keys, e.g. when third-party signatures are desired.Implementation and mail flow

Signing of originating mail (or mail being redistributed by our domain), and verifying signaturesof incoming mail are two tasks that can be performed by the same program, or they can beperformed by separate entities. Traditionally with sendmail, both tasks are performed by onemilter, which may be easier to maintain, but has certain disadvantages.

Verifying signatures should be performed early, before any local mail transformations get achance of invalidating a signature, e.g. by performing MIME conversions to quote-printable, byfixing syntactically invalid mail header section, by reformatting or reordering some headerfields (some MTAs do it frivolously), by modifying/inserting/removing certain header fields, orby a local mailing list modifying mail text, e.g. by appending footers.

Signing outgoing mail should be performed late, after mail sanitation, after conversion to 7-bitcharacters (to avoid later uncontrollable changes by a relaying or receiving MTA), and afterediting header section by a content filter. Similar applies to local mailing lists, which may berewriting messages, requiring them to be re-signed by the domain hosting a mailing list, justbefore being sent out.

Starting with amavisd-new version 2.6.0, DKIM signing can be performed directly by amavisd(using a Perl module Mail::DKIM, which is the same module as used by DKIMproxy and bySpamAssassin). Signing directly by amavisd reduces setup complexity using a milter or


19/29

DKIMproxy, and avoids additional data transfers. Regarding mail flow through the systemthere are similarities between signing in amavisd and signing by dkim-milter, which is why thediagram below shows both possibilities.

For verification there are three choices: either amavisd itself can do it by calling Mail::DKIMdirectly, or a SpamAssassin plugin can do it by calling the same Perl module, or a milter in

verification-only mode can be invoked by an incoming Postfix smtpd service.

Advantage of invoking signature verification by amavisd is that all mail is checked forsignatures, regardless of whether SpamAssassin is called or not. Typically messages beyonda certain size are not passed to SpamAssassin, and neither are infected message or identifiedbounces. Amavisd also offers loading of policy banks based on valid DKIM/DK signatures(e.g. allowing some domains to send-in otherwise banned files, or whitelisting on spam),offers to add score points based on signing domain reputation, and adds Authentication-Results header field (like a dkim-milter does).

Invoking signature verification by SpamAssassin has an advantage that DKIM-based orDomainKeys-based whitelisting or scoring can be used, but has a disadvantage that possiblynot all mail is checked (e.g. large mail and infected mail may be exempt from spam checks).Performing the same signature validation task twice (by amavisd and by SA) may seem

wasteful, but in practice it is not too bad: thanks to DNS server caching a network lookup for apublic signing key is only done once, and as SpamAssassin does not receive large mail forprocessing, its signature verification is very quick: few milliseconds for non-signed mail, and ofthe order of a tenth of a second for signed mail.

Invoking signature verification by calling a milter from incoming smtpd service has anadvantage that it has the best chance of seeing mail in its pristine form (before canonical andvirtual mapping or masquerading by MTA, regardless of their settings). Because it is poorlyintegrated with the rest of the chain (e.g. with SpamAssassin rules and amavisd policy banks),and because it adds one extra data transfer, it is mainly still useful as a way to double-checkthe correctness of DKIM validation by having two independent implementations in use, eachinserting its independently derived Authentication-Results header field into passed mail.

To sign as late as possible with a dkim-milter, the signing milter can be invoked by a Postfixsmtpd service which is receiving content-checked mail from a content filter such as amavisd-new. As this second-stage smtpd service does not reliably know how a given message cameinto a mail system and whether it is supposed to be signed or not, a clean solution is toprovide two (or more) parallel paths through MTA and through a content filter, one used formail that is eligible for being signed (originating mail), the other for all the rest. This same dualpath approach through amavisd is beneficial for signing by amavisd too, for the same reasonof providing a reliable source of information on mail origin to a signature choosing code:

+------+|verify| (verify)+--+---+ | (by amavisd and/or SA)^^^ milter |

incoming: ||| +---v-------+MX ----> 25 smtpd ---> 10024 > >---> 10025 smtpd -->

|| | |SASL --> 25 smtpd \ | amavisd | (notifications)

submission | +-> | >--->_mynets-> 25 smtpd ---> 10026 >ORIGINATING>---> 10027 smtpd -->

submission +-> +-------^---+ |--> 587 smtpd / : | v milter

(convert | +------+to 7-bit) (sign) | sign |

+------+

There are other benefits to providing two parallel paths: a content filter may be configured toapply different rules and settings to mail that is known to be originating from our users. Somesuggestions: apply less strict banning rules, enable spam administrator notifications for

internally originating spam and viruses, letting SpamAssassin rules be conditionalized basedon amavisd-new policy banks loaded, etc.Configuring multiple mail paths in Postfix


20/29

Here is one way of configuring Postfix for providing two paths through a content filter. Locallysubmitted or authenticated mail will go to a content filter to its port 10026 and will be signed onits way out (either by amavisd or by a signing milter). All other mail (incoming) will be divertedto port 10024 for normal content filtering, and will not be eligible for signing.

main.cf:# on re-queueing of a message smtpd_*_restrictions do not apply,# so we'd better provide a safe default for a content_filter,# even at an expense of later flipping the choice twice# (which adds a bit to log clutter, but never mind)#content_filter = amavisfeed:[127.0.0.1]:10024

# each triggered FILTER deposits its argument into a# content_filter setting, the last deposited value applies#smtpd_sender_restrictions =check_sender_access regexp:/etc/postfix/tag_as_originating.repermit_mynetworks

permit_sasl_authenticatedpermit_tls_clientcertscheck_sender_access regexp:/etc/postfix/tag_as_foreign.re

# Make sure to assign FILTER tags in restrictions which# are only invoked once per message, e.g. client or sender# restrictions, but NOT on smtpd_recipient_restrictions,# as a message may have multiple recipients, so multiple# passes through FILTER tag assignments can yield a# surprising (and incorrect) result.

/etc/postfix/tag_as_originating.re:/^/ FILTER amavisfeed:[127.0.0.1]:10026

/etc/postfix/tag_as_foreign.re:/^/ FILTER amavisfeed:[127.0.0.1]:10024

In master.cf set up two listening smtpd services for receiving filtered mail from amavisd (asper README.postfix), one on tcp port 10025 (for inbound mail) and the other on port 10027(for originating mail). If a signing milter is in use it will be attached to a smtpd service on 10027only. If no milters are in use and signing is done by amavisd, both smtpd services can haveexactly the same settings, and in fact only one suffices, in which case redirecting$forward_method and $notify_method to 'smtp:[127.0.0.1]:10027' in later example can bedisregarded.Configuring multiple mail paths in amavisd

In amavisd.conf two parallel paths need to be provided, one receiving on port 10024 and

forwarding to 10025, the other receiving on port 10026 and forwarding to 10027.$inet_socket_port = [10024,10026]; # listen on two ports

The 10024>10025 path will be controlled by a default policy bank, the other (10026>10027),dedicated to mail intended to be signed, will use a policy bank (arbitrarily) namedORIGINATING:$forward_method = 'smtp:[127.0.0.1]:10025'; # MTA with non-signing service$notify_method = 'smtp:[127.0.0.1]:10027'; # MTA with signing service

# switch policy bank to 'ORIGINATING' for mail received on port 10026:$interface_policy{'10026'} = 'ORIGINATING';

$policy_bank{'ORIGINATING'} = { # mail originating from our users

originating => 1, # indicates client is ours, allows signing## force MTA to convert mail to 7-bit before DKIM signing


21/29

# to avoid later conversions which could destroy signature:smtpd_discard_ehlo_keywords => ['8BITMIME'],## forward to a smtpd service providing DKIM signing service# (if using a signing milter instead of signing by amavisd):forward_method => 'smtp:[127.0.0.1]:10027',

## other special treatment of locally originating mail,# just some suggestions here:spam_admin_maps => ["spamalert\@$mydomain"], # warn of spam from usvirus_admin_maps => ["virusalert\@$mydomain"],banned_filename_maps => ['ALT-RULES'], # more relaxed rulesspam_quarantine_cutoff_level_maps => undef, # quarantine all spamspam_dsn_cutoff_level_maps => undef,spam_dsn_cutoff_level_bysender_maps => # bounce to local senders only[ { lc(".$mydomain") => undef, '.' => 15 } ],

};

The smtpd_discard_ehlo_keywords=>['8BITMIME'] serves to persuade Postfix to convert mailto 7-bit quoted-printable before submitting it to content filtering and signing. Avoiding 8-bit

characters in mail body makes signatures less susceptible to breaking by some relaying orreceiving MTA over which we have no control. The same effect (making Postfix convertoutgoing mail to 7-bits before DKIM signing) could be achieved by a Postfix settingsmtp_discard_ehlo_keywords=8bitmime on a smtp service feeding mail-to-be-signed toamavisd, but this would require setting up two such services, one with the option and onewithout.

Note that 8-bit to 7-bit conversion may break a S/MIME or PGP signature, so if mail signing isin use, it may not be desirable to let Postfix do the conversion, and it may be acceptable totake a risk that a remote MTA will clobber signatures if it decides the mail text is to beconverted to 7-bits QP. The only reliable solution in this case is to configure MUA clients tostick to 7-bit characters/encodings before generating S/MIME or PGP signatures.

The following text from the Postfix documentation file MILTER_README should bedisregarded -- amavisd is 8-bit clean, and we do want Postfix to convert to 7-bits on thesigning path but not on the other path: Content filters may break domain key etc. signatures. Ifyou use an SMTP-based content filter, then you should add a line to master.cf with "-odisable_mime_output_conversion=yes", as described in the advanced content filter example.

While testing how the configured system plays with some mailing lists (such as postfix-usersor SpamAssassin users list), one has to keep in mind that amavisd-new caches spamchecking results of recently seen message bodies: a mail going out to a mailing list is not yetsigned as it reaches a content filter, but the SpamAssassin verdict is remembered at that point(claiming the message is not signed). When this message with unchanged body comes backfrom a mailing list, this time signed in the header section by our domain, the signature shouldprove correct, yet the cached result from a minute ago still claims the message is not signed.If this is of concern, one can turn off caching of spam checking results for ham by setting:

$spam_check_negative_ttl = 0;

While on the topic of providing multiple paths through amavisd, when one has to deal with amailing list manager (e.g. Mailman) in the same setup, and re-signing of its fan-out mail isdesired, it may be useful to add a third path through amavisd, this one stripped down to barebones, providing only DKIM signing and nothing else (no virus or spam checks, no decoding),as these checks were already done once on mail before it reached a mailing list manager.Here is one possibility, accepting mail on port 10028 and sending it to 10025:$inet_socket_port = [10024,10026,10028];

$interface_policy{'10028'} = 'NOCHECKS';

$policy_bank{'NOCHECKS'} = { # no checks, just DKIM signing

originating => 1, # allows signingforward_method => 'smtp:[127.0.0.1]:10025',smtpd_greeting_banner =>


22/29

'${helo-name} ${protocol} ${product} NOCHECKS service ready',mynetworks_maps => [], # avoids loading MYNETS policy unnecessarilyos_fingerprint_method => undef,penpals_bonus_score => undef,bounce_killer_score => 0,bypass_decode_parts => 1,

bypass_header_checks_maps => [1],bypass_virus_checks_maps => [1],bypass_spam_checks_maps => [1],bypass_banned_checks_maps => [1],spam_lovers_maps => [1],banned_files_lovers_maps => [1],archive_quarantine_to_maps => [],remove_existing_x_scanned_headers => undef,remove_existing_spam_headers => undef,signed_header_fields => { 'Sender' => 1 },

};Hooking-in dkim-milter (optional)

This section can be ignored when all DKIM signing and verification is to be done by amavisd,

and dkim-milter will not be used. It is mainly provided for compatibility reasons, retaining theold documentation section.

Let's begin by starting a dkim milter in two instances, one dedicated to signing, the other toverification. For security reasons all milters should run under a dedicated username, certainlynot as root, not as user amavis and not as user postfix or mail:

verifying:dkim-filter -u dkfilter -b v \-l -p inet:[email protected] -P /var/run/dkim-filter-v.pid

signing:dkim-filter -u dkimfilter -b s -m ORIGINATING \

-c relaxed/simple -S rsa-sha1 \-d example.com -s myselector -k /var/db/dkim/mykey.pem \-l -p inet:[email protected] -P /var/run/dkim-filter-s.pid

Generating a public and a private pair of keys and publishing a public key in DNS is describedin the dkim milter documentation and also in the DKIM RFC document.

We are not specifying option -i to milters, the default of -i 127.0.0.1 suits our setup just fine, asmail to be signed is coming from a content filter, usually on a loopback interface from the IPaddress 127.0.0.1.

Now we can tie the verifying milter to a Postfix smtpd service listening for incoming mail:

master.cf:

smtp inet n - n - 300 smtpd-o milter_default_action=accept-o milter_macro_daemon_name=MTA-o smtpd_milters=inet:127.0.0.1:4443

and tie the signing milter to a Postfix smtpd service that is receiving checked mail fromamavisd, intended to be signed:

master.cf:# mail return from a content filter (non-signing)10025 inet n - n - - smtpd-o content_filter=... (other options, mail not to be signed) ...

# mail from our users returning from a content filter (DKIM signing)10027 inet n - n - - smtpd


23/29

-o content_filter=... (other options, mail intended to be signed) ...-o milter_default_action=accept-o milter_macro_daemon_name=ORIGINATING-o smtpd_milters=inet:127.0.0.1:4445

As a sidenote, attaching milters to sendmail would use the same order of invocations:signature verifying milter first, content filters next, and signing milter last, for example:dnl Verifiers:INPUT_MAIL_FILTER(`dkim-filter-v', `S=inet:[email protected], T=R:2m')

dnl Content filter:INPUT_MAIL_FILTER(`amavisd-milter',`S=unix:/var/amavis/amavisd-milter.sock, F=T, T=S:10m;R:10m;E:10m')

dnl Signers:INPUT_MAIL_FILTER(`dkim-filter-s', `S=inet:[email protected], T=R:2m')

Setting up DKIM signature verification in amavisd

Starting with 2.6.0, verification of DKIM signatures (and historical DomainKeys signatures) is

provided directly by amavisd (not only by a SpamAssassin plugin DKIM). A required version ofa perl module Mail::DKIM is 0.31 or later, but recommended is 0.33 or later. Signatureverification is sufficiently fast so there is no need for concern about extra processing load (seeTIMING breakdown in your log, level 2). To turn on DKIM (and historical DomainKeys)signature verification, please add the following line to amavisd.conf (if not already there):$enable_dkim_verification = 1;

Benefits:Whitelisting of banned checks or spam checks on messages carrying valid DKIM orDomainKeys signatures from trustworthy signers is possible through the@author_to_policy_bank_maps list of lookup tables. The mechanism uses loading of policybanks based on author's e-mail address (addresses in a 'From:' header field) and a signingdomain, so a full flexibility of per-policy-bank settings is available. See description of a new

configuration variable @author_to_policy_bank_maps in release notes.To each message passed to local recipients amavisd inserts a header field Authentication-Results (according to RFC 5451) for each signature found in a message, reporting averification result. These header fields can reliably tell a recipient or his MUA what domainsclaimed responsibility for a message, or can be used for troubleshooting DKIM signing,verification and tracking mail transformations.Can adjust spam score based on signing domain's reputation for valid signatures found in amessage. A useful reputation metric is an average long term spam score for past messagessigned by a domain, which can currently be provided manually by @signer_reputation_mapsin a configuration file (see example in release notes). A spam score is shifted towards thisreputation score by a configurable factor $reputation_factor (value between 0 and 1, default is0.2) using a formula: adjusted_spam_score = f * reputation + (1-f) * spam_score . Semanticsof a $reputation_factor is equivalent to auto_whitelist_factor in a SpamAssassin's AWL plugin,which shifts spam score towards a long term spam score average of a sender.

Notifications and bounces show a "(dkim:AUTHOR)" next to a From address, and a"(dkim:SENDER)" next to a Sender address if these header fields were signed and theirdomain corresponds to a signer's domain identity.A valid DKIM or DomainKeys signature turns on a 'sender_credible' attribute which serves tochoose one of the two DSN cutoff levels, so that delivery status notifications can be restrictedto or preferred for likely-to-be-valid sending addresses, and bounces to possibly fakeaddresses can be minimized. More information on the 'sender_credible' attribute can be foundin release notes.

Currently the ADSP (RFC 5617, Author Domain Signing Practices, formerly SSP) is notimplemented by amavisd, but is implemented in the SpamAssassin's plugin DKIM as ofversion 3.3.0.Setting up DKIM signing in amavisd

A recommended version of a perl module Mail::DKIM is 0.33 or later when signing.


24/29

1. Generate one or more keys to be used for signing, and enable signing code by adding thefollowing line to amavisd.conf (if not already there):$enable_dkim_signing = 1; # loads DKIM signing code

Signing keys must be made available to amavisd, each private key in a separate file in PEMformat. Customarily such keys would be generated and kept in a dedicated directory such as

/var/db/dkim or /var/lib/dkim, preferably owned by root.

Private keys can be generated by a 'openssl genrsa' command (see RFC 4871 Appendix C),or by an amavisd equivalent. Commonly one key per signing domain or one key per signinghost is used, but other choices are possible. If such keys were already prepared for someother DKIM-signing solution, they can be reused by amavisd.# amavisd genrsa /var/db/dkim/a.key.pem# amavisd genrsa /var/db/dkim/b.key.pem 786# amavisd genrsa /var/db/dkim/sel-example-com.key.pem# amavisd genrsa /var/db/dkim/g-guest-ex-com.key.pem# amavisd genrsa /var/db/dkim/notif-mail.key.pem 512

Amavisd already ensures the generated files are only readable by owner, but a manualprocedure may require explicitly setting file permissions. Private keys must be protected from

unauthorized access, only the signing software such as amavisd should have access.Amavisd loads these files on startup before dropping privileges, so if amavisd is started asroot it is not necessary that these key files are readable by uid under which amavisd isrunning.

2. Add commands to amavisd.conf to load private keys, associate them with signing domainsand selectors, and describe constraints (tags) to be published with public keys.

Calls to dkim_key() load all available private keys and supply their public key RR constraints.Arguments are a domain, a selector, a key (a file name of a private key in PEM format),followed by optional attributes/constraints (tags, represented here as Perl hash key/valuepairs) which are allowed by RFC 4871 in a public key resource record (v, g, h, k, n, s, t), ofwhich only g, h, k, s and t are considered to be constraints limiting the choice of a signing key.

A command 'amavisd showkeys' can be used for displaying corresponding public keys in aformat directly suitable for inclusion into DNS zone files.

For example:# signing domain selector private key options# ------------- -------- ---------------------- ----------dkim_key('example.org', 'abc', '/var/db/dkim/a.key.pem');dkim_key('example.org', 'yyy', '/var/db/dkim/b.key.pem', t=>'s');dkim_key('example.org', 'zzz', '/var/db/dkim/b.key.pem', h=>'sha256');dkim_key('example.com', 'sel-2008', '/var/db/dkim/sel-example-com.key.pem',

t=>'s:y', g=>'*', k=>'rsa', h=>'sha256:sha1', s=>'email',n=>'testing; 1, 2');

dkim_key('guest.example.com', 'g', '/var/db/dkim/g-guest-ex-com.key.pem');dkim_key('mail.example.com', 'notif', '/var/db/dkim/notif-mail.key.pem');

A selector paired with a domain name uniquely identifies a key, both for a signer as well as fora recipient. There may be multiple keys for each domain as long as each one has its ownselector.

A selector along with a domain name will be used by a receiving mailer in assembling a DNSquery (selector._domainkey.signingdomain) to fetch a public key from a signing domain's DNSserver when verifying signature validity.

A selector paired with a domain name will also be used by a signing amavisd when choosing akey applicable to signing, meeting constraints on its public key (tags, RFC 4871 section 3.6)as given by optional arguments. Optional arguments serve as site documentation, may helpamavisd choose between multiple choices (ruling out keys with incompatible tags), and supply

additional information for step 3.

For a list of options (tags) see RFC 4871 section 3.6. Amavisd does not check the syntax of


25/29

tag values, except for performing qp-section encoding of a tag 'n'. Note the Perl syntax ofkey/value pairs, e.g. t => 's:y' will end up as "t=s:y", and n => 'testing; 1, 2' will end up encodedas "n=testing=3B 1, 2".

3. Prepare and publish public keys.

Public keys can be extracted from generated key files (which contain both a private and apublic key). To publish public keys they need to be edited into a format suitable for inclusion ina DNS server's zone file for each signing domain, either by following a procedure in RFC 4871Appendix C, or if step 2 was completed, by asking amavisd to do so:# amavisd showkeys

or more selectively, e.g.:# amavisd showkeys .org example.com

This step is not needed if public keys were already prepared and published earlier for someother DKIM-signing solution.

4. Edit zone files in master DNS server(s) for each signing domain, adding the just preparedTXT resource records, not forgetting to bump up the serial number in a SOA record.

Optionally add a TXT record with ADSP information (formerly SSP) if a default Author DomainSigning Practices is not appropriate. Then reload zone(s) or restart DNS server(s).

5. Test published public keys.

Similar to 'showkeys', a 'testkeys' command walks through available signing keys (as declaredby calls to dkim_key), generates test messages each signed with one key, and validates themby fetching a corresponding public key from a DNS server.# amavisd testkeys

or more selectively, e.g.:# amavisd testkeys .org example.com

(btw, if testkeys fails and you believe your DNS is correctly serving your DKIM public keys, youmay need to upgrade Perl module Mail-DKIM to version 0.33)

6. Restart amavisd, watch the log at log level 2, searching for " dkim: ".

Note that signing could be started (amavisd reload) right after completing step 2, but mailrecipients would not be able to verify validity of signatures until public keys are made availableby a signing domain through its DNS. Recipients are supposed to treat mail with signatureswhich fail verification exactly the same as mail with no signatures, so there is usually no harmdone with a premature start of signing, but there is no benefit either.

7. Optional: to override default values for signature tags, one may specify by-sender signaturetags through @dkim_signature_options_bysender_maps.

@dkim_signature_options_bysender_maps maps author/sender addresses or domains tosignature tags/requirements. Possible signature tags according to RFC 4871 are: (v), a, (b),(bh), c, d, (h), i, l, q, s, (t), x, z; of which the following are determined automatically: v, b, bh, h,t (tag h is controlled by %signed_header_fields). Currently ignored tags are l and z. Instead ofan absolute expiration time (tag x) one may use a pseudo tag 'ttl' to specify a relativeexpiration time in seconds, which is converted to an absolute expiration time prior to signing: x= t + ttl. A built-in default is provided for each tag if no better match is found.

For example:@dkim_signature_options_bysender_maps = ( {'[email protected]' => { a => 'rsa-sha1', ttl => 7*24*3600 },'[email protected]' => { a => 'rsa-sha1', ttl => 7*24*3600 },'mail.example.com' => { a => 'rsa-sha1', ttl => 10*24*3600 },

# explicit 'd' forces a third-party signature on foreign (hosted) domains'ggg.example.net' => { d => 'guest.example.com' },'.example.com' => { d => 'example.com' },


26/29

# catchall defaults'.' => { a => 'rsa-sha256', c => 'relaxed/simple', ttl => 30*24*3600 },# 'd' defaults to a domain of an author/sender address,# 's' defaults to whatever selector is offered by a matching key

} );

The result of a by-sender lookup into @dkim_signature_options_bysender_maps is a hash (aset) of DKIM signing requirements (tags), i.e. canonicalization method, hashing algorithm,domain, identity, selector and expiration time. All matching entries can participate in the result:for each tag individually the first setting (the most specific) is chosen from all matching entries.Resulting tags are then used to choose the most appropriate signing key from a set of keys asdeclared by calls to dkim_key. Main selection criterium is a match on tags d (domain) and s(selector), but other signature requirements must also meet the constraints of a public key(e.g. subdomain matching flag, granularity, hashing algorithm, key type). If a lookup does notfind a signing key which meets requirements, no signing takes place. Also, only mail with'originating' flag is eligible for signing. A lookup is based on either the From header field, theSender header field, the Resent-From and Resent-Sender header field, or on a mail_fromaddress from the envelope, whichever yields a useful result first. Note that neither the Senderheader field, nor the Resent-* header fields, nor a mail_from address has any specialmeaning in the standard (RFC 4871). This results either in an author signature (i.e. a first-

party signature, when based on a From header field), or in a third-party signature (whensigning domain does not match the From, regardless of what other header field (or forcedthrough a 'd' tag) it was based on.

An associative array %signed_header_fields controls which header fields are to be signed. Bydefault it contains a standard (RFC 4871) set of header field names, augmented by someadditional header field names considered appropriate at the time of a release (RFC 4021,RFC 3834). In addition a 'Sender' header field is excluded because it is frequently replaced bya mailing list, and as the RFC 2821 mandates there can only be one such header field theoriginal one is dropped, invalidating a signature. Also the 'To' and 'Cc' are excluded from adefault set because sendmail mailers are known to gratuitously reformat the list, invalidating asignature.

The default set of header fields to be signed can be controlled by setting %signed_header_fields elements to true (to sign) or to false (not to sign). Keys must be inlowercase, e.g.:$signed_header_fields{'received'} = 0; # turn off signing of Received$signed_header_fields{'sender'} = 1; # turn on signing of Sender$signed_header_fields{'to'} = 1; # turn on signing of To$signed_header_fields{'cc'} = 1; # turn on signing of Cc$signed_header_fields{lc('X-MySpecialFlag')} = 1;

Putting DKIM verification to good use in SpamAssassin

In SpamAssassin all that is necessary is to add (or uncomment) a line in any of the .pre files(e.g. in local.pre, or in init.pre and v320.pre):loadplugin Mail::SpamAssassin::Plugin::DKIM

Perl module Mail::DKIM needs to be installed. Note that Mail::DKIM starting with version 0.20also recognizes DomainKeys signatures, so that Plugin::DomainKeys is not needed anylonger, and in fact its underlying module is not supported any longer. It is advisable to stick tothe most recent version of Mail::DKIM, at least 0.32.

The following SpamAssassin rules (in local.cf) work quite well.score DKIM_VERIFIED -0.1score DKIM_SIGNED 0

# don't waste time on fetching ASP re

Documents

Amavisd-new Documentation Bits and Pieces