diff --git a/include/mbedtls/config.h b/include/mbedtls/config.h
index 4c8fc3c..7d0960a 100644
--- a/include/mbedtls/config.h
+++ b/include/mbedtls/config.h
@@ -283,6 +283,7 @@
 //#define MBEDTLS_MD2_ALT
 //#define MBEDTLS_MD4_ALT
 //#define MBEDTLS_MD5_ALT
+//#define MBEDTLS_POLY1305_ALT
 //#define MBEDTLS_RIPEMD160_ALT
 //#define MBEDTLS_RSA_ALT
 //#define MBEDTLS_SHA1_ALT
@@ -2399,6 +2400,15 @@
 #define MBEDTLS_PLATFORM_C
 
 /**
+ * \def MBEDTLS_POLY1305_C
+ *
+ * Enable the Poly1305 MAC algorithm.
+ *
+ * Module:  library/poly1305.c
+ */
+#define MBEDTLS_POLY1305_C
+
+/**
  * \def MBEDTLS_RIPEMD160_C
  *
  * Enable the RIPEMD-160 hash algorithm.
diff --git a/include/mbedtls/error.h b/include/mbedtls/error.h
index ace0c47..feeda79 100644
--- a/include/mbedtls/error.h
+++ b/include/mbedtls/error.h
@@ -77,6 +77,7 @@
  * SHA256    1                  0x0037-0x0037
  * SHA512    1                  0x0039-0x0039
  * CHACHA20  1                  0x003B-0x003B
+ * POLY1305  1                  0x0041-0x0041
  *
  * High-level module nr (3 bits - 0x0...-0x7...)
  * Name      ID  Nr of Errors
diff --git a/include/mbedtls/poly1305.h b/include/mbedtls/poly1305.h
new file mode 100644
index 0000000..1aa55ae
--- /dev/null
+++ b/include/mbedtls/poly1305.h
@@ -0,0 +1,142 @@
+/**
+ * \file poly1305.h
+ *
+ * \brief Poly1305 authenticator algorithm.
+ *
+ *  Copyright (C) 2006-2016, ARM Limited, All Rights Reserved
+ *  SPDX-License-Identifier: Apache-2.0
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"); you may
+ *  not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *  This file is part of mbed TLS (https://tls.mbed.org)
+ */
+#ifndef MBEDTLS_POLY1305_H
+#define MBEDTLS_POLY1305_H
+
+#if !defined(MBEDTLS_CONFIG_FILE)
+#include "mbedtls/config.h"
+#else
+#include MBEDTLS_CONFIG_FILE
+#endif
+
+#include <stdint.h>
+#include <stddef.h>
+
+#if !defined(MBEDTLS_POLY1305_ALT)
+
+#define MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA -0x0041 /**< Invalid input parameter(s). */
+
+typedef struct
+{
+    uint32_t r[4];      /** Stores the value for 'r' (low 128 bits of the key) */
+    uint32_t s[4];      /** Stores the value for 's' (high 128 bits of the key) */
+    uint32_t acc[5];    /** Accumulator number */
+    uint8_t queue[16];  /** Stores partial block data */
+    size_t queue_len;   /** Number of bytes stored in 'queue'. Always less than 16 */
+}
+mbedtls_poly1305_context;
+
+/**
+ * \brief               Initialize a Poly1305 context
+ *
+ * \param ctx           The Poly1305 context to be initialized
+ */
+void mbedtls_poly1305_init( mbedtls_poly1305_context *ctx );
+
+/**
+ * \brief               Clear a Poly1305 context
+ *
+ * \param ctx           The Poly1305 context to be cleared
+ */
+void mbedtls_poly1305_free( mbedtls_poly1305_context *ctx );
+
+/**
+ * \brief               Set the Poly1305 authentication key.
+ *
+ * \warning             The key should be unique, and \b MUST be
+ *                      unpredictable for each invocation of Poly1305.
+ *
+ * \param ctx           The Poly1305 context.
+ * \param key           Buffer containing the 256-bit key.
+ *
+ * \return              MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA is returned if ctx
+ *                      or key are NULL.
+ *                      Otherwise, 0 is returned to indicate success.
+ */
+int mbedtls_poly1305_setkey( mbedtls_poly1305_context *ctx,
+                             const unsigned char key[32] );
+
+/**
+ * \brief               Process data with Poly1305.
+ *
+ *                      This function can be called multiple times to process
+ *                      a stream of data.
+ *
+ * \param ctx           The Poly1305 context.
+ * \param ilen          The input length (in bytes). Any value is accepted.
+ * \param input         Buffer containing the input data to Process.
+ *
+ * \return              MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA is returned if ctx
+ *                      or input are NULL.
+ *                      Otherwise, 0 is returned to indicate success.
+ */
+int mbedtls_poly1305_update( mbedtls_poly1305_context *ctx,
+                             size_t ilen,
+                             const unsigned char *input );
+
+/**
+ * \brief               Generate the Poly1305 MAC.
+ *
+ * \param ctx           The Poly1305 context.
+ * \param mac           Buffer to where the MAC is written. Must be big enough
+ *                      to hold the 16-byte MAC.
+ *
+ * \return              MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA is returned if ctx
+ *                      or mac are NULL.
+ *                      Otherwise, 0 is returned to indicate success.
+ */
+int mbedtls_poly1305_finish( mbedtls_poly1305_context *ctx,
+                             unsigned char mac[16] );
+
+#else  /* MBEDTLS_POLY1305_ALT */
+#include "poly1305_alt.h"
+#endif /* MBEDTLS_POLY1305_ALT */
+
+/**
+ * \brief               Generate the Poly1305 MAC of some data with the given key.
+ *
+ * \warning             The key should be unique, and \b MUST be
+ *                      unpredictable for each invocation of Poly1305.
+ *
+ * \param key           Buffer containing the 256-bit (32 bytes) key.
+ * \param ilen          The length of the input data (in bytes).
+ * \param input         Buffer containing the input data to process.
+ * \param mac           Buffer to where the 128-bit (16 bytes) MAC is written.
+ *
+ * \return              MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA is returned if key,
+ *                      input, or mac are NULL.
+ *                      Otherwise, 0 is returned to indicate success.
+ */
+int mbedtls_poly1305_mac( const unsigned char key[32],
+                          size_t ilen,
+                          const unsigned char *input,
+                          unsigned char mac[16] );
+
+/**
+ * \brief               Checkup routine
+ *
+ * \return              0 if successful, or 1 if the test failed
+ */
+int mbedtls_poly1305_self_test( int verbose );
+
+#endif /* MBEDTLS_POLY1305_H */
diff --git a/library/CMakeLists.txt b/library/CMakeLists.txt
index 78bab7f..251b6c6 100644
--- a/library/CMakeLists.txt
+++ b/library/CMakeLists.txt
@@ -48,6 +48,7 @@
     pkwrite.c
     platform.c
     platform_util.c
