Codebase list gost-crypto / 1e97193
New upstream version 0.3.2 Dmitry Eremin-Solenikov 4 years ago
5 changed file(s) with 24 addition(s) and 179 deletion(s). Raw diff Collapse all Expand all
+0
-9
README less more
0 This is a set of Linux kernel modules implementing GOST cryptographic algorithms:
1
2 - GOST 28147 cipher (RFC 5830)
3 - GOST 28147 "Imitovstavka" (MAC mode) (RFC 5830)
4 - GOST R 34.11-94 digest (RFC 5831)
5 - HMAC using GOST R 34.11-94 (RFC 4357)
6 - GOST R 34.12-2015 ciphers (Magma and Kuznyechik) (RFC 7801)
7 - CMAC using GOST R 34.12-2015 (as required by GOST R 34.13-2015)
8 - GOST R 34.11-2012 digest is provided from external source, developed by Vitaly Chikunov
+11
-0
README.md less more
0 This is a set of Linux kernel modules implementing GOST cryptographic algorithms:
1
2 - GOST 28147 cipher (RFC 5830)
3 - GOST 28147 "Imitovstavka" (MAC mode) (RFC 5830)
4 - GOST R 34.11-94 digest (RFC 5831)
5 - HMAC using GOST R 34.11-94 (RFC 4357)
6 - GOST R 34.12-2015 ciphers (Magma and Kuznyechik) (RFC 7801)
7 - CMAC using GOST R 34.12-2015 (as required by GOST R 34.13-2015)
8 - GOST R 34.11-2012 digest is provided from external source, developed by Vitaly Chikunov
9
10 [![Build Status](https://travis-ci.com/GostCrypt/linux-crypto.svg?branch=master)](https://travis-ci.com/GostCrypt/linux-crypto)
+4
-4
gost28147_modes.c less more
156156 do {
157157 gost28147_cfb_encrypt_one(ctx, iv, dst);
158158 crypto_xor(dst, src, bsize);
159 memcpy(iv, dst, bsize);
159 iv = dst;
160160
161161 src += bsize;
162162 dst += bsize;
163163 } while ((nbytes -= bsize) >= bsize);
164
165 memcpy(walk->iv, iv, bsize);
164166
165167 return nbytes;
166168 }
271273 const unsigned int bsize = GOST28147_BLOCK_SIZE;
272274 unsigned int nbytes = walk->nbytes;
273275 u8 *src = walk->src.virt.addr;
274 u8 *iv = walk->iv;
276 u8 *const iv = walk->iv;
275277 u8 tmp[GOST28147_BLOCK_SIZE];
276278
277279 do {
280282 crypto_xor(src, tmp, bsize);
281283 src += bsize;
282284 } while ((nbytes -= bsize) >= bsize);
283
284 memcpy(walk->iv, iv, bsize);
285285
286286 return nbytes;
287287 }
+0
-160
internal.h less more
0 /*
1 * Cryptographic API.
2 *
3 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
4 * Copyright (c) 2005 Herbert Xu <herbert@gondor.apana.org.au>
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the Free
8 * Software Foundation; either version 2 of the License, or (at your option)
9 * any later version.
10 *
11 */
12 #ifndef _CRYPTO_INTERNAL_H
13 #define _CRYPTO_INTERNAL_H
14
15 #include <crypto/algapi.h>
16 #include <linux/completion.h>
17 #include <linux/mm.h>
18 #include <linux/highmem.h>
19 #include <linux/interrupt.h>
20 #include <linux/init.h>
21 #include <linux/list.h>
22 #include <linux/module.h>
23 #include <linux/kernel.h>
24 #include <linux/notifier.h>
25 #include <linux/rwsem.h>
26 #include <linux/slab.h>
27
28 /* Crypto notification events. */
29 enum {
30 CRYPTO_MSG_ALG_REQUEST,
31 CRYPTO_MSG_ALG_REGISTER,
32 };
33
34 struct crypto_instance;
35 struct crypto_template;
36
37 struct crypto_larval {
38 struct crypto_alg alg;
39 struct crypto_alg *adult;
40 struct completion completion;
41 u32 mask;
42 };
43
44 extern struct list_head crypto_alg_list;
45 extern struct rw_semaphore crypto_alg_sem;
46 extern struct blocking_notifier_head crypto_chain;
47
48 #ifdef CONFIG_PROC_FS
49 void __init crypto_init_proc(void);
50 void __exit crypto_exit_proc(void);
51 #else
52 static inline void crypto_init_proc(void)
53 { }
54 static inline void crypto_exit_proc(void)
55 { }
56 #endif
57
58 static inline unsigned int crypto_cipher_ctxsize(struct crypto_alg *alg)
59 {
60 return alg->cra_ctxsize;
61 }
62
63 static inline unsigned int crypto_compress_ctxsize(struct crypto_alg *alg)
64 {
65 return alg->cra_ctxsize;
66 }
67
68 struct crypto_alg *crypto_mod_get(struct crypto_alg *alg);
69 struct crypto_alg *crypto_alg_mod_lookup(const char *name, u32 type, u32 mask);
70
71 int crypto_init_cipher_ops(struct crypto_tfm *tfm);
72 int crypto_init_compress_ops(struct crypto_tfm *tfm);
73
74 struct crypto_larval *crypto_larval_alloc(const char *name, u32 type, u32 mask);
75 void crypto_larval_kill(struct crypto_alg *alg);
76 void crypto_alg_tested(const char *name, int err);
77
78 void crypto_remove_spawns(struct crypto_alg *alg, struct list_head *list,
79 struct crypto_alg *nalg);
80 void crypto_remove_final(struct list_head *list);
81 void crypto_shoot_alg(struct crypto_alg *alg);
82 struct crypto_tfm *__crypto_alloc_tfm(struct crypto_alg *alg, u32 type,
83 u32 mask);
84 void *crypto_create_tfm(struct crypto_alg *alg,
85 const struct crypto_type *frontend);
86 struct crypto_alg *crypto_find_alg(const char *alg_name,
87 const struct crypto_type *frontend,
88 u32 type, u32 mask);
89 void *crypto_alloc_tfm(const char *alg_name,
90 const struct crypto_type *frontend, u32 type, u32 mask);
91
92 int crypto_register_notifier(struct notifier_block *nb);
93 int crypto_unregister_notifier(struct notifier_block *nb);
94 int crypto_probing_notify(unsigned long val, void *v);
95
96 unsigned int crypto_alg_extsize(struct crypto_alg *alg);
97
98 int crypto_type_has_alg(const char *name, const struct crypto_type *frontend,
99 u32 type, u32 mask);
100
101 #include <linux/version.h>
102 #if LINUX_VERSION_CODE < KERNEL_VERSION(4, 16, 0)
103 static inline struct crypto_alg *crypto_alg_get(struct crypto_alg *alg)
104 {
105 atomic_inc(&alg->cra_refcnt);
106 return alg;
107 }
108
109 static inline void crypto_alg_put(struct crypto_alg *alg)
110 {
111 if (atomic_dec_and_test(&alg->cra_refcnt) && alg->cra_destroy)
112 alg->cra_destroy(alg);
113 }
114 #else
115 static inline struct crypto_alg *crypto_alg_get(struct crypto_alg *alg)
116 {
117 refcount_inc(&alg->cra_refcnt);
118 return alg;
119 }
120
121 static inline void crypto_alg_put(struct crypto_alg *alg)
122 {
123 if (refcount_dec_and_test(&alg->cra_refcnt) && alg->cra_destroy)
124 alg->cra_destroy(alg);
125 }
126 #endif
127
128 static inline int crypto_tmpl_get(struct crypto_template *tmpl)
129 {
130 return try_module_get(tmpl->module);
131 }
132
133 static inline void crypto_tmpl_put(struct crypto_template *tmpl)
134 {
135 module_put(tmpl->module);
136 }
137
138 static inline int crypto_is_larval(struct crypto_alg *alg)
139 {
140 return alg->cra_flags & CRYPTO_ALG_LARVAL;
141 }
142
143 static inline int crypto_is_dead(struct crypto_alg *alg)
144 {
145 return alg->cra_flags & CRYPTO_ALG_DEAD;
146 }
147
148 static inline int crypto_is_moribund(struct crypto_alg *alg)
149 {
150 return alg->cra_flags & (CRYPTO_ALG_DEAD | CRYPTO_ALG_DYING);
151 }
152
153 static inline void crypto_notify(unsigned long val, void *v)
154 {
155 blocking_notifier_call_chain(&crypto_chain, val, v);
156 }
157
158 #endif /* _CRYPTO_INTERNAL_H */
159
+9
-6
testmgr.c less more
2727 #include <linux/scatterlist.h>
2828 #include <linux/slab.h>
2929 #include <linux/string.h>
30 #include <linux/version.h>
3031 #if 0
3132 #include <crypto/aead.h>
3233 #include <crypto/akcipher.h>
3334 #include <crypto/kpp.h>
3435 #endif
3536
36 #include "internal.h"
37 #if LINUX_VERSION_CODE < KERNEL_VERSION(5, 1, 0)
38 #define CRYPTO_TFM_REQ_FORBID_WEAK_KEYS CRYPTO_TFM_REQ_WEAK_KEY
39 #endif
3740
3841 static bool notests;
3942 module_param(notests, bool, 0644);
669672
670673 crypto_aead_clear_flags(tfm, ~0);
671674 if (template[i].wk)
672 crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
675 crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS);
673676
674677 if (template[i].klen > MAX_KEYLEN) {
675678 pr_err("gost-alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n",
770773
771774 crypto_aead_clear_flags(tfm, ~0);
772775 if (template[i].wk)
773 crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
776 crypto_aead_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS);
774777 if (template[i].klen > MAX_KEYLEN) {
775778 pr_err("gost-alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n",
776779 d, j, algo, template[i].klen, MAX_KEYLEN);
10311034
10321035 crypto_cipher_clear_flags(tfm, ~0);
10331036 if (template[i].wk)
1034 crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_WEAK_KEY);
1037 crypto_cipher_set_flags(tfm, CRYPTO_TFM_REQ_FORBID_WEAK_KEYS);
10351038
10361039 ret = crypto_cipher_setkey(tfm, template[i].key,
10371040 template[i].klen);
11481151 crypto_skcipher_clear_flags(tfm, ~0);
11491152 if (template[i].wk)
11501153 crypto_skcipher_set_flags(tfm,
1151 CRYPTO_TFM_REQ_WEAK_KEY);
1154 CRYPTO_TFM_REQ_FORBID_WEAK_KEYS);
11521155
11531156 ret = crypto_skcipher_setkey(tfm, template[i].key,
11541157 template[i].klen);
12191222 crypto_skcipher_clear_flags(tfm, ~0);
12201223 if (template[i].wk)
12211224 crypto_skcipher_set_flags(tfm,
1222 CRYPTO_TFM_REQ_WEAK_KEY);
1225 CRYPTO_TFM_REQ_FORBID_WEAK_KEYS);
12231226
12241227 ret = crypto_skcipher_setkey(tfm, template[i].key,
12251228 template[i].klen);