Coverage Report

Created: 2024-11-21 07:03

/src/boringssl/crypto/cipher_extra/e_des.c
Line
Count
Source (jump to first uncovered line)
1
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
2
 * All rights reserved.
3
 *
4
 * This package is an SSL implementation written
5
 * by Eric Young (eay@cryptsoft.com).
6
 * The implementation was written so as to conform with Netscapes SSL.
7
 *
8
 * This library is free for commercial and non-commercial use as long as
9
 * the following conditions are aheared to.  The following conditions
10
 * apply to all code found in this distribution, be it the RC4, RSA,
11
 * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
12
 * included with this distribution is covered by the same copyright terms
13
 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
14
 *
15
 * Copyright remains Eric Young's, and as such any Copyright notices in
16
 * the code are not to be removed.
17
 * If this package is used in a product, Eric Young should be given attribution
18
 * as the author of the parts of the library used.
19
 * This can be in the form of a textual message at program startup or
20
 * in documentation (online or textual) provided with the package.
21
 *
22
 * Redistribution and use in source and binary forms, with or without
23
 * modification, are permitted provided that the following conditions
24
 * are met:
25
 * 1. Redistributions of source code must retain the copyright
26
 *    notice, this list of conditions and the following disclaimer.
27
 * 2. Redistributions in binary form must reproduce the above copyright
28
 *    notice, this list of conditions and the following disclaimer in the
29
 *    documentation and/or other materials provided with the distribution.
30
 * 3. All advertising materials mentioning features or use of this software
31
 *    must display the following acknowledgement:
32
 *    "This product includes cryptographic software written by
33
 *     Eric Young (eay@cryptsoft.com)"
34
 *    The word 'cryptographic' can be left out if the rouines from the library
35
 *    being used are not cryptographic related :-).
36
 * 4. If you include any Windows specific code (or a derivative thereof) from
37
 *    the apps directory (application code) you must include an acknowledgement:
38
 *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
39
 *
40
 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
41
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
43
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
44
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
45
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
46
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
48
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
49
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
50
 * SUCH DAMAGE.
51
 *
52
 * The licence and distribution terms for any publically available version or
53
 * derivative of this code cannot be changed.  i.e. this code cannot simply be
54
 * copied and put under another distribution licence
55
 * [including the GNU Public Licence.] */