+    poly1305.c
     ripemd160.c
     rsa.c
     rsa_internal.c
diff --git a/library/Makefile b/library/Makefile
index 4fab598..5fd693b 100644
--- a/library/Makefile
+++ b/library/Makefile
@@ -63,11 +63,11 @@
 		padlock.o	pem.o		pk.o		\
 		pk_wrap.o	pkcs12.o	pkcs5.o		\
 		pkparse.o	pkwrite.o	platform.o	\
-		platform_util.o	ripemd160.o	rsa_internal.o	\
-		rsa.o 		sha1.o		sha256.o	\
-		sha512.o	threading.o	timing.o	\
-		version.o	version_features.o		\
-		xtea.o
+		platform_util.o	poly1305.o			\
+		ripemd160.o	rsa_internal.o	rsa.o  		\
+		sha1.o		sha256.o	sha512.o	\
+		threading.o	timing.o	version.o	\
+		version_features.o		xtea.o
 
 OBJS_X509=	certs.o		pkcs11.o	x509.o		\
 		x509_create.o	x509_crl.o	x509_crt.o	\
diff --git a/library/error.c b/library/error.c
index 2aaf359..12bd210 100644
--- a/library/error.c
+++ b/library/error.c
@@ -153,6 +153,10 @@
 #include "mbedtls/pkcs5.h"
 #endif
 
+#if defined(MBEDTLS_POLY1305_C)
+#include "mbedtls/poly1305.h"
+#endif
+
 #if defined(MBEDTLS_RIPEMD160_C)
 #include "mbedtls/ripemd160.h"
 #endif
@@ -774,6 +778,11 @@
         mbedtls_snprintf( buf, buflen, "PADLOCK - Input data should be aligned" );
 #endif /* MBEDTLS_PADLOCK_C */
 
+#if defined(MBEDTLS_POLY1305_C)
+    if( use_ret == -(MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA) )
+        mbedtls_snprintf( buf, buflen, "POLY1305 - Invalid input parameter(s)" );
+#endif /* MBEDTLS_POLY1305_C */
+
 #if defined(MBEDTLS_RIPEMD160_C)
     if( use_ret == -(MBEDTLS_ERR_RIPEMD160_HW_ACCEL_FAILED) )
         mbedtls_snprintf( buf, buflen, "RIPEMD160 - RIPEMD160 hardware accelerator failed" );
