/*

 * socks5-proto.c

 *

 * Based on the gio socks5 implementation that is not yet included in

 * the latest stable glib release.

 * Original Authors:

 * Youness Alaoui <youness.alaoui@collabora.co.uk>

 * Nicolas Dufresne <nicolas.dufresne@collabora.co.uk>

 *

 * Copyrigth (C) 2010 Nicolas Cornu <nicolas.cornu@ensi-bourges.fr>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or (at

 * your option) any later version.

 *

 * This program is distributed in the hope that it will be useful, but

 * WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307

 * USA

 */

#include <glib.h>

#include <gio/gio.h>

#include <string.h>

#include "socks5-proto.h"

#define SOCKS5_VERSION            0x05

#define SOCKS5_CMD_CONNECT        0x01

#define SOCKS5_CMD_BIND           0x02

#define SOCKS5_CMD_UDP_ASSOCIATE  0x03

#define SOCKS5_ATYP_IPV4          0x01

#define SOCKS5_ATYP_DOMAINNAME    0x03

#define SOCKS5_ATYP_IPV6          0x04

#define SOCKS5_AUTH_VERSION       0x01

#define SOCKS5_AUTH_NONE          0x00

#define SOCKS5_AUTH_GSSAPI        0x01

#define SOCKS5_AUTH_USR_PASS      0x02

#define SOCKS5_AUTH_NO_ACCEPT     0xff

#define SOCKS5_MAX_LEN            255

#define SOCKS5_RESERVED           0x00

#define SOCKS5_REP_SUCCEEDED      0x00

#define SOCKS5_REP_SRV_FAILURE    0x01

#define SOCKS5_REP_NOT_ALLOWED    0x02

#define SOCKS5_REP_NET_UNREACH    0x03

#define SOCKS5_REP_HOST_UNREACH   0x04

#define SOCKS5_REP_REFUSED        0x05

#define SOCKS5_REP_TTL_EXPIRED    0x06

#define SOCKS5_REP_CMD_NOT_SUP    0x07

#define SOCKS5_REP_ATYPE_NOT_SUP  0x08

#define S5B_DST_PORT              0

/*

 * +----+----------+----------+

 * |VER | NMETHODS | METHODS  |

 * +----+----------+----------+

 * | 1  |    1     | 1 to 255 |

 * +----+----------+----------+

 */

#define SOCKS5_NEGO_MSG_LEN       4

static gint

client_set_nego_msg (guint8 *msg, gboolean has_auth)

{

  gint len = 3;

  msg[0] = SOCKS5_VERSION;

  msg[1] = 0x01; /* number of methods supported */

  msg[2] = SOCKS5_AUTH_NONE;

  /* add support for authentication method */

  if (has_auth) {

    msg[1] = 0x02; /* number of methods supported */

    msg[3] = SOCKS5_AUTH_USR_PASS;

    len++;

  }

  return len;

}

/*

 * +----+--------+

 * |VER | METHOD |

 * +----+--------+

 * | 1  |   1    |

 * +----+--------+

 */

static gint

server_set_nego_reply_msg (guint8 *msg, guint8 method)

{

  gint len = 2;

  msg[0] = SOCKS5_VERSION;

  msg[1] = method; /* selected method */

  return len;

}

/*

 * +----+--------+

 * |VER | METHOD |

 * +----+--------+

 * | 1  |   1    |

 * +----+--------+

 */

#define SOCKS5_NEGO_REP_LEN       2

static gboolean

client_parse_nego_reply (const guint8 *data,

                         gboolean     has_auth,

                         gboolean    *must_auth,

                         GError     **error)

{

  if (data[0] != SOCKS5_VERSION) {

    g_set_error_literal (error, S5B_SOCKS5_ERROR, S5B_SOCKS5_ERROR_FAILED,

                         "The server is not a SOCKSv5 proxy server.");

    return FALSE;

  }

  switch (data[1]) {

    case SOCKS5_AUTH_NONE:

      *must_auth = FALSE;

      break;

    case SOCKS5_AUTH_USR_PASS:

      if (!has_auth) {

        g_set_error_literal (error, S5B_SOCKS5_ERROR, S5B_SOCKS5_ERROR_NEED_AUTH,

                             "The SOCKSv5 proxy requires authentication.");

        return FALSE;

      }

      *must_auth = TRUE;

      break;

    case SOCKS5_AUTH_GSSAPI:

    case SOCKS5_AUTH_NO_ACCEPT:

    default:

      g_set_error_literal (error, S5B_SOCKS5_ERROR, S5B_SOCKS5_ERROR_AUTH_FAILED,

                           "The SOCKSv5 require an authentication method that is not "

                           "supported.");

      return FALSE;

      break;

  }

  return TRUE;

}

/*

 * +----+----------+----------+

 * |VER | NMETHODS | METHODS  |

 * +----+----------+----------+

 * | 1  |    1     | 1 to 255 |

 * +----+----------+----------+

 */

