crypto/poly1305_generic.c

   1 /*
   2  * Poly1305 authenticator algorithm, RFC7539
   3  *
   4  * Copyright (C) 2015 Martin Willi
   5  *
   6  * Based on public domain code by Andrew Moon and Daniel J. Bernstein.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  */
  13
  14 #include <crypto/algapi.h>
  15 #include <crypto/internal/hash.h>
  16 #include <crypto/internal/poly1305.h>
  17 #include <linux/crypto.h>
  18 #include <linux/kernel.h>
  19 #include <linux/module.h>
  20 #include <asm/unaligned.h>
  21
  22 int crypto_poly1305_init(struct shash_desc *desc)
  23 {
  24         struct poly1305_desc_ctx *dctx = shash_desc_ctx(desc);
  25
  26         poly1305_core_init(&dctx->h);
  27         dctx->buflen = 0;
  28         dctx->rset = 0;
  29         dctx->sset = false;
  30
  31         return 0;
  32 }
  33 EXPORT_SYMBOL_GPL(crypto_poly1305_init);
  34
  35 static void poly1305_blocks(struct poly1305_desc_ctx *dctx, const u8 *src,
  36                             unsigned int srclen)
  37 {
  38         unsigned int datalen;
  39
  40         if (unlikely(!dctx->sset)) {
  41                 datalen = crypto_poly1305_setdesckey(dctx, src, srclen);
  42                 src += srclen - datalen;
  43                 srclen = datalen;
  44         }
  45
  46         poly1305_core_blocks(&dctx->h, dctx->r, src,
  47                              srclen / POLY1305_BLOCK_SIZE, 1);
  48 }
  49
  50 int crypto_poly1305_update(struct shash_desc *desc,
  51                            const u8 *src, unsigned int srclen)
  52 {
  53         struct poly1305_desc_ctx *dctx = shash_desc_ctx(desc);
  54         unsigned int bytes;
  55
  56         if (unlikely(dctx->buflen)) {
  57                 bytes = min(srclen, POLY1305_BLOCK_SIZE - dctx->buflen);
  58                 memcpy(dctx->buf + dctx->buflen, src, bytes);
  59                 src += bytes;
  60                 srclen -= bytes;
  61                 dctx->buflen += bytes;
  62
  63                 if (dctx->buflen == POLY1305_BLOCK_SIZE) {
  64                         poly1305_blocks(dctx, dctx->buf,
  65                                         POLY1305_BLOCK_SIZE);
  66                         dctx->buflen = 0;
  67                 }
  68         }
  69
  70         if (likely(srclen >= POLY1305_BLOCK_SIZE)) {
  71                 poly1305_blocks(dctx, src, srclen);
  72                 src += srclen - (srclen % POLY1305_BLOCK_SIZE);
  73                 srclen %= POLY1305_BLOCK_SIZE;
  74         }
  75
  76         if (unlikely(srclen)) {
  77                 dctx->buflen = srclen;
  78                 memcpy(dctx->buf, src, srclen);
  79         }
  80
  81         return 0;
  82 }
  83 EXPORT_SYMBOL_GPL(crypto_poly1305_update);
  84
  85 int crypto_poly1305_final(struct shash_desc *desc, u8 *dst)
  86 {
  87         struct poly1305_desc_ctx *dctx = shash_desc_ctx(desc);
  88
  89         if (unlikely(!dctx->sset))
  90                 return -ENOKEY;
  91
  92         poly1305_final_generic(dctx, dst);
  93         return 0;
  94 }
  95 EXPORT_SYMBOL_GPL(crypto_poly1305_final);
  96
  97 static struct shash_alg poly1305_alg = {
  98         .digestsize     = POLY1305_DIGEST_SIZE,
  99         .init           = crypto_poly1305_init,
 100         .update         = crypto_poly1305_update,
 101         .final          = crypto_poly1305_final,
 102         .descsize       = sizeof(struct poly1305_desc_ctx),
 103         .base           = {
 104                 .cra_name               = "poly1305",
 105                 .cra_driver_name        = "poly1305-generic",
 106                 .cra_priority           = 100,
 107                 .cra_blocksize          = POLY1305_BLOCK_SIZE,
 108                 .cra_module             = THIS_MODULE,
 109         },
 110 };
 111
 112 static int __init poly1305_mod_init(void)
 113 {
 114         return crypto_register_shash(&poly1305_alg);
 115 }
 116
 117 static void __exit poly1305_mod_exit(void)
 118 {
 119         crypto_unregister_shash(&poly1305_alg);
 120 }
 121
 122 subsys_initcall(poly1305_mod_init);
 123 module_exit(poly1305_mod_exit);
 124
 125 MODULE_LICENSE("GPL");
 126 MODULE_AUTHOR("Martin Willi <martin@strongswan.org>");
 127 MODULE_DESCRIPTION("Poly1305 authenticator");
 128 MODULE_ALIAS_CRYPTO("poly1305");
 129 MODULE_ALIAS_CRYPTO("poly1305-generic");