diff --git a/library/poly1305.c b/library/poly1305.c
new file mode 100644
index 0000000..9a61a85
--- /dev/null
+++ b/library/poly1305.c
@@ -0,0 +1,518 @@
+/**
+ * \file poly1305.c
+ *
+ * \brief Poly1305 authentication algorithm.
+ *
+ *  Copyright (C) 2006-2016, ARM Limited, All Rights Reserved
+ *  SPDX-License-Identifier: Apache-2.0
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"); you may
+ *  not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *  This file is part of mbed TLS (https://tls.mbed.org)
+ */
+#if !defined(MBEDTLS_CONFIG_FILE)
+#include "mbedtls/config.h"
+#else
+#include MBEDTLS_CONFIG_FILE
+#endif
+
+#if defined(MBEDTLS_POLY1305_C)
+
+#if !defined(MBEDTLS_POLY1305_ALT)
+
+#include "mbedtls/poly1305.h"
+
+#include <string.h>
+
+#if defined(MBEDTLS_SELF_TEST)
+#if defined(MBEDTLS_PLATFORM_C)
+#include "mbedtls/platform.h"
+#else
+#include <stdio.h>
+#define mbedtls_printf printf
+#endif /* MBEDTLS_PLATFORM_C */
+#endif /* MBEDTLS_SELF_TEST */
+
+#define POLY1305_BLOCK_SIZE_BYTES ( 16U )
+
+#define BYTES_TO_U32_LE( data, offset )                   \
+    ( (uint32_t)data[offset] |                            \
+      (uint32_t)( (uint32_t)data[(offset) + 1] << 8 )  |  \
+      (uint32_t)( (uint32_t)data[(offset) + 2] << 16 ) |  \
+      (uint32_t)( (uint32_t)data[(offset) + 3] << 24 )    \
+    )
+
+/* Implementation that should never be optimized out by the compiler */
+static void mbedtls_zeroize( void *v, size_t n ) {
+    volatile unsigned char *p = v; while( n-- ) *p++ = 0;
+}
+
+/**
+ * \brief                   Process blocks with Poly1305.
+ *
+ * \param ctx               The Poly1305 context.
+ * \param nblocks           Number of blocks to process. Note that this function
+ *                          only processes full blocks.
+ * \param input             Buffer containing the input block(s).
+ * \param needs_padding     Set to 0 if the padding bit has already been applied
+ *                          to the input data before calling this function.
+ *                          Otherwise, set this parameter to 1.
+ */
+static void mbedtls_poly1305_process( mbedtls_poly1305_context *ctx,
+                                      size_t nblocks,
+                                      const unsigned char *input,
+                                      uint32_t needs_padding )
+{
+    uint64_t d0, d1, d2, d3;
+    uint32_t acc0, acc1, acc2, acc3, acc4;
+    uint32_t r0, r1, r2, r3;
+    uint32_t rs1, rs2, rs3;
+    size_t offset  = 0U;
+    size_t i;
+
+    r0 = ctx->r[0];
+    r1 = ctx->r[1];
+    r2 = ctx->r[2];
+    r3 = ctx->r[3];
+
+    rs1 = r1 + ( r1 >> 2U );
+    rs2 = r2 + ( r2 >> 2U );
+    rs3 = r3 + ( r3 >> 2U );
+
+    acc0 = ctx->acc[0];
+    acc1 = ctx->acc[1];
+    acc2 = ctx->acc[2];
+    acc3 = ctx->acc[3];
+    acc4 = ctx->acc[4];
+
+    /* Process full blocks */
+    for ( i = 0U; i < nblocks; i++ )
+    {
+        /* Compute: acc += block */
+        /* Note that the input block is treated as a 128-bit little-endian integer */
+        d0   = (uint64_t)acc0 + BYTES_TO_U32_LE( input, offset + 0  );
+        d1   = (uint64_t)acc1 + BYTES_TO_U32_LE( input, offset + 4  ) + ( d0 >> 32U );
+        d2   = (uint64_t)acc2 + BYTES_TO_U32_LE( input, offset + 8  ) + ( d1 >> 32U );
+        d3   = (uint64_t)acc3 + BYTES_TO_U32_LE( input, offset + 12 ) + ( d2 >> 32U );
+        acc0 = (uint32_t)d0;
+        acc1 = (uint32_t)d1;
+        acc2 = (uint32_t)d2;
+        acc3 = (uint32_t)d3;
+        acc4 += (uint32_t)( d3 >> 32U ) + needs_padding;
+
+        /* Compute: acc *= r */
+        d0 = ( (uint64_t)acc0 * r0  ) +
+             ( (uint64_t)acc1 * rs3 ) +
+             ( (uint64_t)acc2 * rs2 ) +
+             ( (uint64_t)acc3 * rs1 );
+        d1 = ( (uint64_t)acc0 * r1  ) +
+             ( (uint64_t)acc1 * r0  ) +
+             ( (uint64_t)acc2 * rs3 ) +
+             ( (uint64_t)acc3 * rs2 ) +
+             ( (uint64_t)acc4 * rs1 );
+        d2 = ( (uint64_t)acc0 * r2  ) +
+             ( (uint64_t)acc1 * r1  ) +
+             ( (uint64_t)acc2 * r0  ) +
+             ( (uint64_t)acc3 * rs3 ) +
+             ( (uint64_t)acc4 * rs2 );
+        d3 = ( (uint64_t)acc0 * r3  ) +
+             ( (uint64_t)acc1 * r2  ) +
+             ( (uint64_t)acc2 * r1  ) +
+             ( (uint64_t)acc3 * r0  ) +
+             ( (uint64_t)acc4 * rs3 );
+        acc4 *= r0;
+
+        /* Compute: acc %= (2^130 - 5) (partial remainder) */
+        d1 += ( d0 >> 32 );
+        d2 += ( d1 >> 32 );
+        d3 += ( d2 >> 32 );
+        acc0 = (uint32_t)d0;
+        acc1 = (uint32_t)d1;
+        acc2 = (uint32_t)d2;
+        acc3 = (uint32_t)d3;
+        acc4 = (uint32_t)( d3 >> 32 ) + acc4;
+
+        d0 = (uint64_t)acc0 + ( acc4 >> 2 ) + ( acc4 & 0xFFFFFFFCU );
+        acc4 &= 3U;
+        acc0 = (uint32_t)d0;
+        d0 = (uint64_t)acc1 + ( d0 >> 32U );
+        acc1 = (uint32_t)d0;
+        d0 = (uint64_t)acc2 + ( d0 >> 32U );
+        acc2 = (uint32_t)d0;
+        d0 = (uint64_t)acc3 + ( d0 >> 32U );
+        acc3 = (uint32_t)d0;
+        d0 = (uint64_t)acc4 + ( d0 >> 32U );
+        acc4 = (uint32_t)d0;
+
+        offset    += POLY1305_BLOCK_SIZE_BYTES;
+    }
+
+    ctx->acc[0] = acc0;
+    ctx->acc[1] = acc1;
+    ctx->acc[2] = acc2;
+    ctx->acc[3] = acc3;
+    ctx->acc[4] = acc4;
+}
+
+/**
+ * \brief                   Compute the Poly1305 MAC
+ *
+ * \param ctx               The Poly1305 context.
+ * \param mac               The buffer to where the MAC is written. Must be
+ *                          big enough to contain the 16-byte MAC.
+ */
+static void mbedtls_poly1305_compute_mac( const mbedtls_poly1305_context *ctx,
+                                          unsigned char mac[16] )
+{
+    uint64_t d;
+    uint32_t g0, g1, g2, g3, g4;
+    uint32_t acc0, acc1, acc2, acc3, acc4;
+    uint32_t mask;
+    uint32_t mask_inv;
+
+    acc0 = ctx->acc[0];
+    acc1 = ctx->acc[1];
+    acc2 = ctx->acc[2];
+    acc3 = ctx->acc[3];
+    acc4 = ctx->acc[4];
+
+    /* Before adding 's' we need to ensure that the accumulator is mod 2^130 - 5.
+     * We do this by calculating acc - (2^130 - 5), then checking if
+     * the 131st bit is set. If it is, then reduce: acc -= (2^130 - 5)
+     */
+
+    /* Calculate acc + -(2^130 - 5) */
+    d  = ( (uint64_t)acc0 + 5U );
+    g0 = (uint32_t)d;
+    d  = ( (uint64_t)acc1 + ( d >> 32 ) );
+    g1 = (uint32_t)d;
+    d  = ( (uint64_t)acc2 + ( d >> 32 ) );
+    g2 = (uint32_t)d;
+    d  = ( (uint64_t)acc3 + ( d >> 32 ) );
+    g3 = (uint32_t)d;
+    g4 = acc4 + (uint32_t)( d >> 32U );
+
+    /* mask == 0xFFFFFFFF if 131st bit is set, otherwise mask == 0 */
+    mask = (uint32_t)0U - ( g4 >> 2U );
+    mask_inv = ~mask;
+
+    /* If 131st bit is set then acc=g, otherwise, acc is unmodified */
+    acc0 = ( acc0 & mask_inv ) | ( g0 & mask );
+    acc1 = ( acc1 & mask_inv ) | ( g1 & mask );
+    acc2 = ( acc2 & mask_inv ) | ( g2 & mask );
+    acc3 = ( acc3 & mask_inv ) | ( g3 & mask );
+
+    /* Add 's' */
+    d = (uint64_t)acc0 + ctx->s[0];
+    acc0 = (uint32_t)d;
+    d = (uint64_t)acc1 + ctx->s[1] + ( d >> 32U );
+    acc1 = (uint32_t)d;
+    d = (uint64_t)acc2 + ctx->s[2] + ( d >> 32U );
+    acc2 = (uint32_t)d;
+    acc3 += ctx->s[3] + (uint32_t)( d >> 32U );
+
+    /* Compute MAC (128 least significant bits of the accumulator) */
+    mac[0]  = (uint8_t)acc0;
+    mac[1]  = (uint8_t)( acc0 >> 8  );
+    mac[2]  = (uint8_t)( acc0 >> 16 );
+    mac[3]  = (uint8_t)( acc0 >> 24 );
+    mac[4]  = (uint8_t)acc1;
+    mac[5]  = (uint8_t)( acc1 >> 8  );
+    mac[6]  = (uint8_t)( acc1 >> 16 );
+    mac[7]  = (uint8_t)( acc1 >> 24 );
+    mac[8]  = (uint8_t)acc2;
+    mac[9]  = (uint8_t)( acc2 >> 8  );
+    mac[10] = (uint8_t)( acc2 >> 16 );
+    mac[11] = (uint8_t)( acc2 >> 24 );
+    mac[12] = (uint8_t)acc3;
+    mac[13] = (uint8_t)( acc3 >> 8  );
+    mac[14] = (uint8_t)( acc3 >> 16 );
+    mac[15] = (uint8_t)( acc3 >> 24 );
+}
+
+void mbedtls_poly1305_init( mbedtls_poly1305_context *ctx )
+{
+    if ( ctx != NULL )
+    {
+        mbedtls_zeroize( ctx, sizeof(mbedtls_poly1305_context) );
+    }
+}
+
+void mbedtls_poly1305_free( mbedtls_poly1305_context *ctx )
+{
+    if ( ctx != NULL )
+    {
+        mbedtls_zeroize( ctx, sizeof(mbedtls_poly1305_context) );
+    }
+}
+
+int mbedtls_poly1305_setkey( mbedtls_poly1305_context *ctx,
+                             const unsigned char key[32] )
+{
+    if ( ctx == NULL )
+    {
+        return( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
+    }
+
+    /* r &= 0x0ffffffc0ffffffc0ffffffc0fffffff */
+    ctx->r[0] = BYTES_TO_U32_LE( key, 0 )  & 0x0FFFFFFFU;
+    ctx->r[1] = BYTES_TO_U32_LE( key, 4 )  & 0x0FFFFFFCU;
+    ctx->r[2] = BYTES_TO_U32_LE( key, 8 )  & 0x0FFFFFFCU;
+    ctx->r[3] = BYTES_TO_U32_LE( key, 12 ) & 0x0FFFFFFCU;
+
+    ctx->s[0] = BYTES_TO_U32_LE( key, 16 );
+    ctx->s[1] = BYTES_TO_U32_LE( key, 20 );
+    ctx->s[2] = BYTES_TO_U32_LE( key, 24 );
+    ctx->s[3] = BYTES_TO_U32_LE( key, 28 );
+
+    /* Initial accumulator state */
+    ctx->acc[0] = 0U;
+    ctx->acc[1] = 0U;
+    ctx->acc[2] = 0U;
+    ctx->acc[3] = 0U;
+
+    return 0;
+}
+
+int mbedtls_poly1305_update( mbedtls_poly1305_context *ctx,
+                             size_t ilen,
+                             const unsigned char* input )
+{
+    size_t offset    = 0U;
+    size_t remaining = ilen;
+    size_t queue_free_len;
+    size_t nblocks;
+
+    if ( ( ctx == NULL ) || ( input == NULL ) )
+    {
+        return( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
+    }
+
+    if ( ctx->queue_len > 0U )
+    {
+        queue_free_len = ( POLY1305_BLOCK_SIZE_BYTES - ctx->queue_len );
+
+        if ( ilen < queue_free_len )
+        {
+            /* Not enough data to complete the block.
+             * Store this data with the other leftovers.
+             */
+            memcpy( &ctx->queue[ctx->queue_len],
+                    input,
+                    ilen );
+
+            ctx->queue_len += ilen;
+
+            remaining = 0U;
+        }
+        else
+        {
+            /* Enough data to produce a complete block */
+            memcpy( &ctx->queue[ctx->queue_len],
+                    input,
+                    queue_free_len );
+
+            ctx->queue_len = 0U;
+
+            mbedtls_poly1305_process( ctx,
+                                      1U,
+                                      ctx->queue,
+                                      1U ); /* add padding bit */
+
+            offset    += queue_free_len;
+            remaining -= queue_free_len;
+        }
+    }
+
+    if ( remaining >= POLY1305_BLOCK_SIZE_BYTES )
+    {
+        nblocks = remaining / POLY1305_BLOCK_SIZE_BYTES;
+
+        mbedtls_poly1305_process( ctx, nblocks, &input[offset], 1U );
+
+        offset += nblocks * POLY1305_BLOCK_SIZE_BYTES;
+        remaining %= POLY1305_BLOCK_SIZE_BYTES;
+    }
+
+    if ( remaining > 0U )
+    {
+        /* Store partial block */
+        ctx->queue_len = remaining;
+        memcpy( ctx->queue, &input[offset], remaining );
+    }
+
+    return( 0 );
+}
+
+int mbedtls_poly1305_finish( mbedtls_poly1305_context *ctx,
+                             unsigned char mac[16] )
+{
+    if ( ( ctx == NULL ) || ( mac == NULL ) )
+    {
+        return( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA );
+    }
+
+    /* Process any leftover data */
+    if ( ctx->queue_len > 0U )
+    {
+        /* Add padding bit */
+        ctx->queue[ctx->queue_len] = 1U;
+        ctx->queue_len++;
+
+        /* Pad with zeroes */
+        memset( &ctx->queue[ctx->queue_len],
+                0,
+                POLY1305_BLOCK_SIZE_BYTES - ctx->queue_len );
+
+        mbedtls_poly1305_process( ctx,
+                                  1U,           /* Process 1 block */
+                                  ctx->queue,
+                                  0U );         /* Don't add padding bit (it was just added above) */
+    }
+
+    mbedtls_poly1305_compute_mac( ctx, mac );
+
+    return( 0 );
+}
+
+#endif /* MBEDTLS_POLY1305_ALT */
+
+int mbedtls_poly1305_mac( const unsigned char key[32],
+                           size_t ilen,
+                           const unsigned char *input,
+                           unsigned char mac[16] )
+{
+    mbedtls_poly1305_context ctx;
+    int result;
+
+    mbedtls_poly1305_init( &ctx );
+
+    result = mbedtls_poly1305_setkey( &ctx, key );
+    if ( result != 0 )
+        goto cleanup;
+
+    result = mbedtls_poly1305_update( &ctx, ilen, input );
+    if ( result != 0 )
+        goto cleanup;
+
+    result = mbedtls_poly1305_finish( &ctx, mac );
+
+cleanup:
+    mbedtls_poly1305_free( &ctx );
+    return( 0 );
+}
+
+#if defined(MBEDTLS_SELF_TEST)
+
+static const unsigned char test_keys[2][32] =
+{
+    {
+        0x85, 0xd6, 0xbe, 0x78, 0x57, 0x55, 0x6d, 0x33,
+        0x7f, 0x44, 0x52, 0xfe, 0x42, 0xd5, 0x06, 0xa8,
+        0x01, 0x03, 0x80, 0x8a, 0xfb, 0x0d, 0xb2, 0xfd,
+        0x4a, 0xbf, 0xf6, 0xaf, 0x41, 0x49, 0xf5, 0x1b
+    },
+    {
+        0x1c, 0x92, 0x40, 0xa5, 0xeb, 0x55, 0xd3, 0x8a,
+        0xf3, 0x33, 0x88, 0x86, 0x04, 0xf6, 0xb5, 0xf0,
+        0x47, 0x39, 0x17, 0xc1, 0x40, 0x2b, 0x80, 0x09,
+        0x9d, 0xca, 0x5c, 0xbc, 0x20, 0x70, 0x75, 0xc0
+    }
+};
+
+static const unsigned char test_data[2][127] =
+{
+    {
+        0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x67, 0x72,
+        0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x46, 0x6f,
+        0x72, 0x75, 0x6d, 0x20, 0x52, 0x65, 0x73, 0x65,
+        0x61, 0x72, 0x63, 0x68, 0x20, 0x47, 0x72, 0x6f,
+        0x75, 0x70
+    },
+    {
+        0x27, 0x54, 0x77, 0x61, 0x73, 0x20, 0x62, 0x72,
+        0x69, 0x6c, 0x6c, 0x69, 0x67, 0x2c, 0x20, 0x61,
+        0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73,
+        0x6c, 0x69, 0x74, 0x68, 0x79, 0x20, 0x74, 0x6f,
+        0x76, 0x65, 0x73, 0x0a, 0x44, 0x69, 0x64, 0x20,
+        0x67, 0x79, 0x72, 0x65, 0x20, 0x61, 0x6e, 0x64,
+        0x20, 0x67, 0x69, 0x6d, 0x62, 0x6c, 0x65, 0x20,
+        0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x77,
+        0x61, 0x62, 0x65, 0x3a, 0x0a, 0x41, 0x6c, 0x6c,
+        0x20, 0x6d, 0x69, 0x6d, 0x73, 0x79, 0x20, 0x77,
+        0x65, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20,
+        0x62, 0x6f, 0x72, 0x6f, 0x67, 0x6f, 0x76, 0x65,
+        0x73, 0x2c, 0x0a, 0x41, 0x6e, 0x64, 0x20, 0x74,
+        0x68, 0x65, 0x20, 0x6d, 0x6f, 0x6d, 0x65, 0x20,
+        0x72, 0x61, 0x74, 0x68, 0x73, 0x20, 0x6f, 0x75,
+        0x74, 0x67, 0x72, 0x61, 0x62, 0x65, 0x2e
+    }
+};
+
+static const size_t test_data_len[2] =
+{
+    34U,
+    127U
+};
+
+static const unsigned char test_mac[2][16] =
+{
+    {
+        0xa8, 0x06, 0x1d, 0xc1, 0x30, 0x51, 0x36, 0xc6,
+        0xc2, 0x2b, 0x8b, 0xaf, 0x0c, 0x01, 0x27, 0xa9
+    },
+    {
+        0x45, 0x41, 0x66, 0x9a, 0x7e, 0xaa, 0xee, 0x61,
+        0xe7, 0x08, 0xdc, 0x7c, 0xbc, 0xc5, 0xeb, 0x62
+    }
+};
+
+int mbedtls_poly1305_self_test( int verbose )
+{
+    uint8_t mac[16];
+    size_t i;
+    int result;
+
+    for ( i = 0U; i < 2U; i++ )
+    {
+        result = mbedtls_poly1305_mac( test_keys[i],
+                                        test_data_len[i],
+                                        test_data[i],
+                                        mac );
+        if ( result != 0 )
+        {
+            if ( verbose != 0 )
+            {
+                mbedtls_printf( "Poly1305 test %zi error code: %i\n", i, result );
+            }
+
+            return( -1 );
+        }
+
+        if ( memcmp( mac, test_mac[i], 16U ) != 0 )
+        {
+            if ( verbose != 0 )
+            {
+                mbedtls_printf( "Poly1305 test %zi failed\n", i );
+            }
+
+            return( -1 );
+        }
+    }
+
+    return( 0 );
+}
+
+#endif /* MBEDTLS_SELF_TEST */
+
+#endif /* MBEDTLS_POLY1305_C */
diff --git a/library/version_features.c b/library/version_features.c
index febd506..babf2c7 100644
--- a/library/version_features.c
+++ b/library/version_features.c
@@ -168,6 +168,9 @@
 #if defined(MBEDTLS_SHA512_PROCESS_ALT)
     "MBEDTLS_SHA512_PROCESS_ALT",
 #endif /* MBEDTLS_SHA512_PROCESS_ALT */
+#if defined(MBEDTLS_POLY1305_ALT)
+    "MBEDTLS_POLY1305_ALT",
+#endif /* MBEDTLS_POLY1305_ALT */
 #if defined(MBEDTLS_DES_SETKEY_ALT)
     "MBEDTLS_DES_SETKEY_ALT",
 #endif /* MBEDTLS_DES_SETKEY_ALT */
@@ -639,6 +642,9 @@
 #if defined(MBEDTLS_PLATFORM_C)
     "MBEDTLS_PLATFORM_C",
 #endif /* MBEDTLS_PLATFORM_C */
+#if defined(MBEDTLS_POLY1305_C)
+    "MBEDTLS_POLY1305_C",
+#endif /* MBEDTLS_POLY1305_C */
 #if defined(MBEDTLS_RIPEMD160_C)
     "MBEDTLS_RIPEMD160_C",
 #endif /* MBEDTLS_RIPEMD160_C */
diff --git a/programs/test/benchmark.c b/programs/test/benchmark.c
index bc473cf..c419665 100644
--- a/programs/test/benchmark.c
+++ b/programs/test/benchmark.c
@@ -63,6 +63,7 @@
 #include "mbedtls/gcm.h"
 #include "mbedtls/ccm.h"
 #include "mbedtls/cmac.h"
+#include "mbedtls/poly1305.h"
 #include "mbedtls/havege.h"
 #include "mbedtls/ctr_drbg.h"
 #include "mbedtls/hmac_drbg.h"
@@ -95,7 +96,8 @@
 #define OPTIONS                                                         \
     "md4, md5, ripemd160, sha1, sha256, sha512,\n"                      \
     "arc4, des3, des, camellia, blowfish, chacha20,\n"                  \
-    "aes_cbc, aes_gcm, aes_ccm, aes_cmac, des3_cmac,\n"                 \
+    "aes_cbc, aes_gcm, aes_ccm,\n"                                      \
+    "aes_cmac, des3_cmac, poly1305\n"                                   \
     "havege, ctr_drbg, hmac_drbg\n"                                     \
     "rsa, dhm, ecdsa, ecdh.\n"
 
@@ -231,6 +233,7 @@
          arc4, des3, des,
          aes_cbc, aes_gcm, aes_ccm, aes_cmac, des3_cmac,
          camellia, blowfish, chacha20,
+         poly1305,
          havege, ctr_drbg, hmac_drbg,
          rsa, dhm, ecdsa, ecdh;
 } todo_list;
@@ -289,6 +292,8 @@
                 todo.blowfish = 1;
             else if( strcmp( argv[i], "chacha20" ) == 0 )
                 todo.chacha20 = 1;
+            else if( strcmp( argv[i], "poly1305" ) == 0 )
+                todo.poly1305 = 1;
             else if( strcmp( argv[i], "havege" ) == 0 )
                 todo.havege = 1;
             else if( strcmp( argv[i], "ctr_drbg" ) == 0 )
@@ -530,6 +535,13 @@
     }
 #endif
 