56
57
#include <openssl/cipher.h>
58
#include <openssl/des.h>
59
#include <openssl/nid.h>
60
61
#include "../des/internal.h"
62
#include "../fipsmodule/cipher/internal.h"
63
#include "internal.h"
64
65
66
typedef struct {
67
  union {
68
    double align;
69
    DES_key_schedule ks;
70
  } ks;
71
} EVP_DES_KEY;
72
73
static int des_init_key(EVP_CIPHER_CTX *ctx, const uint8_t *key,
74
1
                        const uint8_t *iv, int enc) {
75
1
  EVP_DES_KEY *dat = (EVP_DES_KEY *)ctx->cipher_data;
76
1
  DES_set_key_ex(key, &dat->ks.ks);
77
1
  return 1;
78
1
}
79
80
static int des_cbc_cipher(EVP_CIPHER_CTX *ctx, uint8_t *out, const uint8_t *in,
81
2
                          size_t in_len) {
82
2
  EVP_DES_KEY *dat = (EVP_DES_KEY *)ctx->cipher_data;
83
2
  DES_ncbc_encrypt_ex(in, out, in_len, &dat->ks.ks, ctx->iv, ctx->encrypt);
84
2
  return 1;
85
2
}
86
87
static const EVP_CIPHER evp_des_cbc = {
88
    .nid = NID_des_cbc,
89
    .block_size = 8,
90
    .key_len = 8,
91
    .iv_len = 8,
92
    .ctx_size = sizeof(EVP_DES_KEY),
93
    .flags = EVP_CIPH_CBC_MODE,
94
    .init = des_init_key,
95
    .cipher = des_cbc_cipher,
96
};
97
98
69
const EVP_CIPHER *EVP_des_cbc(void) { return &evp_des_cbc; }
99
100
static int des_ecb_cipher(EVP_CIPHER_CTX *ctx, uint8_t *out, const uint8_t *in,
101
0
                          size_t in_len) {
102
0
  if (in_len < ctx->cipher->block_size) {
103
0
    return 1;
104
0
  }
105
0
  in_len -= ctx->cipher->block_size;
106
107
0
  EVP_DES_KEY *dat = (EVP_DES_KEY *)ctx->cipher_data;
108
0
  for (size_t i = 0; i <= in_len; i += ctx->cipher->block_size) {
109
0
    DES_ecb_encrypt_ex(in + i, out + i, &dat->ks.ks, ctx->encrypt);
110
0
  }
111
0
  return 1;
112
0
}
113
114
static const EVP_CIPHER evp_des_ecb = {
115
    .nid = NID_des_ecb,
116
    .block_size = 8,
117
    .key_len = 8,
118
    .iv_len = 0,
119
    .ctx_size = sizeof(EVP_DES_KEY),
120
    .flags = EVP_CIPH_ECB_MODE,
121
    .init = des_init_key,
122
    .cipher = des_ecb_cipher,
123
};
124
125
10
const EVP_CIPHER *EVP_des_ecb(void) { return &evp_des_ecb; }
126
127
typedef struct {
128
  union {
129
    double align;
130
    DES_key_schedule ks[3];
131
  } ks;
132
} DES_EDE_KEY;
133
134
static int des_ede3_init_key(EVP_CIPHER_CTX *ctx, const uint8_t *key,
135
16
                             const uint8_t *iv, int enc) {
136
16
  DES_EDE_KEY *dat = (DES_EDE_KEY *)ctx->cipher_data;
137
16
  DES_set_key_ex(key, &dat->ks.ks[0]);
138
16
  DES_set_key_ex(key + 8, &dat->ks.ks[1]);
139
16
  DES_set_key_ex(key + 16, &dat->ks.ks[2]);
140
16
  return 1;
141
16
}
142
143
static int des_ede3_cbc_cipher(EVP_CIPHER_CTX *ctx, uint8_t *out,
144
2.14k
                               const uint8_t *in, size_t in_len) {
145
2.14k
  DES_EDE_KEY *dat = (DES_EDE_KEY *)ctx->cipher_data;
146
2.14k
  DES_ede3_cbc_encrypt_ex(in, out, in_len, &dat->ks.ks[0], &dat->ks.ks[1],
147
2.14k
                          &dat->ks.ks[2], ctx->iv, ctx->encrypt);
148
2.14k
  return 1;
149
2.14k
}
150
151
static const EVP_CIPHER evp_des_ede3_cbc = {
152
    .nid = NID_des_ede3_cbc,
153
    .block_size = 8,
154
    .key_len = 24,
155
    .iv_len = 8,
156
    .ctx_size = sizeof(DES_EDE_KEY),
157
    .flags = EVP_CIPH_CBC_MODE,
158
    .init = des_ede3_init_key,
159
    .cipher = des_ede3_cbc_cipher,
160
};
161
162
105
const EVP_CIPHER *EVP_des_ede3_cbc(void) { return &evp_des_ede3_cbc; }
163
164
static int des_ede_init_key(EVP_CIPHER_CTX *ctx, const uint8_t *key,
165
94
                            const uint8_t *iv, int enc) {
166
94
  DES_EDE_KEY *dat = (DES_EDE_KEY *)ctx->cipher_data;
167
  // 2-DES is 3-DES with the first key used twice.
168
94
  DES_set_key_ex(key, &dat->ks.ks[0]);
169
94
  DES_set_key_ex(key + 8, &dat->ks.ks[1]);
170
94
  DES_set_key_ex(key, &dat->ks.ks[2]);
171
94
  return 1;
172
94
}
173
174
static const EVP_CIPHER evp_des_ede_cbc = {
175
    .nid = NID_des_ede_cbc,
176
    .block_size = 8,
177
    .key_len = 16,
178
    .iv_len = 8,
179
    .ctx_size = sizeof(DES_EDE_KEY),
180
    .flags = EVP_CIPH_CBC_MODE,
181
    .init = des_ede_init_key,
182
    .cipher = des_ede3_cbc_cipher,
183
};
184
185
203
const EVP_CIPHER *EVP_des_ede_cbc(void) { return &evp_des_ede_cbc; }
186
187
static int des_ede_ecb_cipher(EVP_CIPHER_CTX *ctx, uint8_t *out,
188
0
                              const uint8_t *in, size_t in_len) {
189
0
  if (in_len < ctx->cipher->block_size) {
190
0
    return 1;
191
0
  }
192
0
  in_len -= ctx->cipher->block_size;
193
194
0
  DES_EDE_KEY *dat = (DES_EDE_KEY *) ctx->cipher_data;
195
0
  for (size_t i = 0; i <= in_len; i += ctx->cipher->block_size) {
196
0
    DES_ecb3_encrypt_ex(in + i, out + i, &dat->ks.ks[0], &dat->ks.ks[1],
197
0
                        &dat->ks.ks[2], ctx->encrypt);
198
0
  }
199
0
  return 1;
200
0
}
201
202
static const EVP_CIPHER evp_des_ede = {
203
    .nid = NID_des_ede_ecb,
204
    .block_size = 8,
205
    .key_len = 16,
206
    .iv_len = 0,
207
    .ctx_size = sizeof(DES_EDE_KEY),
208
    .flags = EVP_CIPH_ECB_MODE,
209
    .init = des_ede_init_key,
210
    .cipher = des_ede_ecb_cipher,
211
};
212
213
18
const EVP_CIPHER *EVP_des_ede(void) { return &evp_des_ede; }
214
215
static const EVP_CIPHER evp_des_ede3 = {
216
    .nid = NID_des_ede3_ecb,
217
    .block_size = 8,
218
    .key_len = 24,
219
    .iv_len = 0,
220
    .ctx_size = sizeof(DES_EDE_KEY),
221
    .flags = EVP_CIPH_ECB_MODE,
222
    .init = des_ede3_init_key,
223
    .cipher = des_ede_ecb_cipher,
224
};
225
226
21
const EVP_CIPHER *EVP_des_ede3(void) { return &evp_des_ede3; }
227
228
0
const EVP_CIPHER *EVP_des_ede3_ecb(void) { return EVP_des_ede3(); }