static gboolean

server_parse_nego_init (const guint8 *data,

                        gssize        datalen,

                        GError      **error)

{

  guint i;

  if (data[0] != SOCKS5_VERSION) {

    g_set_error_literal (error, S5B_SOCKS5_ERROR, S5B_SOCKS5_ERROR_FAILED,

                         "The client is not a SOCKSv5 client.");

    return FALSE;

  }

  for (i = 2; i < datalen && i < data[1]; ++i) {

    guint8 method = data[i];

    if (method == 0x00)

      return TRUE;

  }

  g_set_error_literal (error, S5B_SOCKS5_ERROR, S5B_SOCKS5_ERROR_AUTH_FAILED,

                       "The client did not offer any authentication method "

                       "we support.");

  return FALSE;

}

#define SOCKS5_AUTH_MSG_LEN       515

static gint

set_auth_msg (guint8      *msg,

              const gchar *username,

              const gchar *password,

              GError **error)

{

  gint len = 0;

  gint ulen = 0; /* username length */

  gint plen = 0; /* Password length */

  if (username)

    ulen = strlen (username);

  if (password)

    plen = strlen (password);

  if (ulen > SOCKS5_MAX_LEN || plen > SOCKS5_MAX_LEN) {

    g_set_error (error, S5B_SOCKS5_ERROR, S5B_SOCKS5_ERROR_FAILED,

                 "Username or password is too long for SOCKSv5 "

                 "protocol (max. is %i).",

                 SOCKS5_MAX_LEN);

    return FALSE;

  }

  msg[len++] = SOCKS5_AUTH_VERSION;

  msg[len++] = ulen;

  if (ulen > 0)

    memcpy (msg + len, username, ulen);

  len += ulen;

  msg[len++] = plen;

  if (plen > 0)

    memcpy (msg + len, password, plen);

  len += plen;

  return len;

}

static gboolean

check_auth_status (const guint8 *data, GError **error)

{

  if (data[0] != SOCKS5_VERSION

      || data[1] != SOCKS5_REP_SUCCEEDED) {

    g_set_error_literal (error, S5B_SOCKS5_ERROR, S5B_SOCKS5_ERROR_AUTH_FAILED,

                         "SOCKSv5 authentication failed due to wrong "

                         "username or password.");

    return FALSE;

  }

  return TRUE;

}

/*

 * +----+-----+-------+------+----------+----------+

 * |VER | CMD |  RSV  | ATYP | DST.ADDR | DST.PORT |

 * +----+-----+-------+------+----------+----------+

 * | 1  |  1  | X'00' |  1   | Variable |    2     |

 * +----+-----+-------+------+----------+----------+

 * DST.ADDR is a string with first byte being the size. So DST.ADDR may not be

 * longer then 256 bytes.

 */

#define SOCKS5_CONN_MSG_LEN       262

static gint

client_set_connect_msg (guint8       *msg,

                        const gchar *hostname,

                        guint16      port,

                        GError     **error)

{

  guint len = 0;

  msg[len++] = SOCKS5_VERSION;

  msg[len++] = SOCKS5_CMD_CONNECT;

  msg[len++] = SOCKS5_RESERVED;

  gsize host_len = strlen (hostname);

  if (host_len > SOCKS5_MAX_LEN) {

    g_set_error (error, S5B_SOCKS5_ERROR, S5B_SOCKS5_ERROR_FAILED,

                 "Hostname '%s' too long for SOCKSv5 protocol "

                 "(maximum is %i bytes)",

                 hostname, SOCKS5_MAX_LEN);

    return -1;

  }

  msg[len++] = SOCKS5_ATYP_DOMAINNAME;

  msg[len++] = (guint8) host_len;

  memcpy (msg + len, hostname, host_len);

  len += host_len;

  {

    guint16 hp = g_htons (port);

    memcpy (msg + len, &hp, 2);

    len += 2;

  }

  return len;

}

static guint

server_parse_connect_msg (const guint8 *data, gint *atype, GError **error)

{

  if (data[0] != SOCKS5_VERSION) {

    g_set_error_literal (error, S5B_SOCKS5_ERROR, S5B_SOCKS5_ERROR_FAILED,

                         "The client is not a SOCKSv5 client.");

    return FALSE;

  }

  if (data[1] != SOCKS5_CMD_CONNECT) {

    g_set_error_literal (error, S5B_SOCKS5_ERROR, S5B_SOCKS5_ERROR_FAILED,

                         "The server only supports the CONNECT command.");

  }

  switch (data[3]) {

    case SOCKS5_ATYP_IPV4:

      *atype = SOCKS5_ATYP_IPV4;

      break;

    case SOCKS5_ATYP_DOMAINNAME:

      *atype = SOCKS5_ATYP_DOMAINNAME;

      break;

    case SOCKS5_ATYP_IPV6:

      *atype = SOCKS5_ATYP_IPV6;

      break;

    default:

      g_set_error_literal (error, S5B_SOCKS5_ERROR, S5B_SOCKS5_ERROR_FAILED,

                           "The client sent an invalid address type.");

      return FALSE;

  }

  return TRUE;

}