+#if defined(MBEDTLS_POLY1305_C)
+    if ( todo.poly1305 )
+    {
+        TIME_AND_TSC( "Poly1305", mbedtls_poly1305_mac( buf, BUFSIZE, buf, buf ) );
+    }
+#endif
+
 #if defined(MBEDTLS_BLOWFISH_C) && defined(MBEDTLS_CIPHER_MODE_CBC)
     if( todo.blowfish )
     {
diff --git a/scripts/generate_errors.pl b/scripts/generate_errors.pl
index 36ee60b..1dac39b 100755
--- a/scripts/generate_errors.pl
+++ b/scripts/generate_errors.pl
@@ -32,7 +32,7 @@
 my @low_level_modules = qw( AES ARC4 ASN1 BASE64 BIGNUM BLOWFISH
                             CAMELLIA CCM CHACHA20 CMAC CTR_DRBG DES
                             ENTROPY GCM HMAC_DRBG MD2 MD4 MD5
-                            NET OID PADLOCK PBKDF2 RIPEMD160
+                            NET OID PADLOCK PBKDF2 POLY1305 RIPEMD160
                             SHA1 SHA256 SHA512 THREADING XTEA );
 my @high_level_modules = qw( CIPHER DHM ECP MD
                              PEM PK PKCS12 PKCS5
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 3821657..82f1554 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -98,6 +98,7 @@
 add_test_suite(pk)
 add_test_suite(pkparse)
 add_test_suite(pkwrite)
+add_test_suite(poly1305)
 add_test_suite(shax)
 add_test_suite(ssl)
 add_test_suite(timing)
diff --git a/tests/Makefile b/tests/Makefile
index 34a0a89..90b2028 100644
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -82,6 +82,7 @@
 	test_suite_pkcs1_v21$(EXEXT)	test_suite_pkcs5$(EXEXT)	\
 	test_suite_pkparse$(EXEXT)	test_suite_pkwrite$(EXEXT)	\
 	test_suite_pk$(EXEXT)						\
+	test_suite_poly1305$(EXEXT)					\
 	test_suite_rsa$(EXEXT)		test_suite_shax$(EXEXT)		\
 	test_suite_ssl$(EXEXT)		test_suite_timing$(EXEXT)			\
 	test_suite_x509parse$(EXEXT)	test_suite_x509write$(EXEXT)	\
@@ -414,6 +415,10 @@
 	echo "  CC    $<"
 	$(CC) $(LOCAL_CFLAGS) $(CFLAGS) $<	$(LOCAL_LDFLAGS) $(LDFLAGS) -o $@
 
+test_suite_poly1305$(EXEXT): test_suite_poly1305.c $(DEP)
+	echo "  CC    $<"
+	$(CC) $(LOCAL_CFLAGS) $(CFLAGS) $<	$(LOCAL_LDFLAGS) $(LDFLAGS) -o $@
+
 test_suite_rsa$(EXEXT): test_suite_rsa.c $(DEP)
 	echo "  CC    $<"
 	$(CC) $(LOCAL_CFLAGS) $(CFLAGS) $<	$(LOCAL_LDFLAGS) $(LDFLAGS) -o $@
diff --git a/tests/suites/test_suite_poly1305.data b/tests/suites/test_suite_poly1305.data
new file mode 100644
index 0000000..f259e84
--- /dev/null
+++ b/tests/suites/test_suite_poly1305.data
@@ -0,0 +1,51 @@
+Poly1305 RFC 7539 Example And Test Vector
+depends_on:MBEDTLS_POLY1305_C
+mbedtls_poly1305:"85d6be7857556d337f4452fe42d506a80103808afb0db2fd4abff6af4149f51b":"a8061dc1305136c6c22b8baf0c0127a9":"43727970746f6772617068696320466f72756d2052657365617263682047726f7570"
+
+Poly1305 RFC 7539 Test Vector #1
+depends_on:MBEDTLS_POLY1305_C
+mbedtls_poly1305:"0000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+
+Poly1305 RFC 7539 Test Vector #2
+depends_on:MBEDTLS_POLY1305_C
+mbedtls_poly1305:"0000000000000000000000000000000036e5f6b5c5e06070f0efca96227a863e":"36e5f6b5c5e06070f0efca96227a863e":"416e79207375626d697373696f6e20746f20746865204945544620696e74656e6465642062792074686520436f6e7472696275746f7220666f72207075626c69636174696f6e20617320616c6c206f722070617274206f6620616e204945544620496e7465726e65742d4472616674206f722052464320616e6420616e792073746174656d656e74206d6164652077697468696e2074686520636f6e74657874206f6620616e204945544620616374697669747920697320636f6e7369646572656420616e20224945544620436f6e747269627574696f6e222e20537563682073746174656d656e747320696e636c756465206f72616c2073746174656d656e747320696e20494554462073657373696f6e732c2061732077656c6c206173207772697474656e20616e6420656c656374726f6e696320636f6d6d756e69636174696f6e73206d61646520617420616e792074696d65206f7220706c6163652c207768696368206172652061646472657373656420746f"
+
+Poly1305 RFC 7539 Test Vector #3
+depends_on:MBEDTLS_POLY1305_C
+mbedtls_poly1305:"36e5f6b5c5e06070f0efca96227a863e00000000000000000000000000000000":"f3477e7cd95417af89a6b8794c310cf0":"416e79207375626d697373696f6e20746f20746865204945544620696e74656e6465642062792074686520436f6e7472696275746f7220666f72207075626c69636174696f6e20617320616c6c206f722070617274206f6620616e204945544620496e7465726e65742d4472616674206f722052464320616e6420616e792073746174656d656e74206d6164652077697468696e2074686520636f6e74657874206f6620616e204945544620616374697669747920697320636f6e7369646572656420616e20224945544620436f6e747269627574696f6e222e20537563682073746174656d656e747320696e636c756465206f72616c2073746174656d656e747320696e20494554462073657373696f6e732c2061732077656c6c206173207772697474656e20616e6420656c656374726f6e696320636f6d6d756e69636174696f6e73206d61646520617420616e792074696d65206f7220706c6163652c207768696368206172652061646472657373656420746f"
+
+Poly1305 RFC 7539 Test Vector #4
+depends_on:MBEDTLS_POLY1305_C
+mbedtls_poly1305:"1c9240a5eb55d38af333888604f6b5f0473917c1402b80099dca5cbc207075c0":"4541669a7eaaee61e708dc7cbcc5eb62":"2754776173206272696c6c69672c20616e642074686520736c6974687920746f7665730a446964206779726520616e642067696d626c6520696e2074686520776162653a0a416c6c206d696d737920776572652074686520626f726f676f7665732c0a416e6420746865206d6f6d65207261746873206f757467726162652e"
+
+Poly1305 RFC 7539 Test Vector #5
+depends_on:MBEDTLS_POLY1305_C
+mbedtls_poly1305:"0200000000000000000000000000000000000000000000000000000000000000":"03000000000000000000000000000000":"ffffffffffffffffffffffffffffffff"
+
+Poly1305 RFC 7539 Test Vector #6
+depends_on:MBEDTLS_POLY1305_C
+mbedtls_poly1305:"02000000000000000000000000000000ffffffffffffffffffffffffffffffff":"03000000000000000000000000000000":"02000000000000000000000000000000"
+
+Poly1305 RFC 7539 Test Vector #7
+depends_on:MBEDTLS_POLY1305_C
+mbedtls_poly1305:"0100000000000000000000000000000000000000000000000000000000000000":"05000000000000000000000000000000":"fffffffffffffffffffffffffffffffff0ffffffffffffffffffffffffffffff11000000000000000000000000000000"
+
+Poly1305 RFC 7539 Test Vector #8
+depends_on:MBEDTLS_POLY1305_C
+mbedtls_poly1305:"0100000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"fffffffffffffffffffffffffffffffffbfefefefefefefefefefefefefefefe01010101010101010101010101010101"
+
+Poly1305 RFC 7539 Test Vector #9
+depends_on:MBEDTLS_POLY1305_C
+mbedtls_poly1305:"0200000000000000000000000000000000000000000000000000000000000000":"faffffffffffffffffffffffffffffff":"fdffffffffffffffffffffffffffffff"
+
+Poly1305 RFC 7539 Test Vector #10
+depends_on:MBEDTLS_POLY1305_C
+mbedtls_poly1305:"0100000000000000040000000000000000000000000000000000000000000000":"14000000000000005500000000000000":"e33594d7505e43b900000000000000003394d7505e4379cd01000000000000000000000000000000000000000000000001000000000000000000000000000000"
+
+Poly1305 RFC 7539 Test Vector #11
+depends_on:MBEDTLS_POLY1305_C
+mbedtls_poly1305:"0100000000000000040000000000000000000000000000000000000000000000":"13000000000000000000000000000000":"e33594d7505e43b900000000000000003394d7505e4379cd010000000000000000000000000000000000000000000000"
+
+Poly1305 Selftest
+depends_on:MBEDTLS_SELF_TEST:MBEDTLS_POLY1305_C
+poly1305_selftest:
diff --git a/tests/suites/test_suite_poly1305.function b/tests/suites/test_suite_poly1305.function
new file mode 100644
index 0000000..af69a03
--- /dev/null
+++ b/tests/suites/test_suite_poly1305.function
@@ -0,0 +1,35 @@
+/* BEGIN_HEADER */
+#include "mbedtls/poly1305.h"
+#include <stddef.h>
+/* END_HEADER */
+
+/* BEGIN_CASE depends_on:MBEDTLS_POLY1305_C */
+void mbedtls_poly1305( char *hex_key_string, char *hex_mac_string, char *hex_src_string  )
+{
+    unsigned char src_str[10000];
+    unsigned char mac_str[100];
+    unsigned char key[32];
+    unsigned char mac[16];
+    size_t src_len;
+
+    memset(src_str, 0x00, 10000);
+    memset(mac_str, 0x00, 100);
+    memset(key,     0x00, 32);
+    memset(mac,     0x00, 16);
+
+    src_len = unhexify( src_str, hex_src_string );
+    unhexify( key, hex_key_string );
+
+    mbedtls_poly1305_mac( key, src_len, src_str, mac );
+    hexify( mac_str, mac, 16 );
+
+    TEST_ASSERT( strcmp( (char *) mac_str, hex_mac_string ) == 0 );
+}
+/* END_CASE */
+
+/* BEGIN_CASE depends_on:MBEDTLS_POLY1305_C:MBEDTLS_SELF_TEST */
+void poly1305_selftest()
+{
+    TEST_ASSERT( mbedtls_poly1305_self_test( 0 ) == 0 );
+}
+/* END_CASE */