Optimize buffer xoring.
[libgcrypt.git] / cipher / cipher-aeswrap.c
1 /* cipher-aeswrap.c  - Generic AESWRAP mode implementation
2  * Copyright (C) 2009, 2011 Free Software Foundation, Inc.
3  *
4  * This file is part of Libgcrypt.
5  *
6  * Libgcrypt is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU Lesser general Public License as
8  * published by the Free Software Foundation; either version 2.1 of
9  * the License, or (at your option) any later version.
10  *
11  * Libgcrypt is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <errno.h>
25
26 #include "g10lib.h"
27 #include "cipher.h"
28 #include "ath.h"
29 #include "bufhelp.h"
30 #include "./cipher-internal.h"
31
32
33 /* Perform the AES-Wrap algorithm as specified by RFC3394.  We
34    implement this as a mode usable with any cipher algorithm of
35    blocksize 128.  */
36 gcry_err_code_t
37 _gcry_cipher_aeswrap_encrypt (gcry_cipher_hd_t c,
38                               byte *outbuf, unsigned int outbuflen,
39                               const byte *inbuf, unsigned int inbuflen )
40 {
41   int j, x;
42   unsigned int n, i;
43   unsigned char *r, *a, *b;
44   unsigned char t[8];
45
46 #if MAX_BLOCKSIZE < 8
47 #error Invalid block size
48 #endif
49   /* We require a cipher with a 128 bit block length.  */
50   if (c->cipher->blocksize != 16)
51     return GPG_ERR_INV_LENGTH;
52
53   /* The output buffer must be able to hold the input data plus one
54      additional block.  */
55   if (outbuflen < inbuflen + 8)
56     return GPG_ERR_BUFFER_TOO_SHORT;
57   /* Input data must be multiple of 64 bits.  */
58   if (inbuflen % 8)
59     return GPG_ERR_INV_ARG;
60
61   n = inbuflen / 8;
62
63   /* We need at least two 64 bit blocks.  */
64   if (n < 2)
65     return GPG_ERR_INV_ARG;
66
67   r = outbuf;
68   a = outbuf;  /* We store A directly in OUTBUF.  */
69   b = c->u_ctr.ctr;  /* B is also used to concatenate stuff.  */
70
71   /* If an IV has been set we use that IV as the Alternative Initial
72      Value; if it has not been set we use the standard value.  */
73   if (c->marks.iv)
74     memcpy (a, c->u_iv.iv, 8);
75   else
76     memset (a, 0xa6, 8);
77
78   /* Copy the inbuf to the outbuf. */
79   memmove (r+8, inbuf, inbuflen);
80
81   memset (t, 0, sizeof t); /* t := 0.  */
82
83   for (j = 0; j <= 5; j++)
84     {
85       for (i = 1; i <= n; i++)
86         {
87           /* B := AES_k( A | R[i] ) */
88           memcpy (b, a, 8);
89           memcpy (b+8, r+i*8, 8);
90           c->cipher->encrypt (&c->context.c, b, b);
91           /* t := t + 1  */
92           for (x = 7; x >= 0; x--)
93             {
94               t[x]++;
95               if (t[x])
96                 break;
97             }
98           /* A := MSB_64(B) ^ t */
99           buf_xor(a, b, t, 8);
100           /* R[i] := LSB_64(B) */
101           memcpy (r+i*8, b+8, 8);
102         }
103    }
104
105   return 0;
106 }
107
108 /* Perform the AES-Unwrap algorithm as specified by RFC3394.  We
109    implement this as a mode usable with any cipher algorithm of
110    blocksize 128.  */
111 gcry_err_code_t
112 _gcry_cipher_aeswrap_decrypt (gcry_cipher_hd_t c,
113                               byte *outbuf, unsigned int outbuflen,
114                               const byte *inbuf, unsigned int inbuflen)
115 {
116   int j, x;
117   unsigned int n, i;
118   unsigned char *r, *a, *b;
119   unsigned char t[8];
120
121 #if MAX_BLOCKSIZE < 8
122 #error Invalid block size
123 #endif
124   /* We require a cipher with a 128 bit block length.  */
125   if (c->cipher->blocksize != 16)
126     return GPG_ERR_INV_LENGTH;
127
128   /* The output buffer must be able to hold the input data minus one
129      additional block.  Fixme: The caller has more restrictive checks
130      - we may want to fix them for this mode.  */
131   if (outbuflen + 8  < inbuflen)
132     return GPG_ERR_BUFFER_TOO_SHORT;
133   /* Input data must be multiple of 64 bits.  */
134   if (inbuflen % 8)
135     return GPG_ERR_INV_ARG;
136
137   n = inbuflen / 8;
138
139   /* We need at least three 64 bit blocks.  */
140   if (n < 3)
141     return GPG_ERR_INV_ARG;
142
143   r = outbuf;
144   a = c->lastiv;  /* We use c->LASTIV as buffer for A.  */
145   b = c->u_ctr.ctr;     /* B is also used to concatenate stuff.  */
146
147   /* Copy the inbuf to the outbuf and save A. */
148   memcpy (a, inbuf, 8);
149   memmove (r, inbuf+8, inbuflen-8);
150   n--; /* Reduce to actual number of data blocks.  */
151
152   /* t := 6 * n  */
153   i = n * 6;  /* The range is valid because: n = inbuflen / 8 - 1.  */
154   for (x=0; x < 8 && x < sizeof (i); x++)
155     t[7-x] = i >> (8*x);
156   for (; x < 8; x++)
157     t[7-x] = 0;
158
159   for (j = 5; j >= 0; j--)
160     {
161       for (i = n; i >= 1; i--)
162         {
163           /* B := AES_k^1( (A ^ t)| R[i] ) */
164           buf_xor(b, a, t, 8);
165           memcpy (b+8, r+(i-1)*8, 8);
166           c->cipher->decrypt (&c->context.c, b, b);
167           /* t := t - 1  */
168           for (x = 7; x >= 0; x--)
169             {
170               t[x]--;
171               if (t[x] != 0xff)
172                 break;
173             }
174           /* A := MSB_64(B) */
175           memcpy (a, b, 8);
176           /* R[i] := LSB_64(B) */
177           memcpy (r+(i-1)*8, b+8, 8);
178         }
179    }
180
181   /* If an IV has been set we compare against this Alternative Initial
182      Value; if it has not been set we compare against the standard IV.  */
183   if (c->marks.iv)
184     j = memcmp (a, c->u_iv.iv, 8);
185   else
186     {
187       for (j=0, x=0; x < 8; x++)
188         if (a[x] != 0xa6)
189           {
190             j=1;
191             break;
192           }
193     }
194   return j? GPG_ERR_CHECKSUM : 0;
195 }