/*

 * +----+-----+-------+------+----------+----------+

 * |VER | REP |  RSV  | ATYP | BND.ADDR | BND.PORT |

 * +----+-----+-------+------+----------+----------+

 * | 1  |  1  | X'00' |  1   | Variable |    2     |

 * +----+-----+-------+------+----------+----------+

 * This reply need to be read by small part to determin size. Buffer

 * size is determined in function of the biggest part to read.

 *

 * The parser only requires 4 bytes.

 */

#define SOCKS5_CONN_REP_LEN       255

static gboolean

client_parse_connect_reply (const guint8 *data, gint *atype, GError **error)

{

  if (data[0] != SOCKS5_VERSION) {

    g_set_error_literal (error, S5B_SOCKS5_ERROR, S5B_SOCKS5_ERROR_FAILED,

                         "The server is not a SOCKSv5 proxy server.");

    return FALSE;

  }

  switch (data[1]) {

    case SOCKS5_REP_SUCCEEDED:

      if (data[2] != SOCKS5_RESERVED) {

        g_set_error_literal (error, S5B_SOCKS5_ERROR, S5B_SOCKS5_ERROR_FAILED,

                             "The server is not a SOCKSv5 proxy server.");

        return FALSE;

      }

      switch (data[3]) {

        case SOCKS5_ATYP_IPV4:

        case SOCKS5_ATYP_IPV6:

        case SOCKS5_ATYP_DOMAINNAME:

          *atype = data[3];

          break;

        default:

          g_set_error_literal (error, S5B_SOCKS5_ERROR, S5B_SOCKS5_ERROR_FAILED,

                               "The SOCKSv5 proxy server uses unkown address type.");

          return FALSE;

      }

      break;

    case SOCKS5_REP_SRV_FAILURE:

      g_set_error_literal (error, S5B_SOCKS5_ERROR, S5B_SOCKS5_ERROR_FAILED,

                           "Internal SOCKSv5 proxy server error.");

      return FALSE;

      break;

    case SOCKS5_REP_NOT_ALLOWED:

      g_set_error_literal (error, S5B_SOCKS5_ERROR, S5B_SOCKS5_ERROR_NOT_ALLOWED,

                           "SOCKSv5 connection not allowed by ruleset.");

      return FALSE;

      break;

    case SOCKS5_REP_TTL_EXPIRED:

    case SOCKS5_REP_HOST_UNREACH:

      g_set_error_literal (error, S5B_SOCKS5_ERROR, S5B_SOCKS5_ERROR_HOST_UNREACHABLE,

                           "Host unreachable through SOCKSv5 server.");

      return FALSE;

      break;

    case SOCKS5_REP_NET_UNREACH:

      g_set_error_literal (error, S5B_SOCKS5_ERROR, S5B_SOCKS5_ERROR_NETWORK_UNREACHABLE,

                           "Network unreachable through SOCKSv5 proxy.");

      return FALSE;

      break;

    case SOCKS5_REP_REFUSED:

      g_set_error_literal (error, S5B_SOCKS5_ERROR, S5B_SOCKS5_ERROR_CONNECTION_REFUSED,

                           "Connection refused through SOCKSv5 proxy.");

      return FALSE;

      break;

    case SOCKS5_REP_CMD_NOT_SUP:

      g_set_error_literal (error, S5B_SOCKS5_ERROR, S5B_SOCKS5_ERROR_FAILED,

                           "SOCKSv5 proxy does not support 'connect' command.");

      return FALSE;

      break;

    case SOCKS5_REP_ATYPE_NOT_SUP:

      g_set_error_literal (error, G_IO_ERROR, S5B_SOCKS5_ERROR_FAILED,

                           "SOCKSv5 proxy does not support provided address type.");

      return FALSE;

      break;

    default: /* Unknown error */

      g_set_error_literal (error, G_IO_ERROR, S5B_SOCKS5_ERROR_FAILED,

                           "Unkown SOCKSv5 proxy error.");

      return FALSE;

      break;

  }

  return TRUE;

}

static gint

server_set_connect_reply (guint8 *msg,

                          guint8 rep,

                          guint8 atype,

                          const guint8 *bndaddr,

                          guint16 bndport)

{

  guint len = 0, host_len;

  msg[len++] = SOCKS5_VERSION;

  msg[len++] = rep;

  if (rep != 0)

    return len;

  len++;

  msg[len++] = atype;

  switch (atype) {

    case SOCKS5_ATYP_IPV4:

      // bndaddr should already be in network byte order

      msg[len++] = SOCKS5_ATYP_IPV4;