    001    /*
    002     * Licensed to the Apache Software Foundation (ASF) under one or more
    003     * contributor license agreements.  See the NOTICE file distributed with
    004     * this work for additional information regarding copyright ownership.
    005     * The ASF licenses this file to You under the Apache License, Version 2.0
    006     * (the "License"); you may not use this file except in compliance with
    007     * the License.  You may obtain a copy of the License at
    008     *
    009     *      http://www.apache.org/licenses/LICENSE-2.0
    010     *
    011     * Unless required by applicable law or agreed to in writing, software
    012     * distributed under the License is distributed on an "AS IS" BASIS,
    013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014     * See the License for the specific language governing permissions and
    015     * limitations under the License.
    016     */
    017
    018    package org.apache.commons.net.smtp;
    019
    020    import java.io.IOException;
    021    import java.net.InetAddress;
    022    import java.security.InvalidKeyException;
    023    import java.security.NoSuchAlgorithmException;
    024    import java.security.spec.InvalidKeySpecException;
    025    import javax.crypto.Mac;
    026    import javax.crypto.spec.SecretKeySpec;
    027
    028    import org.apache.commons.net.util.Base64;
    029
    030
    031    /**
    032     * An SMTP Client class with authentication support (RFC4954).
    033     *
    034     * @see SMTPClient
    035     * @since 3.0
    036     */
    037    public class AuthenticatingSMTPClient extends SMTPSClient
    038    {
    039        /**
    040         * The default AuthenticatingSMTPClient constructor.
    041         * Creates a new Authenticating SMTP Client.
    042         * @throws NoSuchAlgorithmException
    043         */
    044        public AuthenticatingSMTPClient() throws NoSuchAlgorithmException
    045        {
    046            super();
    047        }
    048
    049        /**
    050         * Overloaded constructor that takes a protocol specification
    051         * @param protocol The protocol to use
    052         * @throws NoSuchAlgorithmException
    053         */
    054        public AuthenticatingSMTPClient(String protocol) throws NoSuchAlgorithmException {
    055            super(protocol);
    056        }
    057
    058        /***
    059         * A convenience method to send the ESMTP EHLO command to the server,
    060         * receive the reply, and return the reply code.
    061         * <p>
    062         * @param hostname The hostname of the sender.
    063         * @return The reply code received from the server.
    064         * @exception SMTPConnectionClosedException
    065         *      If the SMTP server prematurely closes the connection as a result
    066         *      of the client being idle or some other reason causing the server
    067         *      to send SMTP reply code 421.  This exception may be caught either
    068         *      as an IOException or independently as itself.
    069         * @exception IOException  If an I/O error occurs while either sending the
    070         *      command or receiving the server reply.
    071         ***/
    072        public int ehlo(String hostname) throws IOException
    073        {
    074            return sendCommand(SMTPCommand.EHLO, hostname);
    075        }
    076
    077        /***
    078         * Login to the ESMTP server by sending the EHLO command with the
    079         * given hostname as an argument.  Before performing any mail commands,
    080         * you must first login.
    081         * <p>
    082         * @param hostname  The hostname with which to greet the SMTP server.
    083         * @return True if successfully completed, false if not.
    084         * @exception SMTPConnectionClosedException
    085         *      If the SMTP server prematurely closes the connection as a result
    086         *      of the client being idle or some other reason causing the server
    087         *      to send SMTP reply code 421.  This exception may be caught either
    088         *      as an IOException or independently as itself.
    089         * @exception IOException  If an I/O error occurs while either sending a
    090         *      command to the server or receiving a reply from the server.
    091         ***/
    092        public boolean elogin(String hostname) throws IOException
    093        {
    094            return SMTPReply.isPositiveCompletion(ehlo(hostname));
    095        }
    096
    097
    098        /***
    099         * Login to the ESMTP server by sending the EHLO command with the
    100         * client hostname as an argument.  Before performing any mail commands,
    101         * you must first login.
    102         * <p>
    103         * @return True if successfully completed, false if not.
    104         * @exception SMTPConnectionClosedException
    105         *      If the SMTP server prematurely closes the connection as a result
    106         *      of the client being idle or some other reason causing the server
    107         *      to send SMTP reply code 421.  This exception may be caught either
    108         *      as an IOException or independently as itself.
    109         * @exception IOException  If an I/O error occurs while either sending a
    110         *      command to the server or receiving a reply from the server.
    111         ***/
    112        public boolean elogin() throws IOException
    113        {
    114            String name;
    115            InetAddress host;
    116
    117            host = getLocalAddress();
    118            name = host.getHostName();
    119
    120            if (name == null) {
    121                return false;
    122            }
    123
    124            return SMTPReply.isPositiveCompletion(ehlo(name));
    125        }
    126
    127        /***
    128         * Returns the integer values of the enhanced reply code of the last SMTP reply.
    129         * @return The integer values of the enhanced reply code of the last SMTP reply.
    130         *  First digit is in the first array element.
    131         ***/
    132        public int[] getEnhancedReplyCode()
    133        {
    134            String reply = getReplyString().substring(4);
    135            String[] parts = reply.substring(0, reply.indexOf(' ')).split ("\\.");
    136            int[] res = new int[parts.length];
    137            for (int i = 0; i < parts.length; i++)
    138            {
    139                res[i] = Integer.parseInt (parts[i]);
    140            }
    141            return res;
    142        }
    143
    144        /***
    145         * Authenticate to the SMTP server by sending the AUTH command with the
    146         * selected mechanism, using the given username and the given password.
    147         * <p>
    148         * @return True if successfully completed, false if not.
    149         * @exception SMTPConnectionClosedException
    150         *      If the SMTP server prematurely closes the connection as a result
    151         *      of the client being idle or some other reason causing the server
    152         *      to send SMTP reply code 421.  This exception may be caught either
    153         *      as an IOException or independently as itself.
    154         * @exception IOException  If an I/O error occurs while either sending a
    155         *      command to the server or receiving a reply from the server.
    156         * @exception NoSuchAlgorithmException If the CRAM hash algorithm
    157         *      cannot be instantiated by the Java runtime system.
    158         * @exception InvalidKeyException If the CRAM hash algorithm
    159         *      failed to use the given password.
    160         * @exception InvalidKeySpecException If the CRAM hash algorithm
    161         *      failed to use the given password.
    162         ***/
    163        public boolean auth(AuthenticatingSMTPClient.AUTH_METHOD method,
    164                            String username, String password)
    165                            throws IOException, NoSuchAlgorithmException,
    166                            InvalidKeyException, InvalidKeySpecException
    167        {
    168            if (!SMTPReply.isPositiveIntermediate(sendCommand(SMTPCommand.AUTH,
    169                    AUTH_METHOD.getAuthName(method)))) {
    170                return false;
    171            }
    172
    173            if (method.equals(AUTH_METHOD.PLAIN))
    174            {
    175                // the server sends an empty response ("334 "), so we don't have to read it.
    176                return SMTPReply.isPositiveCompletion(sendCommand(
    177                    new String(
    178                        Base64.encodeBase64(("\000" + username + "\000" + password).getBytes())
    179                        )
    180                    ));
    181            }
    182            else if (method.equals(AUTH_METHOD.CRAM_MD5))
    183            {
    184                // get the CRAM challenge
    185                byte[] serverChallenge = Base64.decodeBase64(getReplyString().substring(4).trim());
    186                // get the Mac instance
    187                Mac hmac_md5 = Mac.getInstance("HmacMD5");
    188                hmac_md5.init(new SecretKeySpec(password.getBytes(), "HmacMD5"));
    189                // compute the result:
    190                byte[] hmacResult = _convertToHexString(hmac_md5.doFinal(serverChallenge)).getBytes();
    191                // join the byte arrays to form the reply
    192                byte[] usernameBytes = username.getBytes();
    193                byte[] toEncode = new byte[usernameBytes.length + 1 /* the space */ + hmacResult.length];
    194                System.arraycopy(usernameBytes, 0, toEncode, 0, usernameBytes.length);
    195                toEncode[usernameBytes.length] = ' ';
    196                System.arraycopy(hmacResult, 0, toEncode, usernameBytes.length + 1, hmacResult.length);
    197                // send the reply and read the server code:
    198                return SMTPReply.isPositiveCompletion(sendCommand(
    199                    new String(Base64.encodeBase64(toEncode))));
    200            }
    201            else if (method.equals(AUTH_METHOD.LOGIN))
    202            {
    203                // the server sends fixed responses (base64("Username") and
    204                // base64("Password")), so we don't have to read them.
    205                if (!SMTPReply.isPositiveIntermediate(sendCommand(
    206                    new String(Base64.encodeBase64(username.getBytes()))))) {
    207                    return false;
    208                }
    209                return SMTPReply.isPositiveCompletion(sendCommand(
    210                    new String(Base64.encodeBase64(password.getBytes()))));
    211            } else {
    212                return false; // safety check
    213            }
    214        }
    215
    216        /**
    217         * Converts the given byte array to a String containing the hex values of the bytes.
    218         * For example, the byte 'A' will be converted to '41', because this is the ASCII code
    219         * (and the byte value) of the capital letter 'A'.
    220         * @param a The byte array to convert.
    221         * @return The resulting String of hex codes.
    222         */
    223        private String _convertToHexString(byte[] a)
    224        {
    225            StringBuilder result = new StringBuilder(a.length*2);
    226            for (int i = 0; i < a.length; i++)
    227            {
    228                if ( (a[i] & 0x0FF) <= 15 ) {
    229                    result.append("0");
    230                }
    231                result.append(Integer.toHexString(a[i] & 0x0FF));
    232            }
    233            return result.toString();
    234        }
    235
    236        /**
    237         * The enumeration of currently-supported authentication methods.
    238         */
    239        public static enum AUTH_METHOD
    240        {
    241            /** The standarised (RFC4616) PLAIN method, which sends the password unencrypted (insecure). */
    242            PLAIN,
    243            /** The standarised (RFC2195) CRAM-MD5 method, which doesn't send the password (secure). */
    244            CRAM_MD5,
    245            /** The unstandarised Microsoft LOGIN method, which sends the password unencrypted (insecure). */
    246            LOGIN;
    247
    248            /**
    249             * Gets the name of the given authentication method suitable for the server.
    250             * @param method The authentication method to get the name for.
    251             * @return The name of the given authentication method suitable for the server.
    252             */
    253            public static final String getAuthName(AUTH_METHOD method)
    254            {
    255                if (method.equals(AUTH_METHOD.PLAIN)) {
    256                    return "PLAIN";
    257                } else if (method.equals(AUTH_METHOD.CRAM_MD5)) {
    258                    return "CRAM-MD5";
    259                } else if (method.equals(AUTH_METHOD.LOGIN)) {
    260                    return "LOGIN";
    261                } else {
    262                    return null;
    263                }
    264            }
    265        }
    266    }
    267
    268    /* kate: indent-width 4; replace-tabs on; */