/linux-4.1.27/crypto/ |
H A D | aead.c | 82 static unsigned int crypto_aead_ctxsize(struct crypto_alg *alg, u32 type, crypto_aead_ctxsize() argument 85 return alg->cra_ctxsize; crypto_aead_ctxsize() 95 struct aead_alg *alg = &tfm->__crt_alg->cra_aead; crypto_init_aead_ops() local 98 if (max(alg->maxauthsize, alg->ivsize) > PAGE_SIZE / 8) crypto_init_aead_ops() 102 alg->setkey : setkey; crypto_init_aead_ops() 103 crt->encrypt = alg->encrypt; crypto_init_aead_ops() 104 crt->decrypt = alg->decrypt; crypto_init_aead_ops() 105 crt->givencrypt = alg->givencrypt ?: no_givcrypt; crypto_init_aead_ops() 106 crt->givdecrypt = alg->givdecrypt ?: no_givcrypt; crypto_init_aead_ops() 108 crt->ivsize = alg->ivsize; crypto_init_aead_ops() 109 crt->authsize = alg->maxauthsize; crypto_init_aead_ops() 115 static int crypto_aead_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_aead_report() argument 118 struct aead_alg *aead = &alg->cra_aead; crypto_aead_report() 123 raead.blocksize = alg->cra_blocksize; crypto_aead_report() 136 static int crypto_aead_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_aead_report() argument 142 static void crypto_aead_show(struct seq_file *m, struct crypto_alg *alg) 144 static void crypto_aead_show(struct seq_file *m, struct crypto_alg *alg) crypto_aead_show() argument 146 struct aead_alg *aead = &alg->cra_aead; crypto_aead_show() 149 seq_printf(m, "async : %s\n", alg->cra_flags & CRYPTO_ALG_ASYNC ? crypto_aead_show() 151 seq_printf(m, "blocksize : %u\n", alg->cra_blocksize); crypto_aead_show() 179 struct aead_alg *alg = &tfm->__crt_alg->cra_aead; crypto_init_nivaead_ops() local 182 if (max(alg->maxauthsize, alg->ivsize) > PAGE_SIZE / 8) crypto_init_nivaead_ops() 186 crt->encrypt = alg->encrypt; crypto_init_nivaead_ops() 187 crt->decrypt = alg->decrypt; crypto_init_nivaead_ops() 188 if (!alg->ivsize) { crypto_init_nivaead_ops() 193 crt->ivsize = alg->ivsize; crypto_init_nivaead_ops() 194 crt->authsize = alg->maxauthsize; crypto_init_nivaead_ops() 200 static int crypto_nivaead_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_nivaead_report() argument 203 struct aead_alg *aead = &alg->cra_aead; crypto_nivaead_report() 208 raead.blocksize = alg->cra_blocksize; crypto_nivaead_report() 221 static int crypto_nivaead_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_nivaead_report() argument 228 static void crypto_nivaead_show(struct seq_file *m, struct crypto_alg *alg) 230 static void crypto_nivaead_show(struct seq_file *m, struct crypto_alg *alg) crypto_nivaead_show() argument 232 struct aead_alg *aead = &alg->cra_aead; crypto_nivaead_show() 235 seq_printf(m, "async : %s\n", alg->cra_flags & CRYPTO_ALG_ASYNC ? crypto_nivaead_show() 237 seq_printf(m, "blocksize : %u\n", alg->cra_blocksize); crypto_nivaead_show() 256 struct crypto_alg *alg; crypto_grab_nivaead() local 263 alg = crypto_alg_mod_lookup(name, type, mask); crypto_grab_nivaead() 264 if (IS_ERR(alg)) crypto_grab_nivaead() 265 return PTR_ERR(alg); crypto_grab_nivaead() 267 err = crypto_init_spawn(&spawn->base, alg, spawn->base.inst, mask); crypto_grab_nivaead() 268 crypto_mod_put(alg); crypto_grab_nivaead() 280 struct crypto_alg *alg; aead_geniv_alloc() local 309 alg = crypto_aead_spawn_alg(spawn); aead_geniv_alloc() 312 if (!alg->cra_aead.ivsize) aead_geniv_alloc() 321 if (strcmp(tmpl->name, alg->cra_aead.geniv)) aead_geniv_alloc() 324 memcpy(inst->alg.cra_name, alg->cra_name, CRYPTO_MAX_ALG_NAME); aead_geniv_alloc() 325 memcpy(inst->alg.cra_driver_name, alg->cra_driver_name, aead_geniv_alloc() 329 if (snprintf(inst->alg.cra_name, CRYPTO_MAX_ALG_NAME, aead_geniv_alloc() 330 "%s(%s)", tmpl->name, alg->cra_name) >= aead_geniv_alloc() 333 if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, aead_geniv_alloc() 334 "%s(%s)", tmpl->name, alg->cra_driver_name) >= aead_geniv_alloc() 339 inst->alg.cra_flags = CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_GENIV; aead_geniv_alloc() 340 inst->alg.cra_flags |= alg->cra_flags & CRYPTO_ALG_ASYNC; aead_geniv_alloc() 341 inst->alg.cra_priority = alg->cra_priority; aead_geniv_alloc() 342 inst->alg.cra_blocksize = alg->cra_blocksize; aead_geniv_alloc() 343 inst->alg.cra_alignmask = alg->cra_alignmask; aead_geniv_alloc() 344 inst->alg.cra_type = &crypto_aead_type; aead_geniv_alloc() 346 inst->alg.cra_aead.ivsize = alg->cra_aead.ivsize; aead_geniv_alloc() 347 inst->alg.cra_aead.maxauthsize = alg->cra_aead.maxauthsize; aead_geniv_alloc() 348 inst->alg.cra_aead.geniv = alg->cra_aead.geniv; aead_geniv_alloc() 350 inst->alg.cra_aead.setkey = alg->cra_aead.setkey; aead_geniv_alloc() 351 inst->alg.cra_aead.setauthsize = alg->cra_aead.setauthsize; aead_geniv_alloc() 352 inst->alg.cra_aead.encrypt = alg->cra_aead.encrypt; aead_geniv_alloc() 353 inst->alg.cra_aead.decrypt = alg->cra_aead.decrypt; aead_geniv_alloc() 396 static int crypto_nivaead_default(struct crypto_alg *alg, u32 type, u32 mask) crypto_nivaead_default() argument 413 larval = crypto_larval_lookup(alg->cra_driver_name, crypto_nivaead_default() 434 memcpy(palg.data.name, alg->cra_driver_name, CRYPTO_MAX_ALG_NAME); crypto_nivaead_default() 439 geniv = alg->cra_aead.geniv; crypto_nivaead_default() 467 crypto_mod_put(alg); crypto_nivaead_default() 473 struct crypto_alg *alg; crypto_lookup_aead() local 475 alg = crypto_alg_mod_lookup(name, type, mask); crypto_lookup_aead() 476 if (IS_ERR(alg)) crypto_lookup_aead() 477 return alg; crypto_lookup_aead() 479 if (alg->cra_type == &crypto_aead_type) crypto_lookup_aead() 480 return alg; crypto_lookup_aead() 482 if (!alg->cra_aead.ivsize) crypto_lookup_aead() 483 return alg; crypto_lookup_aead() 485 crypto_mod_put(alg); crypto_lookup_aead() 486 alg = crypto_alg_mod_lookup(name, type | CRYPTO_ALG_TESTED, crypto_lookup_aead() 488 if (IS_ERR(alg)) crypto_lookup_aead() 489 return alg; crypto_lookup_aead() 491 if (alg->cra_type == &crypto_aead_type) { crypto_lookup_aead() 492 if ((alg->cra_flags ^ type ^ ~mask) & CRYPTO_ALG_TESTED) { crypto_lookup_aead() 493 crypto_mod_put(alg); crypto_lookup_aead() 494 alg = ERR_PTR(-ENOENT); crypto_lookup_aead() 496 return alg; crypto_lookup_aead() 499 BUG_ON(!alg->cra_aead.ivsize); crypto_lookup_aead() 501 return ERR_PTR(crypto_nivaead_default(alg, type, mask)); crypto_lookup_aead() 508 struct crypto_alg *alg; crypto_grab_aead() local 516 alg = crypto_lookup_aead(name, type, mask); crypto_grab_aead() 517 if (IS_ERR(alg)) crypto_grab_aead() 518 return PTR_ERR(alg); crypto_grab_aead() 520 err = crypto_init_spawn(&spawn->base, alg, spawn->base.inst, mask); crypto_grab_aead() 521 crypto_mod_put(alg); crypto_grab_aead() 537 struct crypto_alg *alg; crypto_alloc_aead() local 539 alg = crypto_lookup_aead(alg_name, type, mask); crypto_alloc_aead() 540 if (IS_ERR(alg)) { crypto_alloc_aead() 541 err = PTR_ERR(alg); crypto_alloc_aead() 545 tfm = __crypto_alloc_tfm(alg, type, mask); crypto_alloc_aead() 549 crypto_mod_put(alg); crypto_alloc_aead()
|
H A D | api.c | 37 static struct crypto_alg *crypto_larval_wait(struct crypto_alg *alg); 39 struct crypto_alg *crypto_mod_get(struct crypto_alg *alg) crypto_mod_get() argument 41 return try_module_get(alg->cra_module) ? crypto_alg_get(alg) : NULL; crypto_mod_get() 45 void crypto_mod_put(struct crypto_alg *alg) crypto_mod_put() argument 47 struct module *module = alg->cra_module; crypto_mod_put() 49 crypto_alg_put(alg); crypto_mod_put() 56 return larval->alg.cra_driver_name[0]; crypto_is_test_larval() 62 struct crypto_alg *q, *alg = NULL; __crypto_alg_lookup() local 88 if (alg) __crypto_alg_lookup() 89 crypto_mod_put(alg); __crypto_alg_lookup() 90 alg = q; __crypto_alg_lookup() 96 return alg; __crypto_alg_lookup() 99 static void crypto_larval_destroy(struct crypto_alg *alg) crypto_larval_destroy() argument 101 struct crypto_larval *larval = (void *)alg; crypto_larval_destroy() 103 BUG_ON(!crypto_is_larval(alg)); crypto_larval_destroy() 118 larval->alg.cra_flags = CRYPTO_ALG_LARVAL | type; crypto_larval_alloc() 119 larval->alg.cra_priority = -1; crypto_larval_alloc() 120 larval->alg.cra_destroy = crypto_larval_destroy; crypto_larval_alloc() 122 strlcpy(larval->alg.cra_name, name, CRYPTO_MAX_ALG_NAME); crypto_larval_alloc() 132 struct crypto_alg *alg; crypto_larval_add() local 139 atomic_set(&larval->alg.cra_refcnt, 2); crypto_larval_add() 142 alg = __crypto_alg_lookup(name, type, mask); crypto_larval_add() 143 if (!alg) { crypto_larval_add() 144 alg = &larval->alg; crypto_larval_add() 145 list_add(&alg->cra_list, &crypto_alg_list); crypto_larval_add() 149 if (alg != &larval->alg) { crypto_larval_add() 151 if (crypto_is_larval(alg)) crypto_larval_add() 152 alg = crypto_larval_wait(alg); crypto_larval_add() 155 return alg; crypto_larval_add() 158 void crypto_larval_kill(struct crypto_alg *alg) crypto_larval_kill() argument 160 struct crypto_larval *larval = (void *)alg; crypto_larval_kill() 163 list_del(&alg->cra_list); crypto_larval_kill() 166 crypto_alg_put(alg); crypto_larval_kill() 170 static struct crypto_alg *crypto_larval_wait(struct crypto_alg *alg) crypto_larval_wait() argument 172 struct crypto_larval *larval = (void *)alg; crypto_larval_wait() 178 alg = larval->adult; crypto_larval_wait() 180 alg = ERR_PTR(-EINTR); crypto_larval_wait() 182 alg = ERR_PTR(-ETIMEDOUT); crypto_larval_wait() 183 else if (!alg) crypto_larval_wait() 184 alg = ERR_PTR(-ENOENT); crypto_larval_wait() 186 !(alg->cra_flags & CRYPTO_ALG_TESTED)) crypto_larval_wait() 187 alg = ERR_PTR(-EAGAIN); crypto_larval_wait() 188 else if (!crypto_mod_get(alg)) crypto_larval_wait() 189 alg = ERR_PTR(-EAGAIN); crypto_larval_wait() 190 crypto_mod_put(&larval->alg); crypto_larval_wait() 192 return alg; crypto_larval_wait() 197 struct crypto_alg *alg; crypto_alg_lookup() local 200 alg = __crypto_alg_lookup(name, type, mask); crypto_alg_lookup() 203 return alg; crypto_alg_lookup() 209 struct crypto_alg *alg; crypto_larval_lookup() local 217 alg = crypto_alg_lookup(name, type, mask); crypto_larval_lookup() 218 if (!alg) { crypto_larval_lookup() 225 alg = crypto_alg_lookup(name, type, mask); crypto_larval_lookup() 228 if (alg) crypto_larval_lookup() 229 return crypto_is_larval(alg) ? crypto_larval_wait(alg) : alg; crypto_larval_lookup() 251 struct crypto_alg *alg; crypto_alg_mod_lookup() local 277 alg = crypto_larval_wait(larval); crypto_alg_mod_lookup() 280 alg = ERR_PTR(-ENOENT); crypto_alg_mod_lookup() 283 return alg; crypto_alg_mod_lookup() 333 static unsigned int crypto_ctxsize(struct crypto_alg *alg, u32 type, u32 mask) crypto_ctxsize() argument 335 const struct crypto_type *type_obj = alg->cra_type; crypto_ctxsize() 338 len = alg->cra_alignmask & ~(crypto_tfm_ctx_alignment() - 1); crypto_ctxsize() 340 return len + type_obj->ctxsize(alg, type, mask); crypto_ctxsize() 342 switch (alg->cra_flags & CRYPTO_ALG_TYPE_MASK) { crypto_ctxsize() 347 len += crypto_cipher_ctxsize(alg); crypto_ctxsize() 351 len += crypto_compress_ctxsize(alg); crypto_ctxsize() 358 void crypto_shoot_alg(struct crypto_alg *alg) crypto_shoot_alg() argument 361 alg->cra_flags |= CRYPTO_ALG_DYING; crypto_shoot_alg() 366 struct crypto_tfm *__crypto_alloc_tfm(struct crypto_alg *alg, u32 type, __crypto_alloc_tfm() argument 373 tfm_size = sizeof(*tfm) + crypto_ctxsize(alg, type, mask); __crypto_alloc_tfm() 378 tfm->__crt_alg = alg; __crypto_alloc_tfm() 384 if (!tfm->exit && alg->cra_init && (err = alg->cra_init(tfm))) __crypto_alloc_tfm() 393 crypto_shoot_alg(alg); __crypto_alloc_tfm() 430 struct crypto_alg *alg; crypto_alloc_base() local 432 alg = crypto_alg_mod_lookup(alg_name, type, mask); crypto_alloc_base() 433 if (IS_ERR(alg)) { crypto_alloc_base() 434 err = PTR_ERR(alg); crypto_alloc_base() 438 tfm = __crypto_alloc_tfm(alg, type, mask); crypto_alloc_base() 442 crypto_mod_put(alg); crypto_alloc_base() 458 void *crypto_create_tfm(struct crypto_alg *alg, crypto_create_tfm() argument 468 total = tfmsize + sizeof(*tfm) + frontend->extsize(alg); crypto_create_tfm() 475 tfm->__crt_alg = alg; crypto_create_tfm() 481 if (!tfm->exit && alg->cra_init && (err = alg->cra_init(tfm))) crypto_create_tfm() 490 crypto_shoot_alg(alg); crypto_create_tfm() 547 struct crypto_alg *alg; crypto_alloc_tfm() local 549 alg = crypto_find_alg(alg_name, frontend, type, mask); crypto_alloc_tfm() 550 if (IS_ERR(alg)) { crypto_alloc_tfm() 551 err = PTR_ERR(alg); crypto_alloc_tfm() 555 tfm = crypto_create_tfm(alg, frontend); crypto_alloc_tfm() 559 crypto_mod_put(alg); crypto_alloc_tfm() 585 struct crypto_alg *alg; crypto_destroy_tfm() local 590 alg = tfm->__crt_alg; crypto_destroy_tfm() 592 if (!tfm->exit && alg->cra_exit) crypto_destroy_tfm() 593 alg->cra_exit(tfm); crypto_destroy_tfm() 595 crypto_mod_put(alg); crypto_destroy_tfm() 603 struct crypto_alg *alg = crypto_alg_mod_lookup(name, type, mask); crypto_has_alg() local 605 if (!IS_ERR(alg)) { crypto_has_alg() 606 crypto_mod_put(alg); crypto_has_alg()
|
H A D | internal.h | 43 struct crypto_alg alg; member in struct:crypto_larval 63 static inline unsigned int crypto_cipher_ctxsize(struct crypto_alg *alg) crypto_cipher_ctxsize() argument 65 return alg->cra_ctxsize; crypto_cipher_ctxsize() 68 static inline unsigned int crypto_compress_ctxsize(struct crypto_alg *alg) crypto_compress_ctxsize() argument 70 return alg->cra_ctxsize; crypto_compress_ctxsize() 73 struct crypto_alg *crypto_mod_get(struct crypto_alg *alg); 84 void crypto_larval_kill(struct crypto_alg *alg); 88 void crypto_remove_spawns(struct crypto_alg *alg, struct list_head *list, 91 void crypto_shoot_alg(struct crypto_alg *alg); 92 struct crypto_tfm *__crypto_alloc_tfm(struct crypto_alg *alg, u32 type, 94 void *crypto_create_tfm(struct crypto_alg *alg, 106 static inline struct crypto_alg *crypto_alg_get(struct crypto_alg *alg) crypto_alg_get() argument 108 atomic_inc(&alg->cra_refcnt); crypto_alg_get() 109 return alg; crypto_alg_get() 112 static inline void crypto_alg_put(struct crypto_alg *alg) crypto_alg_put() argument 114 if (atomic_dec_and_test(&alg->cra_refcnt) && alg->cra_destroy) crypto_alg_put() 115 alg->cra_destroy(alg); crypto_alg_put() 128 static inline int crypto_is_larval(struct crypto_alg *alg) crypto_is_larval() argument 130 return alg->cra_flags & CRYPTO_ALG_LARVAL; crypto_is_larval() 133 static inline int crypto_is_dead(struct crypto_alg *alg) crypto_is_dead() argument 135 return alg->cra_flags & CRYPTO_ALG_DEAD; crypto_is_dead() 138 static inline int crypto_is_moribund(struct crypto_alg *alg) crypto_is_moribund() argument 140 return alg->cra_flags & (CRYPTO_ALG_DEAD | CRYPTO_ALG_DYING); crypto_is_moribund()
|
H A D | algapi.c | 27 static inline int crypto_set_driver_name(struct crypto_alg *alg) crypto_set_driver_name() argument 30 char *driver_name = alg->cra_driver_name; crypto_set_driver_name() 36 len = strlcpy(driver_name, alg->cra_name, CRYPTO_MAX_ALG_NAME); crypto_set_driver_name() 54 static int crypto_check_alg(struct crypto_alg *alg) crypto_check_alg() argument 56 crypto_check_module_sig(alg->cra_module); crypto_check_alg() 58 if (alg->cra_alignmask & (alg->cra_alignmask + 1)) crypto_check_alg() 61 if (alg->cra_blocksize > PAGE_SIZE / 8) crypto_check_alg() 64 if (alg->cra_priority < 0) crypto_check_alg() 67 atomic_set(&alg->cra_refcnt, 1); crypto_check_alg() 69 return crypto_set_driver_name(alg); crypto_check_alg() 72 static void crypto_destroy_instance(struct crypto_alg *alg) crypto_destroy_instance() argument 74 struct crypto_instance *inst = (void *)alg; crypto_destroy_instance() 81 static struct list_head *crypto_more_spawns(struct crypto_alg *alg, crypto_more_spawns() argument 94 if (spawn->alg && &n->list != stack && !n->alg) crypto_more_spawns() 95 n->alg = (n->list.next == stack) ? alg : crypto_more_spawns() 97 list)->inst->alg; crypto_more_spawns() 101 return &n->list == stack ? top : &n->inst->alg.cra_users; crypto_more_spawns() 109 if (crypto_is_dead(&inst->alg)) crypto_remove_instance() 112 inst->alg.cra_flags |= CRYPTO_ALG_DEAD; crypto_remove_instance() 119 crypto_notify(CRYPTO_MSG_ALG_UNREGISTER, &inst->alg); crypto_remove_instance() 120 list_move(&inst->alg.cra_list, list); crypto_remove_instance() 122 inst->alg.cra_destroy = crypto_destroy_instance; crypto_remove_instance() 124 BUG_ON(!list_empty(&inst->alg.cra_users)); crypto_remove_instance() 127 void crypto_remove_spawns(struct crypto_alg *alg, struct list_head *list, crypto_remove_spawns() argument 130 u32 new_type = (nalg ?: alg)->cra_flags; crypto_remove_spawns() 137 spawns = &alg->cra_users; list_for_each_entry_safe() 139 if ((spawn->alg->cra_flags ^ new_type) & spawn->mask) list_for_each_entry_safe() 154 BUG_ON(&inst->alg == alg); 158 if (&inst->alg == nalg) 161 spawn->alg = NULL; 162 spawns = &inst->alg.cra_users; 164 } while ((spawns = crypto_more_spawns(alg, &stack, &top, 168 if (spawn->alg) 169 list_move(&spawn->list, &spawn->alg->cra_users); 176 static struct crypto_larval *__crypto_register_alg(struct crypto_alg *alg) __crypto_register_alg() argument 182 if (crypto_is_dead(alg)) __crypto_register_alg() 185 INIT_LIST_HEAD(&alg->cra_users); __crypto_register_alg() 188 alg->cra_flags &= ~CRYPTO_ALG_TESTED; __crypto_register_alg() 193 if (q == alg) __crypto_register_alg() 200 if (!strcmp(alg->cra_driver_name, q->cra_driver_name)) __crypto_register_alg() 205 if (!strcmp(q->cra_driver_name, alg->cra_name) || __crypto_register_alg() 206 !strcmp(q->cra_name, alg->cra_driver_name)) __crypto_register_alg() 210 larval = crypto_larval_alloc(alg->cra_name, __crypto_register_alg() 211 alg->cra_flags | CRYPTO_ALG_TESTED, 0); __crypto_register_alg() 216 larval->adult = crypto_mod_get(alg); __crypto_register_alg() 220 atomic_set(&larval->alg.cra_refcnt, 1); __crypto_register_alg() 221 memcpy(larval->alg.cra_driver_name, alg->cra_driver_name, __crypto_register_alg() 223 larval->alg.cra_priority = alg->cra_priority; __crypto_register_alg() 225 list_add(&alg->cra_list, &crypto_alg_list); __crypto_register_alg() 226 list_add(&larval->alg.cra_list, &crypto_alg_list); __crypto_register_alg() 241 struct crypto_alg *alg; crypto_alg_tested() local 256 printk(KERN_ERR "alg: Unexpected test result for %s: %d\n", name, err); crypto_alg_tested() 261 alg = test->adult; crypto_alg_tested() 262 if (err || list_empty(&alg->cra_list)) crypto_alg_tested() 265 alg->cra_flags |= CRYPTO_ALG_TESTED; crypto_alg_tested() 268 if (q == alg) crypto_alg_tested() 282 if (strcmp(alg->cra_name, q->cra_name) && crypto_alg_tested() 283 strcmp(alg->cra_driver_name, q->cra_name)) crypto_alg_tested() 288 if ((q->cra_flags ^ alg->cra_flags) & larval->mask) crypto_alg_tested() 290 if (!crypto_mod_get(alg)) crypto_alg_tested() 293 larval->adult = alg; crypto_alg_tested() 297 if (strcmp(alg->cra_name, q->cra_name)) crypto_alg_tested() 300 if (strcmp(alg->cra_driver_name, q->cra_driver_name) && crypto_alg_tested() 301 q->cra_priority > alg->cra_priority) crypto_alg_tested() 304 crypto_remove_spawns(q, &list, alg); crypto_alg_tested() 319 struct crypto_alg *alg; crypto_remove_final() local 322 list_for_each_entry_safe(alg, n, list, cra_list) { list_for_each_entry_safe() 323 list_del_init(&alg->cra_list); list_for_each_entry_safe() 324 crypto_alg_put(alg); list_for_each_entry_safe() 337 crypto_alg_tested(larval->alg.cra_driver_name, 0); crypto_wait_for_test() 344 crypto_larval_kill(&larval->alg); crypto_wait_for_test() 347 int crypto_register_alg(struct crypto_alg *alg) crypto_register_alg() argument 352 err = crypto_check_alg(alg); crypto_register_alg() 357 larval = __crypto_register_alg(alg); crypto_register_alg() 368 static int crypto_remove_alg(struct crypto_alg *alg, struct list_head *list) crypto_remove_alg() argument 370 if (unlikely(list_empty(&alg->cra_list))) crypto_remove_alg() 373 alg->cra_flags |= CRYPTO_ALG_DEAD; crypto_remove_alg() 375 crypto_notify(CRYPTO_MSG_ALG_UNREGISTER, alg); crypto_remove_alg() 376 list_del_init(&alg->cra_list); crypto_remove_alg() 377 crypto_remove_spawns(alg, list, NULL); crypto_remove_alg() 382 int crypto_unregister_alg(struct crypto_alg *alg) crypto_unregister_alg() argument 388 ret = crypto_remove_alg(alg, &list); crypto_unregister_alg() 394 BUG_ON(atomic_read(&alg->cra_refcnt) != 1); crypto_unregister_alg() 395 if (alg->cra_destroy) crypto_unregister_alg() 396 alg->cra_destroy(alg); crypto_unregister_alg() 475 int err = crypto_remove_alg(&inst->alg, &users); hlist_for_each_entry() 485 BUG_ON(atomic_read(&inst->alg.cra_refcnt) != 1); hlist_for_each_entry_safe() 524 err = crypto_check_alg(&inst->alg); crypto_register_instance() 528 inst->alg.cra_module = tmpl->module; crypto_register_instance() 529 inst->alg.cra_flags |= CRYPTO_ALG_INSTANCE; crypto_register_instance() 531 if (unlikely(!crypto_mod_get(&inst->alg))) crypto_register_instance() 536 larval = __crypto_register_alg(&inst->alg); crypto_register_instance() 553 if (!(inst->alg.cra_flags & CRYPTO_ALG_TESTED)) crypto_register_instance() 558 crypto_mod_put(&inst->alg); crypto_register_instance() 569 crypto_remove_spawns(&inst->alg, &list, NULL); crypto_unregister_instance() 580 int crypto_init_spawn(struct crypto_spawn *spawn, struct crypto_alg *alg, crypto_init_spawn() argument 589 if (!crypto_is_moribund(alg)) { crypto_init_spawn() 590 list_add(&spawn->list, &alg->cra_users); crypto_init_spawn() 591 spawn->alg = alg; crypto_init_spawn() 600 int crypto_init_spawn2(struct crypto_spawn *spawn, struct crypto_alg *alg, crypto_init_spawn2() argument 606 if ((alg->cra_flags ^ frontend->type) & frontend->maskset) crypto_init_spawn2() 610 err = crypto_init_spawn(spawn, alg, inst, frontend->maskset); crypto_init_spawn2() 619 if (!spawn->alg) crypto_drop_spawn() 630 struct crypto_alg *alg; crypto_spawn_alg() local 634 alg = spawn->alg; crypto_spawn_alg() 635 alg2 = alg; crypto_spawn_alg() 641 if (alg) crypto_spawn_alg() 642 crypto_shoot_alg(alg); crypto_spawn_alg() 646 return alg; crypto_spawn_alg() 652 struct crypto_alg *alg; crypto_spawn_tfm() local 655 alg = crypto_spawn_alg(spawn); crypto_spawn_tfm() 656 if (IS_ERR(alg)) crypto_spawn_tfm() 657 return ERR_CAST(alg); crypto_spawn_tfm() 660 if (unlikely((alg->cra_flags ^ type) & mask)) crypto_spawn_tfm() 663 tfm = __crypto_alloc_tfm(alg, type, mask); crypto_spawn_tfm() 670 crypto_mod_put(alg); crypto_spawn_tfm() 677 struct crypto_alg *alg; crypto_spawn_tfm2() local 680 alg = crypto_spawn_alg(spawn); crypto_spawn_tfm2() 681 if (IS_ERR(alg)) crypto_spawn_tfm2() 682 return ERR_CAST(alg); crypto_spawn_tfm2() 684 tfm = crypto_create_tfm(alg, spawn->frontend); crypto_spawn_tfm2() 691 crypto_mod_put(alg); crypto_spawn_tfm2() 791 void *crypto_alloc_instance2(const char *name, struct crypto_alg *alg, crypto_alloc_instance2() argument 806 if (snprintf(inst->alg.cra_name, CRYPTO_MAX_ALG_NAME, "%s(%s)", name, crypto_alloc_instance2() 807 alg->cra_name) >= CRYPTO_MAX_ALG_NAME) crypto_alloc_instance2() 810 if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s(%s)", crypto_alloc_instance2() 811 name, alg->cra_driver_name) >= CRYPTO_MAX_ALG_NAME) crypto_alloc_instance2() 823 struct crypto_alg *alg) crypto_alloc_instance() 829 inst = crypto_alloc_instance2(name, alg, 0); crypto_alloc_instance() 834 err = crypto_init_spawn(spawn, alg, inst, crypto_alloc_instance() 822 crypto_alloc_instance(const char *name, struct crypto_alg *alg) crypto_alloc_instance() argument
|
H A D | crypto_user.c | 49 struct crypto_alg *q, *alg = NULL; crypto_alg_match() local 71 alg = q; crypto_alg_match() 77 return alg; crypto_alg_match() 80 static int crypto_report_cipher(struct sk_buff *skb, struct crypto_alg *alg) crypto_report_cipher() argument 86 rcipher.blocksize = alg->cra_blocksize; crypto_report_cipher() 87 rcipher.min_keysize = alg->cra_cipher.cia_min_keysize; crypto_report_cipher() 88 rcipher.max_keysize = alg->cra_cipher.cia_max_keysize; crypto_report_cipher() 99 static int crypto_report_comp(struct sk_buff *skb, struct crypto_alg *alg) crypto_report_comp() argument 113 static int crypto_report_one(struct crypto_alg *alg, crypto_report_one() argument 116 strncpy(ualg->cru_name, alg->cra_name, sizeof(ualg->cru_name)); crypto_report_one() 117 strncpy(ualg->cru_driver_name, alg->cra_driver_name, crypto_report_one() 119 strncpy(ualg->cru_module_name, module_name(alg->cra_module), crypto_report_one() 124 ualg->cru_flags = alg->cra_flags; crypto_report_one() 125 ualg->cru_refcnt = atomic_read(&alg->cra_refcnt); crypto_report_one() 127 if (nla_put_u32(skb, CRYPTOCFGA_PRIORITY_VAL, alg->cra_priority)) crypto_report_one() 129 if (alg->cra_flags & CRYPTO_ALG_LARVAL) { crypto_report_one() 139 if (alg->cra_type && alg->cra_type->report) { crypto_report_one() 140 if (alg->cra_type->report(skb, alg)) crypto_report_one() 146 switch (alg->cra_flags & (CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_LARVAL)) { crypto_report_one() 148 if (crypto_report_cipher(skb, alg)) crypto_report_one() 153 if (crypto_report_comp(skb, alg)) crypto_report_one() 166 static int crypto_report_alg(struct crypto_alg *alg, crypto_report_alg() argument 184 err = crypto_report_one(alg, ualg, skb); crypto_report_alg() 200 struct crypto_alg *alg; crypto_report() local 208 alg = crypto_alg_match(p, 0); crypto_report() 209 if (!alg) crypto_report() 222 err = crypto_report_alg(alg, &info); crypto_report() 225 crypto_mod_put(alg); crypto_report() 235 struct crypto_alg *alg; crypto_dump_report() local 249 list_for_each_entry(alg, &crypto_alg_list, cra_list) { crypto_dump_report() 250 err = crypto_report_alg(alg, &info); crypto_dump_report() 269 struct crypto_alg *alg; crypto_update_alg() local 283 alg = crypto_alg_match(p, 1); crypto_update_alg() 284 if (!alg) crypto_update_alg() 289 crypto_remove_spawns(alg, &list, NULL); crypto_update_alg() 292 alg->cra_priority = nla_get_u32(priority); crypto_update_alg() 296 crypto_mod_put(alg); crypto_update_alg() 305 struct crypto_alg *alg; crypto_del_alg() local 315 alg = crypto_alg_match(p, 1); crypto_del_alg() 316 if (!alg) crypto_del_alg() 325 if (!(alg->cra_flags & CRYPTO_ALG_INSTANCE)) crypto_del_alg() 329 if (atomic_read(&alg->cra_refcnt) > 2) crypto_del_alg() 332 err = crypto_unregister_instance((struct crypto_instance *)alg); crypto_del_alg() 335 crypto_mod_put(alg); crypto_del_alg() 343 struct crypto_alg *alg; crypto_user_skcipher_alg() local 349 alg = crypto_lookup_skcipher(name, type, mask); crypto_user_skcipher_alg() 350 if (!IS_ERR(alg)) crypto_user_skcipher_alg() 351 return alg; crypto_user_skcipher_alg() 353 err = PTR_ERR(alg); crypto_user_skcipher_alg() 369 struct crypto_alg *alg; crypto_user_aead_alg() local 377 alg = crypto_lookup_aead(name, type, mask); crypto_user_aead_alg() 378 if (!IS_ERR(alg)) crypto_user_aead_alg() 379 return alg; crypto_user_aead_alg() 381 err = PTR_ERR(alg); crypto_user_aead_alg() 398 struct crypto_alg *alg; crypto_add_alg() local 414 alg = crypto_alg_match(p, exact); crypto_add_alg() 415 if (alg) { crypto_add_alg() 416 crypto_mod_put(alg); crypto_add_alg() 427 alg = crypto_user_aead_alg(name, p->cru_type, p->cru_mask); crypto_add_alg() 432 alg = crypto_user_skcipher_alg(name, p->cru_type, p->cru_mask); crypto_add_alg() 435 alg = crypto_alg_mod_lookup(name, p->cru_type, p->cru_mask); crypto_add_alg() 438 if (IS_ERR(alg)) crypto_add_alg() 439 return PTR_ERR(alg); crypto_add_alg() 444 alg->cra_priority = nla_get_u32(priority); crypto_add_alg() 448 crypto_mod_put(alg); crypto_add_alg() 496 struct crypto_alg *alg; crypto_user_rcv_msg() local 503 list_for_each_entry(alg, &crypto_alg_list, cra_list) crypto_user_rcv_msg()
|
H A D | ablkcipher.c | 346 static unsigned int crypto_ablkcipher_ctxsize(struct crypto_alg *alg, u32 type, crypto_ablkcipher_ctxsize() argument 349 return alg->cra_ctxsize; crypto_ablkcipher_ctxsize() 365 struct ablkcipher_alg *alg = &tfm->__crt_alg->cra_ablkcipher; crypto_init_ablkcipher_ops() local 368 if (alg->ivsize > PAGE_SIZE / 8) crypto_init_ablkcipher_ops() 372 crt->encrypt = alg->encrypt; crypto_init_ablkcipher_ops() 373 crt->decrypt = alg->decrypt; crypto_init_ablkcipher_ops() 374 if (!alg->ivsize) { crypto_init_ablkcipher_ops() 379 crt->ivsize = alg->ivsize; crypto_init_ablkcipher_ops() 385 static int crypto_ablkcipher_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_ablkcipher_report() argument 390 strncpy(rblkcipher.geniv, alg->cra_ablkcipher.geniv ?: "<default>", crypto_ablkcipher_report() 393 rblkcipher.blocksize = alg->cra_blocksize; crypto_ablkcipher_report() 394 rblkcipher.min_keysize = alg->cra_ablkcipher.min_keysize; crypto_ablkcipher_report() 395 rblkcipher.max_keysize = alg->cra_ablkcipher.max_keysize; crypto_ablkcipher_report() 396 rblkcipher.ivsize = alg->cra_ablkcipher.ivsize; crypto_ablkcipher_report() 407 static int crypto_ablkcipher_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_ablkcipher_report() argument 413 static void crypto_ablkcipher_show(struct seq_file *m, struct crypto_alg *alg) 415 static void crypto_ablkcipher_show(struct seq_file *m, struct crypto_alg *alg) crypto_ablkcipher_show() argument 417 struct ablkcipher_alg *ablkcipher = &alg->cra_ablkcipher; crypto_ablkcipher_show() 420 seq_printf(m, "async : %s\n", alg->cra_flags & CRYPTO_ALG_ASYNC ? crypto_ablkcipher_show() 422 seq_printf(m, "blocksize : %u\n", alg->cra_blocksize); crypto_ablkcipher_show() 447 struct ablkcipher_alg *alg = &tfm->__crt_alg->cra_ablkcipher; crypto_init_givcipher_ops() local 450 if (alg->ivsize > PAGE_SIZE / 8) crypto_init_givcipher_ops() 454 alg->setkey : setkey; crypto_init_givcipher_ops() 455 crt->encrypt = alg->encrypt; crypto_init_givcipher_ops() 456 crt->decrypt = alg->decrypt; crypto_init_givcipher_ops() 457 crt->givencrypt = alg->givencrypt; crypto_init_givcipher_ops() 458 crt->givdecrypt = alg->givdecrypt ?: no_givdecrypt; crypto_init_givcipher_ops() 460 crt->ivsize = alg->ivsize; crypto_init_givcipher_ops() 466 static int crypto_givcipher_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_givcipher_report() argument 471 strncpy(rblkcipher.geniv, alg->cra_ablkcipher.geniv ?: "<built-in>", crypto_givcipher_report() 474 rblkcipher.blocksize = alg->cra_blocksize; crypto_givcipher_report() 475 rblkcipher.min_keysize = alg->cra_ablkcipher.min_keysize; crypto_givcipher_report() 476 rblkcipher.max_keysize = alg->cra_ablkcipher.max_keysize; crypto_givcipher_report() 477 rblkcipher.ivsize = alg->cra_ablkcipher.ivsize; crypto_givcipher_report() 488 static int crypto_givcipher_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_givcipher_report() argument 494 static void crypto_givcipher_show(struct seq_file *m, struct crypto_alg *alg) 496 static void crypto_givcipher_show(struct seq_file *m, struct crypto_alg *alg) crypto_givcipher_show() argument 498 struct ablkcipher_alg *ablkcipher = &alg->cra_ablkcipher; crypto_givcipher_show() 501 seq_printf(m, "async : %s\n", alg->cra_flags & CRYPTO_ALG_ASYNC ? crypto_givcipher_show() 503 seq_printf(m, "blocksize : %u\n", alg->cra_blocksize); crypto_givcipher_show() 520 const char *crypto_default_geniv(const struct crypto_alg *alg) crypto_default_geniv() argument 522 if (((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) == crypto_default_geniv() 523 CRYPTO_ALG_TYPE_BLKCIPHER ? alg->cra_blkcipher.ivsize : crypto_default_geniv() 524 alg->cra_ablkcipher.ivsize) != crypto_default_geniv() 525 alg->cra_blocksize) crypto_default_geniv() 531 static int crypto_givcipher_default(struct crypto_alg *alg, u32 type, u32 mask) crypto_givcipher_default() argument 548 larval = crypto_larval_lookup(alg->cra_driver_name, crypto_givcipher_default() 570 memcpy(palg.data.name, alg->cra_driver_name, CRYPTO_MAX_ALG_NAME); crypto_givcipher_default() 575 if ((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) == crypto_givcipher_default() 577 geniv = alg->cra_blkcipher.geniv; crypto_givcipher_default() 579 geniv = alg->cra_ablkcipher.geniv; crypto_givcipher_default() 582 geniv = crypto_default_geniv(alg); crypto_givcipher_default() 610 crypto_mod_put(alg); crypto_givcipher_default() 616 struct crypto_alg *alg; crypto_lookup_skcipher() local 618 alg = crypto_alg_mod_lookup(name, type, mask); crypto_lookup_skcipher() 619 if (IS_ERR(alg)) crypto_lookup_skcipher() 620 return alg; crypto_lookup_skcipher() 622 if ((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) == crypto_lookup_skcipher() 624 return alg; crypto_lookup_skcipher() 626 if (!((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) == crypto_lookup_skcipher() 627 CRYPTO_ALG_TYPE_BLKCIPHER ? alg->cra_blkcipher.ivsize : crypto_lookup_skcipher() 628 alg->cra_ablkcipher.ivsize)) crypto_lookup_skcipher() 629 return alg; crypto_lookup_skcipher() 631 crypto_mod_put(alg); crypto_lookup_skcipher() 632 alg = crypto_alg_mod_lookup(name, type | CRYPTO_ALG_TESTED, crypto_lookup_skcipher() 634 if (IS_ERR(alg)) crypto_lookup_skcipher() 635 return alg; crypto_lookup_skcipher() 637 if ((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) == crypto_lookup_skcipher() 639 if ((alg->cra_flags ^ type ^ ~mask) & CRYPTO_ALG_TESTED) { crypto_lookup_skcipher() 640 crypto_mod_put(alg); crypto_lookup_skcipher() 641 alg = ERR_PTR(-ENOENT); crypto_lookup_skcipher() 643 return alg; crypto_lookup_skcipher() 646 BUG_ON(!((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) == crypto_lookup_skcipher() 647 CRYPTO_ALG_TYPE_BLKCIPHER ? alg->cra_blkcipher.ivsize : crypto_lookup_skcipher() 648 alg->cra_ablkcipher.ivsize)); crypto_lookup_skcipher() 650 return ERR_PTR(crypto_givcipher_default(alg, type, mask)); crypto_lookup_skcipher() 657 struct crypto_alg *alg; crypto_grab_skcipher() local 663 alg = crypto_lookup_skcipher(name, type, mask); crypto_grab_skcipher() 664 if (IS_ERR(alg)) crypto_grab_skcipher() 665 return PTR_ERR(alg); crypto_grab_skcipher() 667 err = crypto_init_spawn(&spawn->base, alg, spawn->base.inst, mask); crypto_grab_skcipher() 668 crypto_mod_put(alg); crypto_grab_skcipher() 683 struct crypto_alg *alg; crypto_alloc_ablkcipher() local 685 alg = crypto_lookup_skcipher(alg_name, type, mask); crypto_alloc_ablkcipher() 686 if (IS_ERR(alg)) { crypto_alloc_ablkcipher() 687 err = PTR_ERR(alg); crypto_alloc_ablkcipher() 691 tfm = __crypto_alloc_tfm(alg, type, mask); crypto_alloc_ablkcipher() 695 crypto_mod_put(alg); crypto_alloc_ablkcipher()
|
H A D | ctr.c | 184 struct crypto_alg *alg; crypto_ctr_alloc() local 191 alg = crypto_attr_alg(tb[1], CRYPTO_ALG_TYPE_CIPHER, crypto_ctr_alloc() 193 if (IS_ERR(alg)) crypto_ctr_alloc() 194 return ERR_CAST(alg); crypto_ctr_alloc() 198 if (alg->cra_blocksize < 4) crypto_ctr_alloc() 202 if (alg->cra_blocksize % 4) crypto_ctr_alloc() 205 inst = crypto_alloc_instance("ctr", alg); crypto_ctr_alloc() 209 inst->alg.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER; crypto_ctr_alloc() 210 inst->alg.cra_priority = alg->cra_priority; crypto_ctr_alloc() 211 inst->alg.cra_blocksize = 1; crypto_ctr_alloc() 212 inst->alg.cra_alignmask = alg->cra_alignmask | (__alignof__(u32) - 1); crypto_ctr_alloc() 213 inst->alg.cra_type = &crypto_blkcipher_type; crypto_ctr_alloc() 215 inst->alg.cra_blkcipher.ivsize = alg->cra_blocksize; crypto_ctr_alloc() 216 inst->alg.cra_blkcipher.min_keysize = alg->cra_cipher.cia_min_keysize; crypto_ctr_alloc() 217 inst->alg.cra_blkcipher.max_keysize = alg->cra_cipher.cia_max_keysize; crypto_ctr_alloc() 219 inst->alg.cra_ctxsize = sizeof(struct crypto_ctr_ctx); crypto_ctr_alloc() 221 inst->alg.cra_init = crypto_ctr_init_tfm; crypto_ctr_alloc() 222 inst->alg.cra_exit = crypto_ctr_exit_tfm; crypto_ctr_alloc() 224 inst->alg.cra_blkcipher.setkey = crypto_ctr_setkey; crypto_ctr_alloc() 225 inst->alg.cra_blkcipher.encrypt = crypto_ctr_crypt; crypto_ctr_alloc() 226 inst->alg.cra_blkcipher.decrypt = crypto_ctr_crypt; crypto_ctr_alloc() 228 inst->alg.cra_blkcipher.geniv = "chainiv"; crypto_ctr_alloc() 231 crypto_mod_put(alg); crypto_ctr_alloc() 340 struct crypto_alg *alg; crypto_rfc3686_alloc() local 369 alg = crypto_skcipher_spawn_alg(spawn); crypto_rfc3686_alloc() 373 if (alg->cra_ablkcipher.ivsize != CTR_RFC3686_BLOCK_SIZE) crypto_rfc3686_alloc() 377 if (alg->cra_blocksize != 1) crypto_rfc3686_alloc() 381 if (snprintf(inst->alg.cra_name, CRYPTO_MAX_ALG_NAME, "rfc3686(%s)", crypto_rfc3686_alloc() 382 alg->cra_name) >= CRYPTO_MAX_ALG_NAME) crypto_rfc3686_alloc() 384 if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, crypto_rfc3686_alloc() 385 "rfc3686(%s)", alg->cra_driver_name) >= crypto_rfc3686_alloc() 389 inst->alg.cra_priority = alg->cra_priority; crypto_rfc3686_alloc() 390 inst->alg.cra_blocksize = 1; crypto_rfc3686_alloc() 391 inst->alg.cra_alignmask = alg->cra_alignmask; crypto_rfc3686_alloc() 393 inst->alg.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | crypto_rfc3686_alloc() 394 (alg->cra_flags & CRYPTO_ALG_ASYNC); crypto_rfc3686_alloc() 395 inst->alg.cra_type = &crypto_ablkcipher_type; crypto_rfc3686_alloc() 397 inst->alg.cra_ablkcipher.ivsize = CTR_RFC3686_IV_SIZE; crypto_rfc3686_alloc() 398 inst->alg.cra_ablkcipher.min_keysize = crypto_rfc3686_alloc() 399 alg->cra_ablkcipher.min_keysize + CTR_RFC3686_NONCE_SIZE; crypto_rfc3686_alloc() 400 inst->alg.cra_ablkcipher.max_keysize = crypto_rfc3686_alloc() 401 alg->cra_ablkcipher.max_keysize + CTR_RFC3686_NONCE_SIZE; crypto_rfc3686_alloc() 403 inst->alg.cra_ablkcipher.geniv = "seqiv"; crypto_rfc3686_alloc() 405 inst->alg.cra_ablkcipher.setkey = crypto_rfc3686_setkey; crypto_rfc3686_alloc() 406 inst->alg.cra_ablkcipher.encrypt = crypto_rfc3686_crypt; crypto_rfc3686_alloc() 407 inst->alg.cra_ablkcipher.decrypt = crypto_rfc3686_crypt; crypto_rfc3686_alloc() 409 inst->alg.cra_ctxsize = sizeof(struct crypto_rfc3686_ctx); crypto_rfc3686_alloc() 411 inst->alg.cra_init = crypto_rfc3686_init_tfm; crypto_rfc3686_alloc() 412 inst->alg.cra_exit = crypto_rfc3686_exit_tfm; crypto_rfc3686_alloc()
|
H A D | proc.c | 82 struct crypto_alg *alg = list_entry(p, struct crypto_alg, cra_list); c_show() local 84 seq_printf(m, "name : %s\n", alg->cra_name); c_show() 85 seq_printf(m, "driver : %s\n", alg->cra_driver_name); c_show() 86 seq_printf(m, "module : %s\n", module_name(alg->cra_module)); c_show() 87 seq_printf(m, "priority : %d\n", alg->cra_priority); c_show() 88 seq_printf(m, "refcnt : %d\n", atomic_read(&alg->cra_refcnt)); c_show() 90 (alg->cra_flags & CRYPTO_ALG_TESTED) ? c_show() 93 (alg->cra_flags & CRYPTO_ALG_INTERNAL) ? c_show() 96 if (alg->cra_flags & CRYPTO_ALG_LARVAL) { c_show() 98 seq_printf(m, "flags : 0x%x\n", alg->cra_flags); c_show() 102 if (alg->cra_type && alg->cra_type->show) { c_show() 103 alg->cra_type->show(m, alg); c_show() 107 switch (alg->cra_flags & (CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_LARVAL)) { c_show() 110 seq_printf(m, "blocksize : %u\n", alg->cra_blocksize); c_show() 112 alg->cra_cipher.cia_min_keysize); c_show() 114 alg->cra_cipher.cia_max_keysize); c_show()
|
H A D | testmgr.c | 37 int alg_test(const char *driver, const char *alg, u32 type, u32 mask) alg_test() argument 118 const char *alg; member in struct:alg_test_desc 121 int fips_allowed; /* set if alg is allowed in fips mode */ 219 printk(KERN_ERR "alg: hash: Failed to allocate request for " __test_hash() 247 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n", __test_hash() 255 printk(KERN_ERR "alg: hash: setkey failed on " __test_hash() 266 pr_err("alg: hash: digest failed on test %d " __test_hash() 293 printk(KERN_ERR "alg: hash: Test %d failed for %s\n", __test_hash() 331 pr_err("alg: hash: setkey failed on test %d for %s: key size %d > %d\n", __test_hash() 341 printk(KERN_ERR "alg: hash: setkey " __test_hash() 362 printk(KERN_ERR "alg: hash: digest failed " __test_hash() 370 printk(KERN_ERR "alg: hash: Chunking test %d " __test_hash() 475 pr_err("alg: aead%s: Failed to allocate request for %s\n", __test_aead() 514 pr_err("alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n", __test_aead() 524 pr_err("alg: aead%s: setkey failed on test %d for %s: flags=%x\n", __test_aead() 533 pr_err("alg: aead%s: Failed to set authsize to %u on test %d for %s\n", __test_aead() 562 pr_err("alg: aead%s: %s failed on test %d for %s: ret was 0, expected -EBADMSG\n", __test_aead() 582 pr_err("alg: aead%s: %s failed on test %d for %s: ret=%d\n", __test_aead() 589 pr_err("alg: aead%s: Test %d failed on %s for %s\n", __test_aead() 616 pr_err("alg: aead%s: setkey failed on test %d for %s: key size %d > %d\n", __test_aead() 625 pr_err("alg: aead%s: setkey failed on chunk test %d for %s: flags=%x\n", __test_aead() 666 pr_err("alg: aead%s: Failed to set authsize to %u on chunk test %d for %s\n", __test_aead() 712 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret was 0, expected -EBADMSG\n", __test_aead() 732 pr_err("alg: aead%s: %s failed on chunk test %d for %s: ret=%d\n", __test_aead() 751 pr_err("alg: aead%s: Chunk test %d failed on %s at page %u for %s\n", __test_aead() 770 pr_err("alg: aead%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n", __test_aead() 871 printk(KERN_ERR "alg: cipher: setkey failed " test_cipher() 890 printk(KERN_ERR "alg: cipher: Test %d failed " test_cipher() 945 pr_err("alg: skcipher%s: Failed to allocate request for %s\n", __test_skcipher() 979 pr_err("alg: skcipher%s: setkey failed on test %d for %s: flags=%x\n", __test_skcipher() 1009 pr_err("alg: skcipher%s: %s failed on test %d for %s: ret=%d\n", __test_skcipher() 1016 pr_err("alg: skcipher%s: Test %d failed on %s for %s\n", __test_skcipher() 1046 pr_err("alg: skcipher%s: setkey failed on chunk test %d for %s: flags=%x\n", __test_skcipher() 1103 pr_err("alg: skcipher%s: %s failed on chunk test %d for %s: ret=%d\n", __test_skcipher() 1120 pr_err("alg: skcipher%s: Chunk test %d failed on %s at page %u for %s\n", __test_skcipher() 1130 pr_err("alg: skcipher%s: Result buffer corruption in chunk test %d on %s at page %u for %s: %u bytes:\n", __test_skcipher() 1202 printk(KERN_ERR "alg: comp: compression failed " test_comp() 1209 printk(KERN_ERR "alg: comp: Compression test %d " test_comp() 1217 printk(KERN_ERR "alg: comp: Compression test %d " test_comp() 1235 printk(KERN_ERR "alg: comp: decompression failed " test_comp() 1242 printk(KERN_ERR "alg: comp: Decompression test %d " test_comp() 1250 printk(KERN_ERR "alg: comp: Decompression test %d " test_comp() 1281 pr_err("alg: pcomp: compression setup failed on test " test_pcomp() 1288 pr_err("alg: pcomp: compression init failed on test " test_pcomp() 1302 pr_err("alg: pcomp: compression update failed on test " test_pcomp() 1314 pr_err("alg: pcomp: compression update failed on test " test_pcomp() 1326 pr_err("alg: pcomp: compression final failed on test " test_pcomp() 1333 pr_err("alg: comp: Compression test %d failed for %s: " test_pcomp() 1341 pr_err("alg: comp: Compression test %d failed for %s: " test_pcomp() 1348 pr_err("alg: pcomp: Compression test %d failed for " test_pcomp() 1362 pr_err("alg: pcomp: decompression setup failed on " test_pcomp() 1369 pr_err("alg: pcomp: decompression init failed on test " test_pcomp() 1383 pr_err("alg: pcomp: decompression update failed on " test_pcomp() 1395 pr_err("alg: pcomp: decompression update failed on " test_pcomp() 1407 pr_err("alg: pcomp: decompression final failed on " test_pcomp() 1415 pr_err("alg: comp: Decompression test %d failed for " test_pcomp() 1423 pr_err("alg: comp: Decompression test %d failed for " test_pcomp() 1430 pr_err("alg: pcomp: Decompression test %d failed for " test_pcomp() 1453 printk(KERN_ERR "alg: cprng: Failed to allocate seed space " test_cprng() 1469 printk(KERN_ERR "alg: cprng: Failed to reset rng " test_cprng() 1478 printk(KERN_ERR "alg: cprng: Failed to obtain " test_cprng() 1489 printk(KERN_ERR "alg: cprng: Test %d failed for %s\n", test_cprng() 1510 printk(KERN_ERR "alg: aead: Failed to load transform for %s: " alg_test_aead() 1539 printk(KERN_ERR "alg: cipher: Failed to load transform for " alg_test_cipher() 1568 printk(KERN_ERR "alg: skcipher: Failed to load transform for " alg_test_skcipher() 1597 printk(KERN_ERR "alg: comp: Failed to load transform for %s: " alg_test_comp() 1619 pr_err("alg: pcomp: Failed to load transform for %s: %ld\n", alg_test_pcomp() 1641 printk(KERN_ERR "alg: hash: Failed to load transform for %s: " alg_test_hash() 1669 printk(KERN_ERR "alg: crc32c: Failed to load transform for %s: " alg_test_crc32c() 1685 printk(KERN_ERR "alg: crc32c: Operation failed for " alg_test_crc32c() 1691 printk(KERN_ERR "alg: crc32c: Test failed for %s: " alg_test_crc32c() 1711 printk(KERN_ERR "alg: cprng: Failed to load transform for %s: " alg_test_cprng() 1738 printk(KERN_ERR "alg: drbg: could not allocate DRNG handle for " drbg_cavs_test() 1749 printk(KERN_ERR "alg: drbg: Failed to reset rng\n"); drbg_cavs_test() 1763 printk(KERN_ERR "alg: drbg: could not obtain random data for " drbg_cavs_test() 1778 printk(KERN_ERR "alg: drbg: could not obtain random data for " drbg_cavs_test() 1807 printk(KERN_ERR "alg: drbg: Test %d failed for %s\n", alg_test_drbg() 1826 .alg = "__cbc-cast5-avx", 1829 .alg = "__cbc-cast6-avx", 1832 .alg = "__cbc-serpent-avx", 1835 .alg = "__cbc-serpent-avx2", 1838 .alg = "__cbc-serpent-sse2", 1841 .alg = "__cbc-twofish-avx", 1844 .alg = "__driver-cbc-aes-aesni", 1848 .alg = "__driver-cbc-camellia-aesni", 1851 .alg = "__driver-cbc-camellia-aesni-avx2", 1854 .alg = "__driver-cbc-cast5-avx", 1857 .alg = "__driver-cbc-cast6-avx", 1860 .alg = "__driver-cbc-serpent-avx", 1863 .alg = "__driver-cbc-serpent-avx2", 1866 .alg = "__driver-cbc-serpent-sse2", 1869 .alg = "__driver-cbc-twofish-avx", 1872 .alg = "__driver-ecb-aes-aesni", 1876 .alg = "__driver-ecb-camellia-aesni", 1879 .alg = "__driver-ecb-camellia-aesni-avx2", 1882 .alg = "__driver-ecb-cast5-avx", 1885 .alg = "__driver-ecb-cast6-avx", 1888 .alg = "__driver-ecb-serpent-avx", 1891 .alg = "__driver-ecb-serpent-avx2", 1894 .alg = "__driver-ecb-serpent-sse2", 1897 .alg = "__driver-ecb-twofish-avx", 1900 .alg = "__ghash-pclmulqdqni", 1904 .alg = "ansi_cprng", 1914 .alg = "authenc(hmac(md5),ecb(cipher_null))", 1930 .alg = "authenc(hmac(sha1),cbc(aes))", 1944 .alg = "authenc(hmac(sha1),cbc(des))", 1958 .alg = "authenc(hmac(sha1),cbc(des3_ede))", 1972 .alg = "authenc(hmac(sha1),ecb(cipher_null))", 1992 .alg = "authenc(hmac(sha224),cbc(des))", 2006 .alg = "authenc(hmac(sha224),cbc(des3_ede))", 2020 .alg = "authenc(hmac(sha256),cbc(aes))", 2034 .alg = "authenc(hmac(sha256),cbc(des))", 2048 .alg = "authenc(hmac(sha256),cbc(des3_ede))", 2062 .alg = "authenc(hmac(sha384),cbc(des))", 2076 .alg = "authenc(hmac(sha384),cbc(des3_ede))", 2090 .alg = "authenc(hmac(sha512),cbc(aes))", 2104 .alg = "authenc(hmac(sha512),cbc(des))", 2118 .alg = "authenc(hmac(sha512),cbc(des3_ede))", 2132 .alg = "cbc(aes)", 2148 .alg = "cbc(anubis)", 2163 .alg = "cbc(blowfish)", 2178 .alg = "cbc(camellia)", 2193 .alg = "cbc(cast5)", 2208 .alg = "cbc(cast6)", 2223 .alg = "cbc(des)", 2238 .alg = "cbc(des3_ede)", 2254 .alg = "cbc(serpent)", 2269 .alg = "cbc(twofish)", 2284 .alg = "ccm(aes)", 2300 .alg = "cmac(aes)", 2309 .alg = "cmac(des3_ede)", 2318 .alg = "compress_null", 2321 .alg = "crc32c", 2331 .alg = "crct10dif", 2341 .alg = "cryptd(__driver-cbc-aes-aesni)", 2345 .alg = "cryptd(__driver-cbc-camellia-aesni)", 2348 .alg = "cryptd(__driver-cbc-camellia-aesni-avx2)", 2351 .alg = "cryptd(__driver-cbc-serpent-avx2)", 2354 .alg = "cryptd(__driver-ecb-aes-aesni)", 2358 .alg = "cryptd(__driver-ecb-camellia-aesni)", 2361 .alg = "cryptd(__driver-ecb-camellia-aesni-avx2)", 2364 .alg = "cryptd(__driver-ecb-cast5-avx)", 2367 .alg = "cryptd(__driver-ecb-cast6-avx)", 2370 .alg = "cryptd(__driver-ecb-serpent-avx)", 2373 .alg = "cryptd(__driver-ecb-serpent-avx2)", 2376 .alg = "cryptd(__driver-ecb-serpent-sse2)", 2379 .alg = "cryptd(__driver-ecb-twofish-avx)", 2382 .alg = "cryptd(__driver-gcm-aes-aesni)", 2386 .alg = "cryptd(__ghash-pclmulqdqni)", 2390 .alg = "ctr(aes)", 2406 .alg = "ctr(blowfish)", 2421 .alg = "ctr(camellia)", 2436 .alg = "ctr(cast5)", 2451 .alg = "ctr(cast6)", 2466 .alg = "ctr(des)", 2481 .alg = "ctr(des3_ede)", 2496 .alg = "ctr(serpent)", 2511 .alg = "ctr(twofish)", 2526 .alg = "cts(cbc(aes))", 2541 .alg = "deflate", 2557 .alg = "digest_null", 2560 .alg = "drbg_nopr_ctr_aes128", 2570 .alg = "drbg_nopr_ctr_aes192", 2580 .alg = "drbg_nopr_ctr_aes256", 2594 .alg = "drbg_nopr_hmac_sha1", 2598 .alg = "drbg_nopr_hmac_sha256", 2610 .alg = "drbg_nopr_hmac_sha384", 2614 .alg = "drbg_nopr_hmac_sha512", 2618 .alg = "drbg_nopr_sha1", 2622 .alg = "drbg_nopr_sha256", 2633 .alg = "drbg_nopr_sha384", 2637 .alg = "drbg_nopr_sha512", 2641 .alg = "drbg_pr_ctr_aes128", 2652 .alg = "drbg_pr_ctr_aes192", 2656 .alg = "drbg_pr_ctr_aes256", 2660 .alg = "drbg_pr_hmac_sha1", 2664 .alg = "drbg_pr_hmac_sha256", 2675 .alg = "drbg_pr_hmac_sha384", 2679 .alg = "drbg_pr_hmac_sha512", 2683 .alg = "drbg_pr_sha1", 2687 .alg = "drbg_pr_sha256", 2698 .alg = "drbg_pr_sha384", 2702 .alg = "drbg_pr_sha512", 2706 .alg = "ecb(__aes-aesni)", 2710 .alg = "ecb(aes)", 2726 .alg = "ecb(anubis)", 2741 .alg = "ecb(arc4)", 2756 .alg = "ecb(blowfish)", 2771 .alg = "ecb(camellia)", 2786 .alg = "ecb(cast5)", 2801 .alg = "ecb(cast6)", 2816 .alg = "ecb(cipher_null)", 2819 .alg = "ecb(des)", 2835 .alg = "ecb(des3_ede)", 2851 .alg = "ecb(fcrypt)", 2866 .alg = "ecb(khazad)", 2881 .alg = "ecb(seed)", 2896 .alg = "ecb(serpent)", 2911 .alg = "ecb(tea)", 2926 .alg = "ecb(tnepres)", 2941 .alg = "ecb(twofish)", 2956 .alg = "ecb(xeta)", 2971 .alg = "ecb(xtea)", 2986 .alg = "gcm(aes)", 3002 .alg = "ghash", 3012 .alg = "hmac(crc32)", 3021 .alg = "hmac(md5)", 3030 .alg = "hmac(rmd128)", 3039 .alg = "hmac(rmd160)", 3048 .alg = "hmac(sha1)", 3058 .alg = "hmac(sha224)", 3068 .alg = "hmac(sha256)", 3078 .alg = "hmac(sha384)", 3088 .alg = "hmac(sha512)", 3098 .alg = "lrw(aes)", 3113 .alg = "lrw(camellia)", 3128 .alg = "lrw(cast6)", 3143 .alg = "lrw(serpent)", 3158 .alg = "lrw(twofish)", 3173 .alg = "lz4", 3189 .alg = "lz4hc", 3205 .alg = "lzo", 3221 .alg = "md4", 3230 .alg = "md5", 3239 .alg = "michael_mic", 3248 .alg = "ofb(aes)", 3264 .alg = "pcbc(fcrypt)", 3279 .alg = "rfc3686(ctr(aes))", 3295 .alg = "rfc4106(gcm(aes))", 3311 .alg = "rfc4309(ccm(aes))", 3327 .alg = "rfc4543(gcm(aes))", 3342 .alg = "rmd128", 3351 .alg = "rmd160", 3360 .alg = "rmd256", 3369 .alg = "rmd320", 3378 .alg = "salsa20", 3389 .alg = "sha1", 3399 .alg = "sha224", 3409 .alg = "sha256", 3419 .alg = "sha384", 3429 .alg = "sha512", 3439 .alg = "tgr128", 3448 .alg = "tgr160", 3457 .alg = "tgr192", 3466 .alg = "vmac(aes)", 3475 .alg = "wp256", 3484 .alg = "wp384", 3493 .alg = "wp512", 3502 .alg = "xcbc(aes)", 3511 .alg = "xts(aes)", 3527 .alg = "xts(camellia)", 3542 .alg = "xts(cast6)", 3557 .alg = "xts(serpent)", 3572 .alg = "xts(twofish)", 3587 .alg = "zlib", 3618 int diff = strcmp(alg_test_descs[i - 1].alg, alg_test_descs_check_order() 3619 alg_test_descs[i].alg); alg_test_descs_check_order() 3623 alg_test_descs[i - 1].alg, alg_test_descs_check_order() 3624 alg_test_descs[i].alg); alg_test_descs_check_order() 3629 alg_test_descs[i].alg); alg_test_descs_check_order() 3634 static int alg_find_test(const char *alg) alg_find_test() argument 3641 int diff = strcmp(alg_test_descs[i].alg, alg); alg_find_test() 3659 int alg_test(const char *driver, const char *alg, u32 type, u32 mask) alg_test() argument 3670 if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >= alg_test() 3685 i = alg_find_test(alg); alg_test() 3704 panic("%s: %s alg self test failed in fips mode!\n", driver, alg); alg_test() 3707 pr_info("alg: self-tests for %s (%s) passed\n", driver, alg); alg_test() 3712 printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver); alg_test()
|
H A D | ecb.c | 121 struct crypto_alg *alg; crypto_ecb_alloc() local 128 alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER, crypto_ecb_alloc() 130 if (IS_ERR(alg)) crypto_ecb_alloc() 131 return ERR_CAST(alg); crypto_ecb_alloc() 133 inst = crypto_alloc_instance("ecb", alg); crypto_ecb_alloc() 137 inst->alg.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER; crypto_ecb_alloc() 138 inst->alg.cra_priority = alg->cra_priority; crypto_ecb_alloc() 139 inst->alg.cra_blocksize = alg->cra_blocksize; crypto_ecb_alloc() 140 inst->alg.cra_alignmask = alg->cra_alignmask; crypto_ecb_alloc() 141 inst->alg.cra_type = &crypto_blkcipher_type; crypto_ecb_alloc() 143 inst->alg.cra_blkcipher.min_keysize = alg->cra_cipher.cia_min_keysize; crypto_ecb_alloc() 144 inst->alg.cra_blkcipher.max_keysize = alg->cra_cipher.cia_max_keysize; crypto_ecb_alloc() 146 inst->alg.cra_ctxsize = sizeof(struct crypto_ecb_ctx); crypto_ecb_alloc() 148 inst->alg.cra_init = crypto_ecb_init_tfm; crypto_ecb_alloc() 149 inst->alg.cra_exit = crypto_ecb_exit_tfm; crypto_ecb_alloc() 151 inst->alg.cra_blkcipher.setkey = crypto_ecb_setkey; crypto_ecb_alloc() 152 inst->alg.cra_blkcipher.encrypt = crypto_ecb_encrypt; crypto_ecb_alloc() 153 inst->alg.cra_blkcipher.decrypt = crypto_ecb_decrypt; crypto_ecb_alloc() 156 crypto_mod_put(alg); crypto_ecb_alloc()
|
H A D | cryptd.c | 298 static void *cryptd_alloc_instance(struct crypto_alg *alg, unsigned int head, cryptd_alloc_instance() argument 312 if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, cryptd_alloc_instance() 313 "cryptd(%s)", alg->cra_driver_name) >= CRYPTO_MAX_ALG_NAME) cryptd_alloc_instance() 316 memcpy(inst->alg.cra_name, alg->cra_name, CRYPTO_MAX_ALG_NAME); cryptd_alloc_instance() 318 inst->alg.cra_priority = alg->cra_priority + 50; cryptd_alloc_instance() 319 inst->alg.cra_blocksize = alg->cra_blocksize; cryptd_alloc_instance() 320 inst->alg.cra_alignmask = alg->cra_alignmask; cryptd_alloc_instance() 337 struct crypto_alg *alg; cryptd_create_blkcipher() local 344 alg = crypto_get_attr_alg(tb, type, mask); cryptd_create_blkcipher() 345 if (IS_ERR(alg)) cryptd_create_blkcipher() 346 return PTR_ERR(alg); cryptd_create_blkcipher() 348 inst = cryptd_alloc_instance(alg, 0, sizeof(*ctx)); cryptd_create_blkcipher() 356 err = crypto_init_spawn(&ctx->spawn, alg, inst, cryptd_create_blkcipher() 362 if (alg->cra_flags & CRYPTO_ALG_INTERNAL) cryptd_create_blkcipher() 364 inst->alg.cra_flags = type; cryptd_create_blkcipher() 365 inst->alg.cra_type = &crypto_ablkcipher_type; cryptd_create_blkcipher() 367 inst->alg.cra_ablkcipher.ivsize = alg->cra_blkcipher.ivsize; cryptd_create_blkcipher() 368 inst->alg.cra_ablkcipher.min_keysize = alg->cra_blkcipher.min_keysize; cryptd_create_blkcipher() 369 inst->alg.cra_ablkcipher.max_keysize = alg->cra_blkcipher.max_keysize; cryptd_create_blkcipher() 371 inst->alg.cra_ablkcipher.geniv = alg->cra_blkcipher.geniv; cryptd_create_blkcipher() 373 inst->alg.cra_ctxsize = sizeof(struct cryptd_blkcipher_ctx); cryptd_create_blkcipher() 375 inst->alg.cra_init = cryptd_blkcipher_init_tfm; cryptd_create_blkcipher() 376 inst->alg.cra_exit = cryptd_blkcipher_exit_tfm; cryptd_create_blkcipher() 378 inst->alg.cra_ablkcipher.setkey = cryptd_blkcipher_setkey; cryptd_create_blkcipher() 379 inst->alg.cra_ablkcipher.encrypt = cryptd_blkcipher_encrypt_enqueue; cryptd_create_blkcipher() 380 inst->alg.cra_ablkcipher.decrypt = cryptd_blkcipher_decrypt_enqueue; cryptd_create_blkcipher() 390 crypto_mod_put(alg); cryptd_create_blkcipher() 599 struct crypto_alg *alg; cryptd_create_hash() local 610 alg = &salg->base; cryptd_create_hash() 611 inst = cryptd_alloc_instance(alg, ahash_instance_headroom(), cryptd_create_hash() 626 if (alg->cra_flags & CRYPTO_ALG_INTERNAL) cryptd_create_hash() 628 inst->alg.halg.base.cra_flags = type; cryptd_create_hash() 630 inst->alg.halg.digestsize = salg->digestsize; cryptd_create_hash() 631 inst->alg.halg.base.cra_ctxsize = sizeof(struct cryptd_hash_ctx); cryptd_create_hash() 633 inst->alg.halg.base.cra_init = cryptd_hash_init_tfm; cryptd_create_hash() 634 inst->alg.halg.base.cra_exit = cryptd_hash_exit_tfm; cryptd_create_hash() 636 inst->alg.init = cryptd_hash_init_enqueue; cryptd_create_hash() 637 inst->alg.update = cryptd_hash_update_enqueue; cryptd_create_hash() 638 inst->alg.final = cryptd_hash_final_enqueue; cryptd_create_hash() 639 inst->alg.finup = cryptd_hash_finup_enqueue; cryptd_create_hash() 640 inst->alg.export = cryptd_hash_export; cryptd_create_hash() 641 inst->alg.import = cryptd_hash_import; cryptd_create_hash() 642 inst->alg.setkey = cryptd_hash_setkey; cryptd_create_hash() 643 inst->alg.digest = cryptd_hash_digest_enqueue; cryptd_create_hash() 653 crypto_mod_put(alg); cryptd_create_hash() 748 struct crypto_alg *alg; cryptd_create_aead() local 755 alg = crypto_get_attr_alg(tb, type, mask); cryptd_create_aead() 756 if (IS_ERR(alg)) cryptd_create_aead() 757 return PTR_ERR(alg); cryptd_create_aead() 759 inst = cryptd_alloc_instance(alg, 0, sizeof(*ctx)); cryptd_create_aead() 767 err = crypto_init_spawn(&ctx->aead_spawn.base, alg, inst, cryptd_create_aead() 773 if (alg->cra_flags & CRYPTO_ALG_INTERNAL) cryptd_create_aead() 775 inst->alg.cra_flags = type; cryptd_create_aead() 776 inst->alg.cra_type = alg->cra_type; cryptd_create_aead() 777 inst->alg.cra_ctxsize = sizeof(struct cryptd_aead_ctx); cryptd_create_aead() 778 inst->alg.cra_init = cryptd_aead_init_tfm; cryptd_create_aead() 779 inst->alg.cra_exit = cryptd_aead_exit_tfm; cryptd_create_aead() 780 inst->alg.cra_aead.setkey = alg->cra_aead.setkey; cryptd_create_aead() 781 inst->alg.cra_aead.setauthsize = alg->cra_aead.setauthsize; cryptd_create_aead() 782 inst->alg.cra_aead.geniv = alg->cra_aead.geniv; cryptd_create_aead() 783 inst->alg.cra_aead.ivsize = alg->cra_aead.ivsize; cryptd_create_aead() 784 inst->alg.cra_aead.maxauthsize = alg->cra_aead.maxauthsize; cryptd_create_aead() 785 inst->alg.cra_aead.encrypt = cryptd_aead_encrypt_enqueue; cryptd_create_aead() 786 inst->alg.cra_aead.decrypt = cryptd_aead_decrypt_enqueue; cryptd_create_aead() 787 inst->alg.cra_aead.givencrypt = alg->cra_aead.givencrypt; cryptd_create_aead() 788 inst->alg.cra_aead.givdecrypt = alg->cra_aead.givdecrypt; cryptd_create_aead() 797 crypto_mod_put(alg); cryptd_create_aead() 829 switch (inst->alg.cra_flags & CRYPTO_ALG_TYPE_MASK) { cryptd_free()
|
H A D | lrw.c | 329 struct crypto_alg *alg; alloc() local 336 alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER, alloc() 338 if (IS_ERR(alg)) alloc() 339 return ERR_CAST(alg); alloc() 341 inst = crypto_alloc_instance("lrw", alg); alloc() 345 inst->alg.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER; alloc() 346 inst->alg.cra_priority = alg->cra_priority; alloc() 347 inst->alg.cra_blocksize = alg->cra_blocksize; alloc() 349 if (alg->cra_alignmask < 7) inst->alg.cra_alignmask = 7; alloc() 350 else inst->alg.cra_alignmask = alg->cra_alignmask; alloc() 351 inst->alg.cra_type = &crypto_blkcipher_type; alloc() 353 if (!(alg->cra_blocksize % 4)) alloc() 354 inst->alg.cra_alignmask |= 3; alloc() 355 inst->alg.cra_blkcipher.ivsize = alg->cra_blocksize; alloc() 356 inst->alg.cra_blkcipher.min_keysize = alloc() 357 alg->cra_cipher.cia_min_keysize + alg->cra_blocksize; alloc() 358 inst->alg.cra_blkcipher.max_keysize = alloc() 359 alg->cra_cipher.cia_max_keysize + alg->cra_blocksize; alloc() 361 inst->alg.cra_ctxsize = sizeof(struct priv); alloc() 363 inst->alg.cra_init = init_tfm; alloc() 364 inst->alg.cra_exit = exit_tfm; alloc() 366 inst->alg.cra_blkcipher.setkey = setkey; alloc() 367 inst->alg.cra_blkcipher.encrypt = encrypt; alloc() 368 inst->alg.cra_blkcipher.decrypt = decrypt; alloc() 371 crypto_mod_put(alg); alloc()
|
H A D | pcompress.c | 41 static unsigned int crypto_pcomp_extsize(struct crypto_alg *alg) crypto_pcomp_extsize() argument 43 return alg->cra_ctxsize; crypto_pcomp_extsize() 52 static int crypto_pcomp_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_pcomp_report() argument 66 static int crypto_pcomp_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_pcomp_report() argument 72 static void crypto_pcomp_show(struct seq_file *m, struct crypto_alg *alg) 74 static void crypto_pcomp_show(struct seq_file *m, struct crypto_alg *alg) crypto_pcomp_show() argument 100 int crypto_register_pcomp(struct pcomp_alg *alg) crypto_register_pcomp() argument 102 struct crypto_alg *base = &alg->base; crypto_register_pcomp() 112 int crypto_unregister_pcomp(struct pcomp_alg *alg) crypto_unregister_pcomp() argument 114 return crypto_unregister_alg(&alg->base); crypto_unregister_pcomp()
|
H A D | blkcipher.c | 421 struct blkcipher_alg *alg = &tfm->__crt_alg->cra_blkcipher; async_encrypt() local 429 return alg->encrypt(&desc, req->dst, req->src, req->nbytes); async_encrypt() 435 struct blkcipher_alg *alg = &tfm->__crt_alg->cra_blkcipher; async_decrypt() local 442 return alg->decrypt(&desc, req->dst, req->src, req->nbytes); async_decrypt() 445 static unsigned int crypto_blkcipher_ctxsize(struct crypto_alg *alg, u32 type, crypto_blkcipher_ctxsize() argument 448 struct blkcipher_alg *cipher = &alg->cra_blkcipher; crypto_blkcipher_ctxsize() 449 unsigned int len = alg->cra_ctxsize; crypto_blkcipher_ctxsize() 453 len = ALIGN(len, (unsigned long)alg->cra_alignmask + 1); crypto_blkcipher_ctxsize() 463 struct blkcipher_alg *alg = &tfm->__crt_alg->cra_blkcipher; crypto_init_blkcipher_ops_async() local 468 if (!alg->ivsize) { crypto_init_blkcipher_ops_async() 473 crt->ivsize = alg->ivsize; crypto_init_blkcipher_ops_async() 481 struct blkcipher_alg *alg = &tfm->__crt_alg->cra_blkcipher; crypto_init_blkcipher_ops_sync() local 486 crt->encrypt = alg->encrypt; crypto_init_blkcipher_ops_sync() 487 crt->decrypt = alg->decrypt; crypto_init_blkcipher_ops_sync() 499 struct blkcipher_alg *alg = &tfm->__crt_alg->cra_blkcipher; crypto_init_blkcipher_ops() local 501 if (alg->ivsize > PAGE_SIZE / 8) crypto_init_blkcipher_ops() 511 static int crypto_blkcipher_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_blkcipher_report() argument 516 strncpy(rblkcipher.geniv, alg->cra_blkcipher.geniv ?: "<default>", crypto_blkcipher_report() 519 rblkcipher.blocksize = alg->cra_blocksize; crypto_blkcipher_report() 520 rblkcipher.min_keysize = alg->cra_blkcipher.min_keysize; crypto_blkcipher_report() 521 rblkcipher.max_keysize = alg->cra_blkcipher.max_keysize; crypto_blkcipher_report() 522 rblkcipher.ivsize = alg->cra_blkcipher.ivsize; crypto_blkcipher_report() 533 static int crypto_blkcipher_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_blkcipher_report() argument 539 static void crypto_blkcipher_show(struct seq_file *m, struct crypto_alg *alg) 541 static void crypto_blkcipher_show(struct seq_file *m, struct crypto_alg *alg) crypto_blkcipher_show() argument 544 seq_printf(m, "blocksize : %u\n", alg->cra_blocksize); crypto_blkcipher_show() 545 seq_printf(m, "min keysize : %u\n", alg->cra_blkcipher.min_keysize); crypto_blkcipher_show() 546 seq_printf(m, "max keysize : %u\n", alg->cra_blkcipher.max_keysize); crypto_blkcipher_show() 547 seq_printf(m, "ivsize : %u\n", alg->cra_blkcipher.ivsize); crypto_blkcipher_show() 548 seq_printf(m, "geniv : %s\n", alg->cra_blkcipher.geniv ?: crypto_blkcipher_show() 565 struct crypto_alg *alg; crypto_grab_nivcipher() local 571 alg = crypto_alg_mod_lookup(name, type, mask); crypto_grab_nivcipher() 572 if (IS_ERR(alg)) crypto_grab_nivcipher() 573 return PTR_ERR(alg); crypto_grab_nivcipher() 575 err = crypto_init_spawn(&spawn->base, alg, spawn->base.inst, mask); crypto_grab_nivcipher() 576 crypto_mod_put(alg); crypto_grab_nivcipher() 600 struct crypto_alg *alg; skcipher_geniv_alloc() local 629 alg = crypto_skcipher_spawn_alg(spawn); skcipher_geniv_alloc() 631 if ((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) == skcipher_geniv_alloc() 633 balg.ivsize = alg->cra_blkcipher.ivsize; skcipher_geniv_alloc() 634 balg.min_keysize = alg->cra_blkcipher.min_keysize; skcipher_geniv_alloc() 635 balg.max_keysize = alg->cra_blkcipher.max_keysize; skcipher_geniv_alloc() 641 balg.geniv = alg->cra_blkcipher.geniv; skcipher_geniv_alloc() 643 balg.ivsize = alg->cra_ablkcipher.ivsize; skcipher_geniv_alloc() 644 balg.min_keysize = alg->cra_ablkcipher.min_keysize; skcipher_geniv_alloc() 645 balg.max_keysize = alg->cra_ablkcipher.max_keysize; skcipher_geniv_alloc() 647 balg.setkey = alg->cra_ablkcipher.setkey; skcipher_geniv_alloc() 648 balg.encrypt = alg->cra_ablkcipher.encrypt; skcipher_geniv_alloc() 649 balg.decrypt = alg->cra_ablkcipher.decrypt; skcipher_geniv_alloc() 651 balg.geniv = alg->cra_ablkcipher.geniv; skcipher_geniv_alloc() 665 balg.geniv = crypto_default_geniv(alg); skcipher_geniv_alloc() 670 memcpy(inst->alg.cra_name, alg->cra_name, CRYPTO_MAX_ALG_NAME); skcipher_geniv_alloc() 671 memcpy(inst->alg.cra_driver_name, alg->cra_driver_name, skcipher_geniv_alloc() 675 if (snprintf(inst->alg.cra_name, CRYPTO_MAX_ALG_NAME, skcipher_geniv_alloc() 676 "%s(%s)", tmpl->name, alg->cra_name) >= skcipher_geniv_alloc() 679 if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, skcipher_geniv_alloc() 680 "%s(%s)", tmpl->name, alg->cra_driver_name) >= skcipher_geniv_alloc() 685 inst->alg.cra_flags = CRYPTO_ALG_TYPE_GIVCIPHER | CRYPTO_ALG_GENIV; skcipher_geniv_alloc() 686 inst->alg.cra_flags |= alg->cra_flags & CRYPTO_ALG_ASYNC; skcipher_geniv_alloc() 687 inst->alg.cra_priority = alg->cra_priority; skcipher_geniv_alloc() 688 inst->alg.cra_blocksize = alg->cra_blocksize; skcipher_geniv_alloc() 689 inst->alg.cra_alignmask = alg->cra_alignmask; skcipher_geniv_alloc() 690 inst->alg.cra_type = &crypto_givcipher_type; skcipher_geniv_alloc() 692 inst->alg.cra_ablkcipher.ivsize = balg.ivsize; skcipher_geniv_alloc() 693 inst->alg.cra_ablkcipher.min_keysize = balg.min_keysize; skcipher_geniv_alloc() 694 inst->alg.cra_ablkcipher.max_keysize = balg.max_keysize; skcipher_geniv_alloc() 695 inst->alg.cra_ablkcipher.geniv = balg.geniv; skcipher_geniv_alloc() 697 inst->alg.cra_ablkcipher.setkey = balg.setkey; skcipher_geniv_alloc() 698 inst->alg.cra_ablkcipher.encrypt = balg.encrypt; skcipher_geniv_alloc() 699 inst->alg.cra_ablkcipher.decrypt = balg.decrypt; skcipher_geniv_alloc()
|
H A D | cbc.c | 217 struct crypto_alg *alg; crypto_cbc_alloc() local 224 alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER, crypto_cbc_alloc() 226 if (IS_ERR(alg)) crypto_cbc_alloc() 227 return ERR_CAST(alg); crypto_cbc_alloc() 230 if (!is_power_of_2(alg->cra_blocksize)) crypto_cbc_alloc() 233 inst = crypto_alloc_instance("cbc", alg); crypto_cbc_alloc() 237 inst->alg.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER; crypto_cbc_alloc() 238 inst->alg.cra_priority = alg->cra_priority; crypto_cbc_alloc() 239 inst->alg.cra_blocksize = alg->cra_blocksize; crypto_cbc_alloc() 240 inst->alg.cra_alignmask = alg->cra_alignmask; crypto_cbc_alloc() 241 inst->alg.cra_type = &crypto_blkcipher_type; crypto_cbc_alloc() 244 inst->alg.cra_alignmask |= __alignof__(u32) - 1; crypto_cbc_alloc() 246 inst->alg.cra_blkcipher.ivsize = alg->cra_blocksize; crypto_cbc_alloc() 247 inst->alg.cra_blkcipher.min_keysize = alg->cra_cipher.cia_min_keysize; crypto_cbc_alloc() 248 inst->alg.cra_blkcipher.max_keysize = alg->cra_cipher.cia_max_keysize; crypto_cbc_alloc() 250 inst->alg.cra_ctxsize = sizeof(struct crypto_cbc_ctx); crypto_cbc_alloc() 252 inst->alg.cra_init = crypto_cbc_init_tfm; crypto_cbc_alloc() 253 inst->alg.cra_exit = crypto_cbc_exit_tfm; crypto_cbc_alloc() 255 inst->alg.cra_blkcipher.setkey = crypto_cbc_setkey; crypto_cbc_alloc() 256 inst->alg.cra_blkcipher.encrypt = crypto_cbc_encrypt; crypto_cbc_alloc() 257 inst->alg.cra_blkcipher.decrypt = crypto_cbc_decrypt; crypto_cbc_alloc() 260 crypto_mod_put(alg); crypto_cbc_alloc()
|
H A D | xts.c | 290 struct crypto_alg *alg; alloc() local 297 alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER, alloc() 299 if (IS_ERR(alg)) alloc() 300 return ERR_CAST(alg); alloc() 302 inst = crypto_alloc_instance("xts", alg); alloc() 306 inst->alg.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER; alloc() 307 inst->alg.cra_priority = alg->cra_priority; alloc() 308 inst->alg.cra_blocksize = alg->cra_blocksize; alloc() 310 if (alg->cra_alignmask < 7) alloc() 311 inst->alg.cra_alignmask = 7; alloc() 313 inst->alg.cra_alignmask = alg->cra_alignmask; alloc() 315 inst->alg.cra_type = &crypto_blkcipher_type; alloc() 317 inst->alg.cra_blkcipher.ivsize = alg->cra_blocksize; alloc() 318 inst->alg.cra_blkcipher.min_keysize = alloc() 319 2 * alg->cra_cipher.cia_min_keysize; alloc() 320 inst->alg.cra_blkcipher.max_keysize = alloc() 321 2 * alg->cra_cipher.cia_max_keysize; alloc() 323 inst->alg.cra_ctxsize = sizeof(struct priv); alloc() 325 inst->alg.cra_init = init_tfm; alloc() 326 inst->alg.cra_exit = exit_tfm; alloc() 328 inst->alg.cra_blkcipher.setkey = setkey; alloc() 329 inst->alg.cra_blkcipher.encrypt = encrypt; alloc() 330 inst->alg.cra_blkcipher.decrypt = decrypt; alloc() 333 crypto_mod_put(alg); alloc()
|
H A D | pcbc.c | 227 struct crypto_alg *alg; crypto_pcbc_alloc() local 234 alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER, crypto_pcbc_alloc() 236 if (IS_ERR(alg)) crypto_pcbc_alloc() 237 return ERR_CAST(alg); crypto_pcbc_alloc() 239 inst = crypto_alloc_instance("pcbc", alg); crypto_pcbc_alloc() 243 inst->alg.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER; crypto_pcbc_alloc() 244 inst->alg.cra_priority = alg->cra_priority; crypto_pcbc_alloc() 245 inst->alg.cra_blocksize = alg->cra_blocksize; crypto_pcbc_alloc() 246 inst->alg.cra_alignmask = alg->cra_alignmask; crypto_pcbc_alloc() 247 inst->alg.cra_type = &crypto_blkcipher_type; crypto_pcbc_alloc() 250 inst->alg.cra_alignmask |= __alignof__(u32) - 1; crypto_pcbc_alloc() 252 inst->alg.cra_blkcipher.ivsize = alg->cra_blocksize; crypto_pcbc_alloc() 253 inst->alg.cra_blkcipher.min_keysize = alg->cra_cipher.cia_min_keysize; crypto_pcbc_alloc() 254 inst->alg.cra_blkcipher.max_keysize = alg->cra_cipher.cia_max_keysize; crypto_pcbc_alloc() 256 inst->alg.cra_ctxsize = sizeof(struct crypto_pcbc_ctx); crypto_pcbc_alloc() 258 inst->alg.cra_init = crypto_pcbc_init_tfm; crypto_pcbc_alloc() 259 inst->alg.cra_exit = crypto_pcbc_exit_tfm; crypto_pcbc_alloc() 261 inst->alg.cra_blkcipher.setkey = crypto_pcbc_setkey; crypto_pcbc_alloc() 262 inst->alg.cra_blkcipher.encrypt = crypto_pcbc_encrypt; crypto_pcbc_alloc() 263 inst->alg.cra_blkcipher.decrypt = crypto_pcbc_decrypt; crypto_pcbc_alloc() 266 crypto_mod_put(alg); crypto_pcbc_alloc()
|
H A D | cmac.c | 228 struct crypto_alg *alg; cmac_create() local 236 alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER, cmac_create() 238 if (IS_ERR(alg)) cmac_create() 239 return PTR_ERR(alg); cmac_create() 241 switch (alg->cra_blocksize) { cmac_create() 249 inst = shash_alloc_instance("cmac", alg); cmac_create() 254 err = crypto_init_spawn(shash_instance_ctx(inst), alg, cmac_create() 260 alignmask = alg->cra_alignmask | (sizeof(long) - 1); cmac_create() 261 inst->alg.base.cra_alignmask = alignmask; cmac_create() 262 inst->alg.base.cra_priority = alg->cra_priority; cmac_create() 263 inst->alg.base.cra_blocksize = alg->cra_blocksize; cmac_create() 265 inst->alg.digestsize = alg->cra_blocksize; cmac_create() 266 inst->alg.descsize = cmac_create() 269 + alg->cra_blocksize * 2; cmac_create() 271 inst->alg.base.cra_ctxsize = cmac_create() 273 + alg->cra_blocksize * 2; cmac_create() 275 inst->alg.base.cra_init = cmac_init_tfm; cmac_create() 276 inst->alg.base.cra_exit = cmac_exit_tfm; cmac_create() 278 inst->alg.init = crypto_cmac_digest_init; cmac_create() 279 inst->alg.update = crypto_cmac_digest_update; cmac_create() 280 inst->alg.final = crypto_cmac_digest_final; cmac_create() 281 inst->alg.setkey = crypto_cmac_digest_setkey; cmac_create() 290 crypto_mod_put(alg); cmac_create()
|
H A D | xcbc.c | 202 struct crypto_alg *alg; xcbc_create() local 210 alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER, xcbc_create() 212 if (IS_ERR(alg)) xcbc_create() 213 return PTR_ERR(alg); xcbc_create() 215 switch(alg->cra_blocksize) { xcbc_create() 222 inst = shash_alloc_instance("xcbc", alg); xcbc_create() 227 err = crypto_init_spawn(shash_instance_ctx(inst), alg, xcbc_create() 233 alignmask = alg->cra_alignmask | 3; xcbc_create() 234 inst->alg.base.cra_alignmask = alignmask; xcbc_create() 235 inst->alg.base.cra_priority = alg->cra_priority; xcbc_create() 236 inst->alg.base.cra_blocksize = alg->cra_blocksize; xcbc_create() 238 inst->alg.digestsize = alg->cra_blocksize; xcbc_create() 239 inst->alg.descsize = ALIGN(sizeof(struct xcbc_desc_ctx), xcbc_create() 243 alg->cra_blocksize * 2; xcbc_create() 245 inst->alg.base.cra_ctxsize = ALIGN(sizeof(struct xcbc_tfm_ctx), xcbc_create() 247 alg->cra_blocksize * 2; xcbc_create() 248 inst->alg.base.cra_init = xcbc_init_tfm; xcbc_create() 249 inst->alg.base.cra_exit = xcbc_exit_tfm; xcbc_create() 251 inst->alg.init = crypto_xcbc_digest_init; xcbc_create() 252 inst->alg.update = crypto_xcbc_digest_update; xcbc_create() 253 inst->alg.final = crypto_xcbc_digest_final; xcbc_create() 254 inst->alg.setkey = crypto_xcbc_digest_setkey; xcbc_create() 263 crypto_mod_put(alg); xcbc_create()
|
H A D | hmac.c | 184 struct crypto_alg *alg; hmac_create() local 201 alg = &salg->base; hmac_create() 202 if (ds > alg->cra_blocksize || hmac_create() 203 ss < alg->cra_blocksize) hmac_create() 206 inst = shash_alloc_instance("hmac", alg); hmac_create() 216 inst->alg.base.cra_priority = alg->cra_priority; hmac_create() 217 inst->alg.base.cra_blocksize = alg->cra_blocksize; hmac_create() 218 inst->alg.base.cra_alignmask = alg->cra_alignmask; hmac_create() 220 ss = ALIGN(ss, alg->cra_alignmask + 1); hmac_create() 221 inst->alg.digestsize = ds; hmac_create() 222 inst->alg.statesize = ss; hmac_create() 224 inst->alg.base.cra_ctxsize = sizeof(struct hmac_ctx) + hmac_create() 227 inst->alg.base.cra_init = hmac_init_tfm; hmac_create() 228 inst->alg.base.cra_exit = hmac_exit_tfm; hmac_create() 230 inst->alg.init = hmac_init; hmac_create() 231 inst->alg.update = hmac_update; hmac_create() 232 inst->alg.final = hmac_final; hmac_create() 233 inst->alg.finup = hmac_finup; hmac_create() 234 inst->alg.export = hmac_export; hmac_create() 235 inst->alg.import = hmac_import; hmac_create() 236 inst->alg.setkey = hmac_setkey; hmac_create() 245 crypto_mod_put(alg); hmac_create()
|
H A D | algboss.c | 41 } alg; member in union:cryptomgr_param::__anon3244 58 char alg[CRYPTO_MAX_ALG_NAME]; member in struct:crypto_test_param 90 crypto_alg_put(¶m->larval->alg); cryptomgr_probe() 99 const char *name = larval->alg.cra_name; cryptomgr_schedule_probe() 151 param->attrs[i].alg.attr.rta_len = cryptomgr_schedule_probe() 152 sizeof(param->attrs[i].alg); cryptomgr_schedule_probe() 153 param->attrs[i].alg.attr.rta_type = CRYPTOA_ALG; cryptomgr_schedule_probe() 154 memcpy(param->attrs[i].alg.data.name, name, len); cryptomgr_schedule_probe() 183 param->type.data.type = larval->alg.cra_flags & ~CRYPTO_ALG_TESTED; cryptomgr_schedule_probe() 187 param->otype = larval->alg.cra_flags; cryptomgr_schedule_probe() 190 crypto_alg_get(&larval->alg); cryptomgr_schedule_probe() 202 crypto_alg_put(&larval->alg); cryptomgr_schedule_probe() 224 err = alg_test(param->driver, param->alg, type, CRYPTO_ALG_TESTED); cryptomgr_test() 233 static int cryptomgr_schedule_test(struct crypto_alg *alg) cryptomgr_schedule_test() argument 246 memcpy(param->driver, alg->cra_driver_name, sizeof(param->driver)); cryptomgr_schedule_test() 247 memcpy(param->alg, alg->cra_name, sizeof(param->alg)); cryptomgr_schedule_test() 248 type = alg->cra_flags; cryptomgr_schedule_test() 253 ((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) == cryptomgr_schedule_test() 254 CRYPTO_ALG_TYPE_BLKCIPHER ? alg->cra_blkcipher.ivsize : cryptomgr_schedule_test() 255 alg->cra_ablkcipher.ivsize)) || cryptomgr_schedule_test() 257 alg->cra_type == &crypto_nivaead_type && alg->cra_aead.ivsize)) cryptomgr_schedule_test()
|
H A D | ahash.c | 452 struct ahash_alg *alg = crypto_ahash_alg(hash); crypto_ahash_init_tfm() local 462 hash->init = alg->init; crypto_ahash_init_tfm() 463 hash->update = alg->update; crypto_ahash_init_tfm() 464 hash->final = alg->final; crypto_ahash_init_tfm() 465 hash->finup = alg->finup ?: ahash_def_finup; crypto_ahash_init_tfm() 466 hash->digest = alg->digest; crypto_ahash_init_tfm() 468 if (alg->setkey) { crypto_ahash_init_tfm() 469 hash->setkey = alg->setkey; crypto_ahash_init_tfm() 472 if (alg->export) crypto_ahash_init_tfm() 473 hash->export = alg->export; crypto_ahash_init_tfm() 474 if (alg->import) crypto_ahash_init_tfm() 475 hash->import = alg->import; crypto_ahash_init_tfm() 480 static unsigned int crypto_ahash_extsize(struct crypto_alg *alg) crypto_ahash_extsize() argument 482 if (alg->cra_type == &crypto_ahash_type) crypto_ahash_extsize() 483 return alg->cra_ctxsize; crypto_ahash_extsize() 489 static int crypto_ahash_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_ahash_report() argument 495 rhash.blocksize = alg->cra_blocksize; crypto_ahash_report() 496 rhash.digestsize = __crypto_hash_alg_common(alg)->digestsize; crypto_ahash_report() 507 static int crypto_ahash_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_ahash_report() argument 513 static void crypto_ahash_show(struct seq_file *m, struct crypto_alg *alg) 515 static void crypto_ahash_show(struct seq_file *m, struct crypto_alg *alg) crypto_ahash_show() argument 518 seq_printf(m, "async : %s\n", alg->cra_flags & CRYPTO_ALG_ASYNC ? crypto_ahash_show() 520 seq_printf(m, "blocksize : %u\n", alg->cra_blocksize); crypto_ahash_show() 522 __crypto_hash_alg_common(alg)->digestsize); crypto_ahash_show() 546 static int ahash_prepare_alg(struct ahash_alg *alg) ahash_prepare_alg() argument 548 struct crypto_alg *base = &alg->halg.base; ahash_prepare_alg() 550 if (alg->halg.digestsize > PAGE_SIZE / 8 || ahash_prepare_alg() 551 alg->halg.statesize > PAGE_SIZE / 8 || ahash_prepare_alg() 552 alg->halg.statesize == 0) ahash_prepare_alg() 562 int crypto_register_ahash(struct ahash_alg *alg) crypto_register_ahash() argument 564 struct crypto_alg *base = &alg->halg.base; crypto_register_ahash() 567 err = ahash_prepare_alg(alg); crypto_register_ahash() 575 int crypto_unregister_ahash(struct ahash_alg *alg) crypto_unregister_ahash() argument 577 return crypto_unregister_alg(&alg->halg.base); crypto_unregister_ahash() 586 err = ahash_prepare_alg(&inst->alg); ahash_register_instance() 602 struct hash_alg_common *alg, crypto_init_ahash_spawn() 605 return crypto_init_spawn2(&spawn->base, &alg->base, inst, crypto_init_ahash_spawn() 612 struct crypto_alg *alg; ahash_attr_alg() local 614 alg = crypto_attr_alg2(rta, &crypto_ahash_type, type, mask); ahash_attr_alg() 615 return IS_ERR(alg) ? ERR_CAST(alg) : __crypto_hash_alg_common(alg); ahash_attr_alg() 601 crypto_init_ahash_spawn(struct crypto_ahash_spawn *spawn, struct hash_alg_common *alg, struct crypto_instance *inst) crypto_init_ahash_spawn() argument
|
H A D | rng.c | 54 struct rng_alg *alg = &tfm->__crt_alg->cra_rng; crypto_init_rng_ops() local 57 ops->rng_gen_random = alg->rng_make_random; crypto_init_rng_ops() 64 static int crypto_rng_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_rng_report() argument 70 rrng.seedsize = alg->cra_rng.seedsize; crypto_rng_report() 81 static int crypto_rng_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_rng_report() argument 87 static void crypto_rng_show(struct seq_file *m, struct crypto_alg *alg) 89 static void crypto_rng_show(struct seq_file *m, struct crypto_alg *alg) crypto_rng_show() argument 92 seq_printf(m, "seedsize : %u\n", alg->cra_rng.seedsize); crypto_rng_show() 95 static unsigned int crypto_rng_ctxsize(struct crypto_alg *alg, u32 type, crypto_rng_ctxsize() argument 98 return alg->cra_ctxsize; crypto_rng_ctxsize()
|
H A D | cts.c | 277 struct crypto_alg *alg; crypto_cts_alloc() local 284 alg = crypto_attr_alg(tb[1], CRYPTO_ALG_TYPE_BLKCIPHER, crypto_cts_alloc() 286 if (IS_ERR(alg)) crypto_cts_alloc() 287 return ERR_CAST(alg); crypto_cts_alloc() 290 if (!is_power_of_2(alg->cra_blocksize)) crypto_cts_alloc() 293 if (strncmp(alg->cra_name, "cbc(", 4)) crypto_cts_alloc() 296 inst = crypto_alloc_instance("cts", alg); crypto_cts_alloc() 300 inst->alg.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER; crypto_cts_alloc() 301 inst->alg.cra_priority = alg->cra_priority; crypto_cts_alloc() 302 inst->alg.cra_blocksize = alg->cra_blocksize; crypto_cts_alloc() 303 inst->alg.cra_alignmask = alg->cra_alignmask; crypto_cts_alloc() 304 inst->alg.cra_type = &crypto_blkcipher_type; crypto_cts_alloc() 307 inst->alg.cra_alignmask |= __alignof__(u32) - 1; crypto_cts_alloc() 309 inst->alg.cra_blkcipher.ivsize = alg->cra_blocksize; crypto_cts_alloc() 310 inst->alg.cra_blkcipher.min_keysize = alg->cra_blkcipher.min_keysize; crypto_cts_alloc() 311 inst->alg.cra_blkcipher.max_keysize = alg->cra_blkcipher.max_keysize; crypto_cts_alloc() 313 inst->alg.cra_ctxsize = sizeof(struct crypto_cts_ctx); crypto_cts_alloc() 315 inst->alg.cra_init = crypto_cts_init_tfm; crypto_cts_alloc() 316 inst->alg.cra_exit = crypto_cts_exit_tfm; crypto_cts_alloc() 318 inst->alg.cra_blkcipher.setkey = crypto_cts_setkey; crypto_cts_alloc() 319 inst->alg.cra_blkcipher.encrypt = crypto_cts_encrypt; crypto_cts_alloc() 320 inst->alg.cra_blkcipher.decrypt = crypto_cts_decrypt; crypto_cts_alloc() 323 crypto_mod_put(alg); crypto_cts_alloc()
|
H A D | pcrypt.c | 309 static struct crypto_instance *pcrypt_alloc_instance(struct crypto_alg *alg) pcrypt_alloc_instance() argument 322 if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, pcrypt_alloc_instance() 323 "pcrypt(%s)", alg->cra_driver_name) >= CRYPTO_MAX_ALG_NAME) pcrypt_alloc_instance() 326 memcpy(inst->alg.cra_name, alg->cra_name, CRYPTO_MAX_ALG_NAME); pcrypt_alloc_instance() 329 err = crypto_init_spawn(&ctx->spawn, alg, inst, pcrypt_alloc_instance() 334 inst->alg.cra_priority = alg->cra_priority + 100; pcrypt_alloc_instance() 335 inst->alg.cra_blocksize = alg->cra_blocksize; pcrypt_alloc_instance() 336 inst->alg.cra_alignmask = alg->cra_alignmask; pcrypt_alloc_instance() 351 struct crypto_alg *alg; pcrypt_alloc_aead() local 353 alg = crypto_get_attr_alg(tb, type, (mask & CRYPTO_ALG_TYPE_MASK)); pcrypt_alloc_aead() 354 if (IS_ERR(alg)) pcrypt_alloc_aead() 355 return ERR_CAST(alg); pcrypt_alloc_aead() 357 inst = pcrypt_alloc_instance(alg); pcrypt_alloc_aead() 361 inst->alg.cra_flags = CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC; pcrypt_alloc_aead() 362 inst->alg.cra_type = &crypto_aead_type; pcrypt_alloc_aead() 364 inst->alg.cra_aead.ivsize = alg->cra_aead.ivsize; pcrypt_alloc_aead() 365 inst->alg.cra_aead.geniv = alg->cra_aead.geniv; pcrypt_alloc_aead() 366 inst->alg.cra_aead.maxauthsize = alg->cra_aead.maxauthsize; pcrypt_alloc_aead() 368 inst->alg.cra_ctxsize = sizeof(struct pcrypt_aead_ctx); pcrypt_alloc_aead() 370 inst->alg.cra_init = pcrypt_aead_init_tfm; pcrypt_alloc_aead() 371 inst->alg.cra_exit = pcrypt_aead_exit_tfm; pcrypt_alloc_aead() 373 inst->alg.cra_aead.setkey = pcrypt_aead_setkey; pcrypt_alloc_aead() 374 inst->alg.cra_aead.setauthsize = pcrypt_aead_setauthsize; pcrypt_alloc_aead() 375 inst->alg.cra_aead.encrypt = pcrypt_aead_encrypt; pcrypt_alloc_aead() 376 inst->alg.cra_aead.decrypt = pcrypt_aead_decrypt; pcrypt_alloc_aead() 377 inst->alg.cra_aead.givencrypt = pcrypt_aead_givencrypt; pcrypt_alloc_aead() 380 crypto_mod_put(alg); pcrypt_alloc_aead()
|
H A D | mcryptd.c | 33 static void *mcryptd_alloc_instance(struct crypto_alg *alg, unsigned int head, 228 static void *mcryptd_alloc_instance(struct crypto_alg *alg, unsigned int head, mcryptd_alloc_instance() argument 242 if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, mcryptd_alloc_instance() 243 "mcryptd(%s)", alg->cra_driver_name) >= CRYPTO_MAX_ALG_NAME) mcryptd_alloc_instance() 246 memcpy(inst->alg.cra_name, alg->cra_name, CRYPTO_MAX_ALG_NAME); mcryptd_alloc_instance() 248 inst->alg.cra_priority = alg->cra_priority + 50; mcryptd_alloc_instance() 249 inst->alg.cra_blocksize = alg->cra_blocksize; mcryptd_alloc_instance() 250 inst->alg.cra_alignmask = alg->cra_alignmask; mcryptd_alloc_instance() 496 struct crypto_alg *alg; mcryptd_create_hash() local 507 alg = &salg->base; mcryptd_create_hash() 508 pr_debug("crypto: mcryptd hash alg: %s\n", alg->cra_name); mcryptd_create_hash() 509 inst = mcryptd_alloc_instance(alg, ahash_instance_headroom(), mcryptd_create_hash() 524 if (alg->cra_flags & CRYPTO_ALG_INTERNAL) mcryptd_create_hash() 526 inst->alg.halg.base.cra_flags = type; mcryptd_create_hash() 528 inst->alg.halg.digestsize = salg->digestsize; mcryptd_create_hash() 529 inst->alg.halg.base.cra_ctxsize = sizeof(struct mcryptd_hash_ctx); mcryptd_create_hash() 531 inst->alg.halg.base.cra_init = mcryptd_hash_init_tfm; mcryptd_create_hash() 532 inst->alg.halg.base.cra_exit = mcryptd_hash_exit_tfm; mcryptd_create_hash() 534 inst->alg.init = mcryptd_hash_init_enqueue; mcryptd_create_hash() 535 inst->alg.update = mcryptd_hash_update_enqueue; mcryptd_create_hash() 536 inst->alg.final = mcryptd_hash_final_enqueue; mcryptd_create_hash() 537 inst->alg.finup = mcryptd_hash_finup_enqueue; mcryptd_create_hash() 538 inst->alg.export = mcryptd_hash_export; mcryptd_create_hash() 539 inst->alg.import = mcryptd_hash_import; mcryptd_create_hash() 540 inst->alg.setkey = mcryptd_hash_setkey; mcryptd_create_hash() 541 inst->alg.digest = mcryptd_hash_digest_enqueue; mcryptd_create_hash() 551 crypto_mod_put(alg); mcryptd_create_hash() 579 switch (inst->alg.cra_flags & CRYPTO_ALG_TYPE_MASK) { mcryptd_free()
|
H A D | shash.c | 335 struct shash_alg *alg = __crypto_shash_alg(calg); crypto_init_shash_ops_async() local 359 crt->has_setkey = alg->setkey != shash_no_setkey; crypto_init_shash_ops_async() 361 if (alg->export) crypto_init_shash_ops_async() 363 if (alg->import) crypto_init_shash_ops_async() 459 struct shash_alg *alg = __crypto_shash_alg(calg); crypto_init_shash_ops_compat() local 490 crt->digestsize = alg->digestsize; crypto_init_shash_ops_compat() 505 static unsigned int crypto_shash_ctxsize(struct crypto_alg *alg, u32 type, crypto_shash_ctxsize() argument 524 static unsigned int crypto_shash_extsize(struct crypto_alg *alg) crypto_shash_extsize() argument 526 return alg->cra_ctxsize; crypto_shash_extsize() 530 static int crypto_shash_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_shash_report() argument 533 struct shash_alg *salg = __crypto_shash_alg(alg); crypto_shash_report() 537 rhash.blocksize = alg->cra_blocksize; crypto_shash_report() 549 static int crypto_shash_report(struct sk_buff *skb, struct crypto_alg *alg) crypto_shash_report() argument 555 static void crypto_shash_show(struct seq_file *m, struct crypto_alg *alg) 557 static void crypto_shash_show(struct seq_file *m, struct crypto_alg *alg) crypto_shash_show() argument 559 struct shash_alg *salg = __crypto_shash_alg(alg); crypto_shash_show() 562 seq_printf(m, "blocksize : %u\n", alg->cra_blocksize); crypto_shash_show() 588 static int shash_prepare_alg(struct shash_alg *alg) shash_prepare_alg() argument 590 struct crypto_alg *base = &alg->base; shash_prepare_alg() 592 if (alg->digestsize > PAGE_SIZE / 8 || shash_prepare_alg() 593 alg->descsize > PAGE_SIZE / 8 || shash_prepare_alg() 594 alg->statesize > PAGE_SIZE / 8) shash_prepare_alg() 601 if (!alg->finup) shash_prepare_alg() 602 alg->finup = shash_finup_unaligned; shash_prepare_alg() 603 if (!alg->digest) shash_prepare_alg() 604 alg->digest = shash_digest_unaligned; shash_prepare_alg() 605 if (!alg->export) { shash_prepare_alg() 606 alg->export = shash_default_export; shash_prepare_alg() 607 alg->import = shash_default_import; shash_prepare_alg() 608 alg->statesize = alg->descsize; shash_prepare_alg() 610 if (!alg->setkey) shash_prepare_alg() 611 alg->setkey = shash_no_setkey; shash_prepare_alg() 616 int crypto_register_shash(struct shash_alg *alg) crypto_register_shash() argument 618 struct crypto_alg *base = &alg->base; crypto_register_shash() 621 err = shash_prepare_alg(alg); crypto_register_shash() 629 int crypto_unregister_shash(struct shash_alg *alg) crypto_unregister_shash() argument 631 return crypto_unregister_alg(&alg->base); crypto_unregister_shash() 676 err = shash_prepare_alg(&inst->alg); shash_register_instance() 692 struct shash_alg *alg, crypto_init_shash_spawn() 695 return crypto_init_spawn2(&spawn->base, &alg->base, inst, crypto_init_shash_spawn() 702 struct crypto_alg *alg; shash_attr_alg() local 704 alg = crypto_attr_alg2(rta, &crypto_shash_type, type, mask); shash_attr_alg() 705 return IS_ERR(alg) ? ERR_CAST(alg) : shash_attr_alg() 706 container_of(alg, struct shash_alg, base); shash_attr_alg() 691 crypto_init_shash_spawn(struct crypto_shash_spawn *spawn, struct shash_alg *alg, struct crypto_instance *inst) crypto_init_shash_spawn() argument
|
H A D | gcm.c | 754 if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, crypto_gcm_alloc_common() 760 memcpy(inst->alg.cra_name, full_name, CRYPTO_MAX_ALG_NAME); crypto_gcm_alloc_common() 762 inst->alg.cra_flags = CRYPTO_ALG_TYPE_AEAD; crypto_gcm_alloc_common() 763 inst->alg.cra_flags |= ctr->cra_flags & CRYPTO_ALG_ASYNC; crypto_gcm_alloc_common() 764 inst->alg.cra_priority = ctr->cra_priority; crypto_gcm_alloc_common() 765 inst->alg.cra_blocksize = 1; crypto_gcm_alloc_common() 766 inst->alg.cra_alignmask = ctr->cra_alignmask | (__alignof__(u64) - 1); crypto_gcm_alloc_common() 767 inst->alg.cra_type = &crypto_aead_type; crypto_gcm_alloc_common() 768 inst->alg.cra_aead.ivsize = 16; crypto_gcm_alloc_common() 769 inst->alg.cra_aead.maxauthsize = 16; crypto_gcm_alloc_common() 770 inst->alg.cra_ctxsize = sizeof(struct crypto_gcm_ctx); crypto_gcm_alloc_common() 771 inst->alg.cra_init = crypto_gcm_init_tfm; crypto_gcm_alloc_common() 772 inst->alg.cra_exit = crypto_gcm_exit_tfm; crypto_gcm_alloc_common() 773 inst->alg.cra_aead.setkey = crypto_gcm_setkey; crypto_gcm_alloc_common() 774 inst->alg.cra_aead.setauthsize = crypto_gcm_setauthsize; crypto_gcm_alloc_common() 775 inst->alg.cra_aead.encrypt = crypto_gcm_encrypt; crypto_gcm_alloc_common() 776 inst->alg.cra_aead.decrypt = crypto_gcm_decrypt; crypto_gcm_alloc_common() 969 struct crypto_alg *alg; crypto_rfc4106_alloc() local 995 alg = crypto_aead_spawn_alg(spawn); crypto_rfc4106_alloc() 1000 if (alg->cra_aead.ivsize != 16) crypto_rfc4106_alloc() 1004 if (alg->cra_blocksize != 1) crypto_rfc4106_alloc() 1008 if (snprintf(inst->alg.cra_name, CRYPTO_MAX_ALG_NAME, crypto_rfc4106_alloc() 1009 "rfc4106(%s)", alg->cra_name) >= CRYPTO_MAX_ALG_NAME || crypto_rfc4106_alloc() 1010 snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, crypto_rfc4106_alloc() 1011 "rfc4106(%s)", alg->cra_driver_name) >= crypto_rfc4106_alloc() 1015 inst->alg.cra_flags = CRYPTO_ALG_TYPE_AEAD; crypto_rfc4106_alloc() 1016 inst->alg.cra_flags |= alg->cra_flags & CRYPTO_ALG_ASYNC; crypto_rfc4106_alloc() 1017 inst->alg.cra_priority = alg->cra_priority; crypto_rfc4106_alloc() 1018 inst->alg.cra_blocksize = 1; crypto_rfc4106_alloc() 1019 inst->alg.cra_alignmask = alg->cra_alignmask; crypto_rfc4106_alloc() 1020 inst->alg.cra_type = &crypto_nivaead_type; crypto_rfc4106_alloc() 1022 inst->alg.cra_aead.ivsize = 8; crypto_rfc4106_alloc() 1023 inst->alg.cra_aead.maxauthsize = 16; crypto_rfc4106_alloc() 1025 inst->alg.cra_ctxsize = sizeof(struct crypto_rfc4106_ctx); crypto_rfc4106_alloc() 1027 inst->alg.cra_init = crypto_rfc4106_init_tfm; crypto_rfc4106_alloc() 1028 inst->alg.cra_exit = crypto_rfc4106_exit_tfm; crypto_rfc4106_alloc() 1030 inst->alg.cra_aead.setkey = crypto_rfc4106_setkey; crypto_rfc4106_alloc() 1031 inst->alg.cra_aead.setauthsize = crypto_rfc4106_setauthsize; crypto_rfc4106_alloc() 1032 inst->alg.cra_aead.encrypt = crypto_rfc4106_encrypt; crypto_rfc4106_alloc() 1033 inst->alg.cra_aead.decrypt = crypto_rfc4106_decrypt; crypto_rfc4106_alloc() 1035 inst->alg.cra_aead.geniv = "seqiv"; crypto_rfc4106_alloc() 1284 struct crypto_alg *alg; crypto_rfc4543_alloc() local 1312 alg = crypto_aead_spawn_alg(spawn); crypto_rfc4543_alloc() 1325 if (alg->cra_aead.ivsize != 16) crypto_rfc4543_alloc() 1329 if (alg->cra_blocksize != 1) crypto_rfc4543_alloc() 1333 if (snprintf(inst->alg.cra_name, CRYPTO_MAX_ALG_NAME, crypto_rfc4543_alloc() 1334 "rfc4543(%s)", alg->cra_name) >= CRYPTO_MAX_ALG_NAME || crypto_rfc4543_alloc() 1335 snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, crypto_rfc4543_alloc() 1336 "rfc4543(%s)", alg->cra_driver_name) >= crypto_rfc4543_alloc() 1340 inst->alg.cra_flags = CRYPTO_ALG_TYPE_AEAD; crypto_rfc4543_alloc() 1341 inst->alg.cra_flags |= alg->cra_flags & CRYPTO_ALG_ASYNC; crypto_rfc4543_alloc() 1342 inst->alg.cra_priority = alg->cra_priority; crypto_rfc4543_alloc() 1343 inst->alg.cra_blocksize = 1; crypto_rfc4543_alloc() 1344 inst->alg.cra_alignmask = alg->cra_alignmask; crypto_rfc4543_alloc() 1345 inst->alg.cra_type = &crypto_nivaead_type; crypto_rfc4543_alloc() 1347 inst->alg.cra_aead.ivsize = 8; crypto_rfc4543_alloc() 1348 inst->alg.cra_aead.maxauthsize = 16; crypto_rfc4543_alloc() 1350 inst->alg.cra_ctxsize = sizeof(struct crypto_rfc4543_ctx); crypto_rfc4543_alloc() 1352 inst->alg.cra_init = crypto_rfc4543_init_tfm; crypto_rfc4543_alloc() 1353 inst->alg.cra_exit = crypto_rfc4543_exit_tfm; crypto_rfc4543_alloc() 1355 inst->alg.cra_aead.setkey = crypto_rfc4543_setkey; crypto_rfc4543_alloc() 1356 inst->alg.cra_aead.setauthsize = crypto_rfc4543_setauthsize; crypto_rfc4543_alloc() 1357 inst->alg.cra_aead.encrypt = crypto_rfc4543_encrypt; crypto_rfc4543_alloc() 1358 inst->alg.cra_aead.decrypt = crypto_rfc4543_decrypt; crypto_rfc4543_alloc() 1360 inst->alg.cra_aead.geniv = "seqiv"; crypto_rfc4543_alloc()
|
H A D | ccm.c | 534 if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, crypto_ccm_alloc_common() 539 memcpy(inst->alg.cra_name, full_name, CRYPTO_MAX_ALG_NAME); crypto_ccm_alloc_common() 541 inst->alg.cra_flags = CRYPTO_ALG_TYPE_AEAD; crypto_ccm_alloc_common() 542 inst->alg.cra_flags |= ctr->cra_flags & CRYPTO_ALG_ASYNC; crypto_ccm_alloc_common() 543 inst->alg.cra_priority = cipher->cra_priority + ctr->cra_priority; crypto_ccm_alloc_common() 544 inst->alg.cra_blocksize = 1; crypto_ccm_alloc_common() 545 inst->alg.cra_alignmask = cipher->cra_alignmask | ctr->cra_alignmask | crypto_ccm_alloc_common() 547 inst->alg.cra_type = &crypto_aead_type; crypto_ccm_alloc_common() 548 inst->alg.cra_aead.ivsize = 16; crypto_ccm_alloc_common() 549 inst->alg.cra_aead.maxauthsize = 16; crypto_ccm_alloc_common() 550 inst->alg.cra_ctxsize = sizeof(struct crypto_ccm_ctx); crypto_ccm_alloc_common() 551 inst->alg.cra_init = crypto_ccm_init_tfm; crypto_ccm_alloc_common() 552 inst->alg.cra_exit = crypto_ccm_exit_tfm; crypto_ccm_alloc_common() 553 inst->alg.cra_aead.setkey = crypto_ccm_setkey; crypto_ccm_alloc_common() 554 inst->alg.cra_aead.setauthsize = crypto_ccm_setauthsize; crypto_ccm_alloc_common() 555 inst->alg.cra_aead.encrypt = crypto_ccm_encrypt; crypto_ccm_alloc_common() 556 inst->alg.cra_aead.decrypt = crypto_ccm_decrypt; crypto_ccm_alloc_common() 752 struct crypto_alg *alg; crypto_rfc4309_alloc() local 778 alg = crypto_aead_spawn_alg(spawn); crypto_rfc4309_alloc() 783 if (alg->cra_aead.ivsize != 16) crypto_rfc4309_alloc() 787 if (alg->cra_blocksize != 1) crypto_rfc4309_alloc() 791 if (snprintf(inst->alg.cra_name, CRYPTO_MAX_ALG_NAME, crypto_rfc4309_alloc() 792 "rfc4309(%s)", alg->cra_name) >= CRYPTO_MAX_ALG_NAME || crypto_rfc4309_alloc() 793 snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, crypto_rfc4309_alloc() 794 "rfc4309(%s)", alg->cra_driver_name) >= crypto_rfc4309_alloc() 798 inst->alg.cra_flags = CRYPTO_ALG_TYPE_AEAD; crypto_rfc4309_alloc() 799 inst->alg.cra_flags |= alg->cra_flags & CRYPTO_ALG_ASYNC; crypto_rfc4309_alloc() 800 inst->alg.cra_priority = alg->cra_priority; crypto_rfc4309_alloc() 801 inst->alg.cra_blocksize = 1; crypto_rfc4309_alloc() 802 inst->alg.cra_alignmask = alg->cra_alignmask; crypto_rfc4309_alloc() 803 inst->alg.cra_type = &crypto_nivaead_type; crypto_rfc4309_alloc() 805 inst->alg.cra_aead.ivsize = 8; crypto_rfc4309_alloc() 806 inst->alg.cra_aead.maxauthsize = 16; crypto_rfc4309_alloc() 808 inst->alg.cra_ctxsize = sizeof(struct crypto_rfc4309_ctx); crypto_rfc4309_alloc() 810 inst->alg.cra_init = crypto_rfc4309_init_tfm; crypto_rfc4309_alloc() 811 inst->alg.cra_exit = crypto_rfc4309_exit_tfm; crypto_rfc4309_alloc() 813 inst->alg.cra_aead.setkey = crypto_rfc4309_setkey; crypto_rfc4309_alloc() 814 inst->alg.cra_aead.setauthsize = crypto_rfc4309_setauthsize; crypto_rfc4309_alloc() 815 inst->alg.cra_aead.encrypt = crypto_rfc4309_encrypt; crypto_rfc4309_alloc() 816 inst->alg.cra_aead.decrypt = crypto_rfc4309_decrypt; crypto_rfc4309_alloc() 818 inst->alg.cra_aead.geniv = "seqiv"; crypto_rfc4309_alloc()
|
H A D | seqiv.c | 270 if (inst->alg.cra_ablkcipher.ivsize < sizeof(u64)) { seqiv_ablkcipher_alloc() 276 inst->alg.cra_ablkcipher.givencrypt = seqiv_givencrypt_first; seqiv_ablkcipher_alloc() 278 inst->alg.cra_init = seqiv_init; seqiv_ablkcipher_alloc() 279 inst->alg.cra_exit = skcipher_geniv_exit; seqiv_ablkcipher_alloc() 281 inst->alg.cra_ctxsize += inst->alg.cra_ablkcipher.ivsize; seqiv_ablkcipher_alloc() 296 if (inst->alg.cra_aead.ivsize < sizeof(u64)) { seqiv_aead_alloc() 302 inst->alg.cra_aead.givencrypt = seqiv_aead_givencrypt_first; seqiv_aead_alloc() 304 inst->alg.cra_init = seqiv_aead_init; seqiv_aead_alloc() 305 inst->alg.cra_exit = aead_geniv_exit; seqiv_aead_alloc() 307 inst->alg.cra_ctxsize = inst->alg.cra_aead.ivsize; seqiv_aead_alloc() 335 inst->alg.cra_alignmask |= __alignof__(u32) - 1; seqiv_alloc() 336 inst->alg.cra_ctxsize += sizeof(struct seqiv_ctx); seqiv_alloc() 348 if ((inst->alg.cra_flags ^ CRYPTO_ALG_TYPE_AEAD) & CRYPTO_ALG_TYPE_MASK) seqiv_free()
|
H A D | sha1_generic.c | 62 static struct shash_alg alg = { variable in typeref:struct:shash_alg 80 return crypto_register_shash(&alg); sha1_generic_mod_init() 85 crypto_unregister_shash(&alg); sha1_generic_mod_fini()
|
H A D | chainiv.c | 305 inst->alg.cra_ablkcipher.givencrypt = chainiv_givencrypt_first; chainiv_alloc() 307 inst->alg.cra_init = chainiv_init; chainiv_alloc() 308 inst->alg.cra_exit = skcipher_geniv_exit; chainiv_alloc() 310 inst->alg.cra_ctxsize = sizeof(struct chainiv_ctx); chainiv_alloc() 313 inst->alg.cra_flags |= CRYPTO_ALG_ASYNC; chainiv_alloc() 315 inst->alg.cra_ablkcipher.givencrypt = chainiv_alloc() 318 inst->alg.cra_init = async_chainiv_init; chainiv_alloc() 319 inst->alg.cra_exit = async_chainiv_exit; chainiv_alloc() 321 inst->alg.cra_ctxsize = sizeof(struct async_chainiv_ctx); chainiv_alloc() 324 inst->alg.cra_ctxsize += inst->alg.cra_ablkcipher.ivsize; chainiv_alloc()
|
H A D | lzo.c | 83 static struct crypto_alg alg = { variable in typeref:struct:crypto_alg 97 return crypto_register_alg(&alg); lzo_mod_init() 102 crypto_unregister_alg(&alg); lzo_mod_fini()
|
H A D | vmac.c | 646 struct crypto_alg *alg; vmac_create() local 653 alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER, vmac_create() 655 if (IS_ERR(alg)) vmac_create() 656 return PTR_ERR(alg); vmac_create() 658 inst = shash_alloc_instance("vmac", alg); vmac_create() 663 err = crypto_init_spawn(shash_instance_ctx(inst), alg, vmac_create() 669 inst->alg.base.cra_priority = alg->cra_priority; vmac_create() 670 inst->alg.base.cra_blocksize = alg->cra_blocksize; vmac_create() 671 inst->alg.base.cra_alignmask = alg->cra_alignmask; vmac_create() 673 inst->alg.digestsize = sizeof(vmac_t); vmac_create() 674 inst->alg.base.cra_ctxsize = sizeof(struct vmac_ctx_t); vmac_create() 675 inst->alg.base.cra_init = vmac_init_tfm; vmac_create() 676 inst->alg.base.cra_exit = vmac_exit_tfm; vmac_create() 678 inst->alg.init = vmac_init; vmac_create() 679 inst->alg.update = vmac_update; vmac_create() 680 inst->alg.final = vmac_final; vmac_create() 681 inst->alg.setkey = vmac_setkey; vmac_create() 690 crypto_mod_put(alg); vmac_create()
|
H A D | eseqiv.c | 220 if (inst->alg.cra_ablkcipher.ivsize != inst->alg.cra_blocksize) eseqiv_alloc() 223 inst->alg.cra_ablkcipher.givencrypt = eseqiv_givencrypt_first; eseqiv_alloc() 225 inst->alg.cra_init = eseqiv_init; eseqiv_alloc() 226 inst->alg.cra_exit = skcipher_geniv_exit; eseqiv_alloc() 228 inst->alg.cra_ctxsize = sizeof(struct eseqiv_ctx); eseqiv_alloc() 229 inst->alg.cra_ctxsize += inst->alg.cra_ablkcipher.ivsize; eseqiv_alloc()
|
H A D | blowfish_generic.c | 109 static struct crypto_alg alg = { variable in typeref:struct:crypto_alg 128 return crypto_register_alg(&alg); blowfish_mod_init() 133 crypto_unregister_alg(&alg); blowfish_mod_fini()
|
H A D | crc32.c | 123 static struct shash_alg alg = { variable in typeref:struct:shash_alg 145 return crypto_register_shash(&alg); crc32_mod_init() 150 crypto_unregister_shash(&alg); crc32_mod_fini()
|
H A D | crct10dif_generic.c | 91 static struct shash_alg alg = { variable in typeref:struct:shash_alg 112 ret = crypto_register_shash(&alg); crct10dif_mod_init() 118 crypto_unregister_shash(&alg); crct10dif_mod_fini()
|
H A D | md5.c | 139 static struct shash_alg alg = { variable in typeref:struct:shash_alg 158 return crypto_register_shash(&alg); md5_mod_init() 163 crypto_unregister_shash(&alg); md5_mod_fini()
|
H A D | michael_mic.c | 153 static struct shash_alg alg = { variable in typeref:struct:shash_alg 171 return crypto_register_shash(&alg); michael_mic_init() 177 crypto_unregister_shash(&alg); michael_mic_exit()
|
H A D | authenc.c | 647 if (snprintf(inst->alg.cra_name, CRYPTO_MAX_ALG_NAME, crypto_authenc_alloc() 652 if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, crypto_authenc_alloc() 657 inst->alg.cra_flags = CRYPTO_ALG_TYPE_AEAD; crypto_authenc_alloc() 658 inst->alg.cra_flags |= enc->cra_flags & CRYPTO_ALG_ASYNC; crypto_authenc_alloc() 659 inst->alg.cra_priority = enc->cra_priority * crypto_authenc_alloc() 661 inst->alg.cra_blocksize = enc->cra_blocksize; crypto_authenc_alloc() 662 inst->alg.cra_alignmask = auth_base->cra_alignmask | enc->cra_alignmask; crypto_authenc_alloc() 663 inst->alg.cra_type = &crypto_aead_type; crypto_authenc_alloc() 665 inst->alg.cra_aead.ivsize = enc->cra_ablkcipher.ivsize; crypto_authenc_alloc() 666 inst->alg.cra_aead.maxauthsize = auth->digestsize; crypto_authenc_alloc() 668 inst->alg.cra_ctxsize = sizeof(struct crypto_authenc_ctx); crypto_authenc_alloc() 670 inst->alg.cra_init = crypto_authenc_init_tfm; crypto_authenc_alloc() 671 inst->alg.cra_exit = crypto_authenc_exit_tfm; crypto_authenc_alloc() 673 inst->alg.cra_aead.setkey = crypto_authenc_setkey; crypto_authenc_alloc() 674 inst->alg.cra_aead.encrypt = crypto_authenc_encrypt; crypto_authenc_alloc() 675 inst->alg.cra_aead.decrypt = crypto_authenc_decrypt; crypto_authenc_alloc() 676 inst->alg.cra_aead.givencrypt = crypto_authenc_givencrypt; crypto_authenc_alloc()
|
H A D | authencesn.c | 739 if (snprintf(inst->alg.cra_name, CRYPTO_MAX_ALG_NAME, crypto_authenc_esn_alloc() 744 if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, crypto_authenc_esn_alloc() 749 inst->alg.cra_flags = CRYPTO_ALG_TYPE_AEAD; crypto_authenc_esn_alloc() 750 inst->alg.cra_flags |= enc->cra_flags & CRYPTO_ALG_ASYNC; crypto_authenc_esn_alloc() 751 inst->alg.cra_priority = enc->cra_priority * crypto_authenc_esn_alloc() 753 inst->alg.cra_blocksize = enc->cra_blocksize; crypto_authenc_esn_alloc() 754 inst->alg.cra_alignmask = auth_base->cra_alignmask | enc->cra_alignmask; crypto_authenc_esn_alloc() 755 inst->alg.cra_type = &crypto_aead_type; crypto_authenc_esn_alloc() 757 inst->alg.cra_aead.ivsize = enc->cra_ablkcipher.ivsize; crypto_authenc_esn_alloc() 758 inst->alg.cra_aead.maxauthsize = auth->digestsize; crypto_authenc_esn_alloc() 760 inst->alg.cra_ctxsize = sizeof(struct crypto_authenc_esn_ctx); crypto_authenc_esn_alloc() 762 inst->alg.cra_init = crypto_authenc_esn_init_tfm; crypto_authenc_esn_alloc() 763 inst->alg.cra_exit = crypto_authenc_esn_exit_tfm; crypto_authenc_esn_alloc() 765 inst->alg.cra_aead.setkey = crypto_authenc_esn_setkey; crypto_authenc_esn_alloc() 766 inst->alg.cra_aead.encrypt = crypto_authenc_esn_encrypt; crypto_authenc_esn_alloc() 767 inst->alg.cra_aead.decrypt = crypto_authenc_esn_decrypt; crypto_authenc_esn_alloc() 768 inst->alg.cra_aead.givencrypt = crypto_authenc_esn_givencrypt; crypto_authenc_esn_alloc()
|
H A D | 842.c | 155 static struct crypto_alg alg = { variable in typeref:struct:crypto_alg 170 return crypto_register_alg(&alg); nx842_mod_init() 175 crypto_unregister_alg(&alg); nx842_mod_exit()
|
H A D | crc32c_generic.c | 136 static struct shash_alg alg = { variable in typeref:struct:shash_alg 159 return crypto_register_shash(&alg); crc32c_mod_init() 164 crypto_unregister_shash(&alg); crc32c_mod_fini()
|
H A D | deflate.c | 197 static struct crypto_alg alg = { variable in typeref:struct:crypto_alg 211 return crypto_register_alg(&alg); deflate_mod_init() 216 crypto_unregister_alg(&alg); deflate_mod_fini()
|
H A D | md4.c | 229 static struct shash_alg alg = { variable in typeref:struct:shash_alg 245 return crypto_register_shash(&alg); md4_mod_init() 250 crypto_unregister_shash(&alg); md4_mod_fini()
|
H A D | salsa20_generic.c | 214 static struct crypto_alg alg = { variable in typeref:struct:crypto_alg 238 return crypto_register_alg(&alg); salsa20_generic_mod_init() 243 crypto_unregister_alg(&alg); salsa20_generic_mod_fini()
|
H A D | tcrypt.c | 60 static char *alg = NULL; variable 320 pr_err("alg: aead: Failed to load transform for %s: %ld\n", algo, test_aead_speed() 330 pr_err("alg: aead: Failed to allocate request for %s\n", test_aead_speed() 1213 printk("alg %s ", *name); test_available() 1220 static inline int tcrypt_test(const char *alg) tcrypt_test() argument 1224 ret = alg_test(alg, alg, 0, 0); tcrypt_test() 1231 static int do_test(const char *alg, u32 type, u32 mask, int m) do_test() argument 1238 if (alg) { do_test() 1239 if (!crypto_has_alg(alg, type, do_test() 1765 if (alg) { do_test() 1766 test_hash_speed(alg, sec, generic_hash_speed_template); do_test() 1856 if (alg) { do_test() 1857 test_ahash_speed(alg, sec, generic_hash_speed_template); do_test() 2161 err = do_test(alg, type, mask, mode); tcrypt_mod_init() 2194 module_param(alg, charp, 0);
|
H A D | cast6_generic.c | 260 static struct crypto_alg alg = { variable in typeref:struct:crypto_alg 281 return crypto_register_alg(&alg); cast6_mod_init() 286 crypto_unregister_alg(&alg); cast6_mod_fini()
|
H A D | twofish_generic.c | 182 static struct crypto_alg alg = { variable in typeref:struct:crypto_alg 201 return crypto_register_alg(&alg); twofish_mod_init() 206 crypto_unregister_alg(&alg); twofish_mod_fini()
|
H A D | drbg.c | 1892 static inline void __init drbg_fill_array(struct crypto_alg *alg, drbg_fill_array() argument 1898 memset(alg, 0, sizeof(struct crypto_alg)); drbg_fill_array() 1899 memcpy(alg->cra_name, "stdrng", 6); drbg_fill_array() 1901 memcpy(alg->cra_driver_name, "drbg_pr_", 8); drbg_fill_array() 1904 memcpy(alg->cra_driver_name, "drbg_nopr_", 10); drbg_fill_array() 1907 memcpy(alg->cra_driver_name + pos, core->cra_name, drbg_fill_array() 1910 alg->cra_priority = priority; drbg_fill_array() 1918 alg->cra_priority += 200; drbg_fill_array() 1920 alg->cra_flags = CRYPTO_ALG_TYPE_RNG; drbg_fill_array() 1921 alg->cra_ctxsize = sizeof(struct drbg_state); drbg_fill_array() 1922 alg->cra_type = &crypto_rng_type; drbg_fill_array() 1923 alg->cra_module = THIS_MODULE; drbg_fill_array() 1924 alg->cra_init = drbg_kcapi_init; drbg_fill_array() 1925 alg->cra_exit = drbg_kcapi_cleanup; drbg_fill_array() 1926 alg->cra_u.rng.rng_make_random = drbg_kcapi_random; drbg_fill_array() 1927 alg->cra_u.rng.rng_reset = drbg_kcapi_reset; drbg_fill_array() 1928 alg->cra_u.rng.seedsize = 0; drbg_fill_array()
|
H A D | rmd128.c | 300 static struct shash_alg alg = { variable in typeref:struct:shash_alg 316 return crypto_register_shash(&alg); rmd128_mod_init() 321 crypto_unregister_shash(&alg); rmd128_mod_fini()
|
H A D | rmd256.c | 319 static struct shash_alg alg = { variable in typeref:struct:shash_alg 335 return crypto_register_shash(&alg); rmd256_mod_init() 340 crypto_unregister_shash(&alg); rmd256_mod_fini()
|
H A D | cast5_generic.c | 517 static struct crypto_alg alg = { variable in typeref:struct:crypto_alg 539 return crypto_register_alg(&alg); cast5_mod_init() 544 crypto_unregister_alg(&alg); cast5_mod_fini()
|
H A D | rmd160.c | 344 static struct shash_alg alg = { variable in typeref:struct:shash_alg 360 return crypto_register_shash(&alg); rmd160_mod_init() 365 crypto_unregister_shash(&alg); rmd160_mod_fini()
|
H A D | rmd320.c | 368 static struct shash_alg alg = { variable in typeref:struct:shash_alg 384 return crypto_register_shash(&alg); rmd320_mod_init() 389 crypto_unregister_shash(&alg); rmd320_mod_fini()
|
/linux-4.1.27/arch/x86/crypto/ |
H A D | fpu.c | 105 struct crypto_alg *alg; crypto_fpu_alloc() local 112 alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_BLKCIPHER, crypto_fpu_alloc() 114 if (IS_ERR(alg)) crypto_fpu_alloc() 115 return ERR_CAST(alg); crypto_fpu_alloc() 117 inst = crypto_alloc_instance("fpu", alg); crypto_fpu_alloc() 121 inst->alg.cra_flags = alg->cra_flags; crypto_fpu_alloc() 122 inst->alg.cra_priority = alg->cra_priority; crypto_fpu_alloc() 123 inst->alg.cra_blocksize = alg->cra_blocksize; crypto_fpu_alloc() 124 inst->alg.cra_alignmask = alg->cra_alignmask; crypto_fpu_alloc() 125 inst->alg.cra_type = alg->cra_type; crypto_fpu_alloc() 126 inst->alg.cra_blkcipher.ivsize = alg->cra_blkcipher.ivsize; crypto_fpu_alloc() 127 inst->alg.cra_blkcipher.min_keysize = alg->cra_blkcipher.min_keysize; crypto_fpu_alloc() 128 inst->alg.cra_blkcipher.max_keysize = alg->cra_blkcipher.max_keysize; crypto_fpu_alloc() 129 inst->alg.cra_ctxsize = sizeof(struct crypto_fpu_ctx); crypto_fpu_alloc() 130 inst->alg.cra_init = crypto_fpu_init_tfm; crypto_fpu_alloc() 131 inst->alg.cra_exit = crypto_fpu_exit_tfm; crypto_fpu_alloc() 132 inst->alg.cra_blkcipher.setkey = crypto_fpu_setkey; crypto_fpu_alloc() 133 inst->alg.cra_blkcipher.encrypt = crypto_fpu_encrypt; crypto_fpu_alloc() 134 inst->alg.cra_blkcipher.decrypt = crypto_fpu_decrypt; crypto_fpu_alloc() 137 crypto_mod_put(alg); crypto_fpu_alloc()
|
H A D | crct10dif-pclmul_glue.c | 107 static struct shash_alg alg = { variable in typeref:struct:shash_alg 135 return crypto_register_shash(&alg); crct10dif_intel_mod_init() 140 crypto_unregister_shash(&alg); crct10dif_intel_mod_fini()
|
H A D | salsa20_glue.c | 85 static struct crypto_alg alg = { variable in typeref:struct:crypto_alg 109 return crypto_register_alg(&alg); init() 114 crypto_unregister_alg(&alg); fini()
|
H A D | twofish_glue.c | 64 static struct crypto_alg alg = { variable in typeref:struct:crypto_alg 86 return crypto_register_alg(&alg); init() 91 crypto_unregister_alg(&alg); fini()
|
H A D | crc32c-intel_glue.c | 230 static struct shash_alg alg = { variable in typeref:struct:shash_alg 262 alg.update = crc32c_pcl_intel_update; crc32c_intel_mod_init() 263 alg.finup = crc32c_pcl_intel_finup; crc32c_intel_mod_init() 264 alg.digest = crc32c_pcl_intel_digest; crc32c_intel_mod_init() 268 return crypto_register_shash(&alg); crc32c_intel_mod_init() 273 crypto_unregister_shash(&alg); crc32c_intel_mod_fini()
|
H A D | crc32-pclmul_glue.c | 152 static struct shash_alg alg = { variable in typeref:struct:shash_alg 186 return crypto_register_shash(&alg); crc32_pclmul_mod_init() 191 crypto_unregister_shash(&alg); crc32_pclmul_mod_fini()
|
H A D | sha1_ssse3_glue.c | 106 static struct shash_alg alg = { variable in typeref:struct:shash_alg 180 return crypto_register_shash(&alg); sha1_ssse3_mod_init() 189 crypto_unregister_shash(&alg); sha1_ssse3_mod_fini()
|
H A D | aesni-intel_glue.c | 1218 WARN_ONCE(1, "__gcm-aes-aesni alg used in invalid context"); helper_rfc4106_encrypt() 1233 WARN_ONCE(1, "__gcm-aes-aesni alg used in invalid context"); helper_rfc4106_decrypt()
|
/linux-4.1.27/include/crypto/internal/ |
H A D | hash.h | 38 struct ahash_alg alg; member in struct:ahash_instance 42 struct shash_alg alg; member in struct:shash_instance 80 int crypto_register_ahash(struct ahash_alg *alg); 81 int crypto_unregister_ahash(struct ahash_alg *alg); 87 struct hash_alg_common *alg, 97 int crypto_register_shash(struct shash_alg *alg); 98 int crypto_unregister_shash(struct shash_alg *alg); 106 struct shash_alg *alg, 136 static inline struct ahash_alg *__crypto_ahash_alg(struct crypto_alg *alg) __crypto_ahash_alg() argument 138 return container_of(__crypto_hash_alg_common(alg), struct ahash_alg, __crypto_ahash_alg() 151 return container_of(&inst->alg.halg.base, struct crypto_instance, alg); ahash_crypto_instance() 157 return container_of(&inst->alg, struct ahash_instance, alg.halg.base); ahash_instance() 171 const char *name, struct crypto_alg *alg) ahash_alloc_instance() 173 return crypto_alloc_instance2(name, alg, ahash_instance_headroom()); ahash_alloc_instance() 208 return container_of(&inst->alg.base, struct crypto_instance, alg); shash_crypto_instance() 214 return container_of(__crypto_shash_alg(&inst->alg), shash_instance() 215 struct shash_instance, alg); shash_instance() 224 const char *name, struct crypto_alg *alg) shash_alloc_instance() 226 return crypto_alloc_instance2(name, alg, shash_alloc_instance() 227 sizeof(struct shash_alg) - sizeof(*alg)); shash_alloc_instance() 170 ahash_alloc_instance( const char *name, struct crypto_alg *alg) ahash_alloc_instance() argument 223 shash_alloc_instance( const char *name, struct crypto_alg *alg) shash_alloc_instance() argument
|
H A D | compress.h | 25 extern int crypto_register_pcomp(struct pcomp_alg *alg); 26 extern int crypto_unregister_pcomp(struct pcomp_alg *alg);
|
H A D | skcipher.h | 47 return spawn->base.alg; crypto_skcipher_spawn_alg() 60 const char *crypto_default_geniv(const struct crypto_alg *alg);
|
H A D | aead.h | 47 return spawn->base.alg; crypto_aead_spawn_alg()
|
/linux-4.1.27/drivers/staging/rtl8192e/ |
H A D | rtllib_crypt.c | 106 struct rtllib_crypto_alg *alg; rtllib_register_crypto_ops() local 111 alg = kzalloc(sizeof(*alg), GFP_KERNEL); rtllib_register_crypto_ops() 112 if (alg == NULL) rtllib_register_crypto_ops() 115 alg->ops = ops; rtllib_register_crypto_ops() 118 list_add(&alg->list, &hcrypt->algs); rtllib_register_crypto_ops() 139 struct rtllib_crypto_alg *alg = rtllib_unregister_crypto_ops() local 141 if (alg->ops == ops) { rtllib_unregister_crypto_ops() 142 list_del(&alg->list); rtllib_unregister_crypto_ops() 143 del_alg = alg; rtllib_unregister_crypto_ops() 171 struct rtllib_crypto_alg *alg = rtllib_get_crypto_ops() local 173 if (strcmp(alg->ops->name, name) == 0) { rtllib_get_crypto_ops() 174 found_alg = alg; rtllib_get_crypto_ops() 239 struct rtllib_crypto_alg *alg = rtllib_crypto_deinit() local 244 alg->ops->name); rtllib_crypto_deinit() 245 kfree(alg); rtllib_crypto_deinit()
|
H A D | rtllib_wx.c | 534 const char *alg, *module; rtllib_wx_set_encode_ext() local 554 if (idx != 0 && ext->alg != IW_ENCODE_ALG_WEP) rtllib_wx_set_encode_ext() 564 ext->alg == IW_ENCODE_ALG_NONE) { rtllib_wx_set_encode_ext() 581 switch (ext->alg) { rtllib_wx_set_encode_ext() 583 alg = "R-WEP"; rtllib_wx_set_encode_ext() 587 alg = "R-TKIP"; rtllib_wx_set_encode_ext() 591 alg = "R-CCMP"; rtllib_wx_set_encode_ext() 595 RTLLIB_DEBUG_WX("%s: unknown crypto alg %d\n", rtllib_wx_set_encode_ext() 596 dev->name, ext->alg); rtllib_wx_set_encode_ext() 600 netdev_info(dev, "alg name:%s\n", alg); rtllib_wx_set_encode_ext() 602 ops = lib80211_get_crypto_ops(alg); rtllib_wx_set_encode_ext() 609 ops = lib80211_get_crypto_ops(alg); rtllib_wx_set_encode_ext() 612 netdev_info(dev, "========>unknown crypto alg %d\n", ext->alg); rtllib_wx_set_encode_ext() 652 if (ext->alg != IW_ENCODE_ALG_NONE) { rtllib_wx_set_encode_ext() 655 if (ext->alg == IW_ENCODE_ALG_WEP) { rtllib_wx_set_encode_ext() 658 } else if (ext->alg == IW_ENCODE_ALG_TKIP) { rtllib_wx_set_encode_ext() 661 } else if (ext->alg == IW_ENCODE_ALG_CCMP) { rtllib_wx_set_encode_ext() 705 (ext->alg != IW_ENCODE_ALG_WEP)) rtllib_wx_get_encode_ext() 715 ext->alg = IW_ENCODE_ALG_NONE; rtllib_wx_get_encode_ext() 720 ext->alg = IW_ENCODE_ALG_WEP; rtllib_wx_get_encode_ext() 722 ext->alg = IW_ENCODE_ALG_TKIP; rtllib_wx_get_encode_ext() 724 ext->alg = IW_ENCODE_ALG_CCMP; rtllib_wx_get_encode_ext() 731 (ext->alg == IW_ENCODE_ALG_TKIP || rtllib_wx_get_encode_ext() 732 ext->alg == IW_ENCODE_ALG_CCMP)) rtllib_wx_get_encode_ext()
|
H A D | rtllib_softmac.c | 3367 param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0'; rtllib_wpa_set_encryption() 3384 if (strcmp(param->u.crypt.alg, "none") == 0) { rtllib_wpa_set_encryption() 3398 strcmp(param->u.crypt.alg, "R-TKIP")) rtllib_wpa_set_encryption() 3401 ops = lib80211_get_crypto_ops(param->u.crypt.alg); rtllib_wpa_set_encryption() 3402 if (ops == NULL && strcmp(param->u.crypt.alg, "R-WEP") == 0) { rtllib_wpa_set_encryption() 3404 ops = lib80211_get_crypto_ops(param->u.crypt.alg); rtllib_wpa_set_encryption() 3405 } else if (ops == NULL && strcmp(param->u.crypt.alg, "R-TKIP") == 0) { rtllib_wpa_set_encryption() 3407 ops = lib80211_get_crypto_ops(param->u.crypt.alg); rtllib_wpa_set_encryption() 3408 } else if (ops == NULL && strcmp(param->u.crypt.alg, "R-CCMP") == 0) { rtllib_wpa_set_encryption() 3410 ops = lib80211_get_crypto_ops(param->u.crypt.alg); rtllib_wpa_set_encryption() 3413 netdev_info(ieee->dev, "unknown crypto alg '%s'\n", rtllib_wpa_set_encryption() 3414 param->u.crypt.alg); rtllib_wpa_set_encryption() 3462 if (param->u.crypt.alg != NULL) { rtllib_wpa_set_encryption() 3469 if (strcmp(param->u.crypt.alg, "R-WEP") == 0) { rtllib_wpa_set_encryption() 3472 } else if (strcmp(param->u.crypt.alg, "R-TKIP") == 0) { rtllib_wpa_set_encryption() 3475 } else if (strcmp(param->u.crypt.alg, "R-CCMP") == 0) { rtllib_wpa_set_encryption()
|
H A D | rtllib_crypt_wep.c | 255 seq_printf(m, "key[%d] alg=WEP len=%d\n", wep->key_idx, wep->key_len); prism2_wep_print_stats()
|
H A D | rtllib_crypt_ccmp.c | 418 "key[%d] alg=CCMP key_set=%d tx_pn=%pM rx_pn=%pM format_errors=%d replays=%d decrypt_errors=%d\n", rtllib_ccmp_print_stats()
|
H A D | rtllib_crypt_tkip.c | 728 "key[%d] alg=TKIP key_set=%d tx_pn=%02x%02x%02x%02x%02x%02x rx_pn=%02x%02x%02x%02x%02x%02x replays=%d icv_errors=%d local_mic_failures=%d\n", rtllib_tkip_print_stats()
|
/linux-4.1.27/drivers/staging/rtl8192u/ieee80211/ |
H A D | ieee80211_crypt.c | 105 struct ieee80211_crypto_alg *alg; ieee80211_register_crypto_ops() local 110 alg = kzalloc(sizeof(*alg), GFP_KERNEL); ieee80211_register_crypto_ops() 111 if (alg == NULL) ieee80211_register_crypto_ops() 114 alg->ops = ops; ieee80211_register_crypto_ops() 117 list_add(&alg->list, &hcrypt->algs); ieee80211_register_crypto_ops() 137 struct ieee80211_crypto_alg *alg = ieee80211_unregister_crypto_ops() local 139 if (alg->ops == ops) { ieee80211_unregister_crypto_ops() 140 list_del(&alg->list); ieee80211_unregister_crypto_ops() 141 del_alg = alg; ieee80211_unregister_crypto_ops() 168 struct ieee80211_crypto_alg *alg = ieee80211_get_crypto_ops() local 170 if (strcmp(alg->ops->name, name) == 0) { ieee80211_get_crypto_ops() 171 found_alg = alg; ieee80211_get_crypto_ops() 231 struct ieee80211_crypto_alg *alg = ieee80211_crypto_deinit() local 235 alg->ops->name); ieee80211_crypto_deinit() 236 kfree(alg); ieee80211_crypto_deinit()
|
H A D | ieee80211_wx.c | 518 const char *alg, *module; ieee80211_wx_set_encode_ext() local 525 //printk("======>encoding flag:%x,ext flag:%x, ext alg:%d\n", encoding->flags,ext->ext_flags, ext->alg); ieee80211_wx_set_encode_ext() 541 //printk("not group key, flags:%x, ext->alg:%d\n", ext->ext_flags, ext->alg); ieee80211_wx_set_encode_ext() 542 if (idx != 0 && ext->alg != IW_ENCODE_ALG_WEP) ieee80211_wx_set_encode_ext() 554 ext->alg == IW_ENCODE_ALG_NONE) { ieee80211_wx_set_encode_ext() 576 switch (ext->alg) { ieee80211_wx_set_encode_ext() 578 alg = "WEP"; ieee80211_wx_set_encode_ext() 582 alg = "TKIP"; ieee80211_wx_set_encode_ext() 586 alg = "CCMP"; ieee80211_wx_set_encode_ext() 590 IEEE80211_DEBUG_WX("%s: unknown crypto alg %d\n", ieee80211_wx_set_encode_ext() 591 dev->name, ext->alg); ieee80211_wx_set_encode_ext() 595 printk("alg name:%s\n",alg); ieee80211_wx_set_encode_ext() 597 ops = ieee80211_get_crypto_ops(alg); ieee80211_wx_set_encode_ext() 600 ops = ieee80211_get_crypto_ops(alg); ieee80211_wx_set_encode_ext() 603 IEEE80211_DEBUG_WX("%s: unknown crypto alg %d\n", ieee80211_wx_set_encode_ext() 604 dev->name, ext->alg); ieee80211_wx_set_encode_ext() 605 printk("========>unknown crypto alg %d\n", ext->alg); ieee80211_wx_set_encode_ext() 648 if (ext->alg != IW_ENCODE_ALG_NONE) { ieee80211_wx_set_encode_ext() 652 if (ext->alg == IW_ENCODE_ALG_WEP) { ieee80211_wx_set_encode_ext() 656 } else if (ext->alg == IW_ENCODE_ALG_TKIP) { ieee80211_wx_set_encode_ext() 660 } else if (ext->alg == IW_ENCODE_ALG_CCMP) { ieee80211_wx_set_encode_ext() 705 ext->alg != IW_ENCODE_ALG_WEP) ieee80211_wx_get_encode_ext() 714 ext->alg = IW_ENCODE_ALG_NONE; ieee80211_wx_get_encode_ext() 719 ext->alg = IW_ENCODE_ALG_WEP; ieee80211_wx_get_encode_ext() 721 ext->alg = IW_ENCODE_ALG_TKIP; ieee80211_wx_get_encode_ext() 723 ext->alg = IW_ENCODE_ALG_CCMP; ieee80211_wx_get_encode_ext() 729 (ext->alg == IW_ENCODE_ALG_TKIP || ieee80211_wx_get_encode_ext() 730 ext->alg == IW_ENCODE_ALG_CCMP)) ieee80211_wx_get_encode_ext()
|
H A D | ieee80211_softmac.c | 2970 param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0'; ieee80211_wpa_set_encryption() 2987 if (strcmp(param->u.crypt.alg, "none") == 0) { ieee80211_wpa_set_encryption() 3005 strcmp(param->u.crypt.alg, "TKIP")) ieee80211_wpa_set_encryption() 3008 ops = ieee80211_get_crypto_ops(param->u.crypt.alg); ieee80211_wpa_set_encryption() 3009 if (ops == NULL && strcmp(param->u.crypt.alg, "WEP") == 0) { ieee80211_wpa_set_encryption() 3011 ops = ieee80211_get_crypto_ops(param->u.crypt.alg); ieee80211_wpa_set_encryption() 3013 } else if (ops == NULL && strcmp(param->u.crypt.alg, "TKIP") == 0) { ieee80211_wpa_set_encryption() 3015 ops = ieee80211_get_crypto_ops(param->u.crypt.alg); ieee80211_wpa_set_encryption() 3016 } else if (ops == NULL && strcmp(param->u.crypt.alg, "CCMP") == 0) { ieee80211_wpa_set_encryption() 3018 ops = ieee80211_get_crypto_ops(param->u.crypt.alg); ieee80211_wpa_set_encryption() 3021 printk("unknown crypto alg '%s'\n", param->u.crypt.alg); ieee80211_wpa_set_encryption() 3070 if (param->u.crypt.alg != NULL) { ieee80211_wpa_set_encryption() 3077 if (strcmp(param->u.crypt.alg, "WEP") == 0) { ieee80211_wpa_set_encryption() 3080 } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) { ieee80211_wpa_set_encryption() 3083 } else if (strcmp(param->u.crypt.alg, "CCMP") == 0) { ieee80211_wpa_set_encryption()
|
H A D | ieee80211_crypt_wep.c | 262 p += sprintf(p, "key[%d] alg=WEP len=%d\n", prism2_wep_print_stats()
|
H A D | ieee80211_crypt_ccmp.c | 432 p += sprintf(p, "key[%d] alg=CCMP key_set=%d " ieee80211_ccmp_print_stats()
|
H A D | ieee80211_crypt_tkip.c | 723 p += sprintf(p, "key[%d] alg=TKIP key_set=%d " ieee80211_tkip_print_stats()
|
/linux-4.1.27/net/wireless/ |
H A D | lib80211.c | 167 struct lib80211_crypto_alg *alg; lib80211_register_crypto_ops() local 169 alg = kzalloc(sizeof(*alg), GFP_KERNEL); lib80211_register_crypto_ops() 170 if (alg == NULL) lib80211_register_crypto_ops() 173 alg->ops = ops; lib80211_register_crypto_ops() 176 list_add(&alg->list, &lib80211_crypto_algs); lib80211_register_crypto_ops() 188 struct lib80211_crypto_alg *alg; lib80211_unregister_crypto_ops() local 192 list_for_each_entry(alg, &lib80211_crypto_algs, list) { lib80211_unregister_crypto_ops() 193 if (alg->ops == ops) lib80211_unregister_crypto_ops() 202 list_del(&alg->list); lib80211_unregister_crypto_ops() 204 kfree(alg); lib80211_unregister_crypto_ops() 211 struct lib80211_crypto_alg *alg; lib80211_get_crypto_ops() local 215 list_for_each_entry(alg, &lib80211_crypto_algs, list) { lib80211_get_crypto_ops() 216 if (strcmp(alg->ops->name, name) == 0) lib80211_get_crypto_ops() 224 return alg->ops; lib80211_get_crypto_ops()
|
H A D | lib80211_crypt_wep.c | 259 seq_printf(m, "key[%d] alg=WEP len=%d\n", wep->key_idx, wep->key_len); lib80211_wep_print_stats()
|
H A D | lib80211_crypt_ccmp.c | 438 "key[%d] alg=CCMP key_set=%d " lib80211_ccmp_print_stats()
|
H A D | lib80211_crypt_tkip.c | 710 "key[%d] alg=TKIP key_set=%d " lib80211_tkip_print_stats()
|
/linux-4.1.27/drivers/crypto/ccp/ |
H A D | ccp-crypto-aes-xts.c | 229 struct crypto_alg *alg; ccp_register_aes_xts_alg() local 238 alg = &ccp_alg->alg; ccp_register_aes_xts_alg() 240 snprintf(alg->cra_name, CRYPTO_MAX_ALG_NAME, "%s", def->name); ccp_register_aes_xts_alg() 241 snprintf(alg->cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s", ccp_register_aes_xts_alg() 243 alg->cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC | ccp_register_aes_xts_alg() 246 alg->cra_blocksize = AES_BLOCK_SIZE; ccp_register_aes_xts_alg() 247 alg->cra_ctxsize = sizeof(struct ccp_ctx); ccp_register_aes_xts_alg() 248 alg->cra_priority = CCP_CRA_PRIORITY; ccp_register_aes_xts_alg() 249 alg->cra_type = &crypto_ablkcipher_type; ccp_register_aes_xts_alg() 250 alg->cra_ablkcipher.setkey = ccp_aes_xts_setkey; ccp_register_aes_xts_alg() 251 alg->cra_ablkcipher.encrypt = ccp_aes_xts_encrypt; ccp_register_aes_xts_alg() 252 alg->cra_ablkcipher.decrypt = ccp_aes_xts_decrypt; ccp_register_aes_xts_alg() 253 alg->cra_ablkcipher.min_keysize = AES_MIN_KEY_SIZE * 2; ccp_register_aes_xts_alg() 254 alg->cra_ablkcipher.max_keysize = AES_MAX_KEY_SIZE * 2; ccp_register_aes_xts_alg() 255 alg->cra_ablkcipher.ivsize = AES_BLOCK_SIZE; ccp_register_aes_xts_alg() 256 alg->cra_init = ccp_aes_xts_cra_init; ccp_register_aes_xts_alg() 257 alg->cra_exit = ccp_aes_xts_cra_exit; ccp_register_aes_xts_alg() 258 alg->cra_module = THIS_MODULE; ccp_register_aes_xts_alg() 260 ret = crypto_register_alg(alg); ccp_register_aes_xts_alg() 263 alg->cra_name, ret); ccp_register_aes_xts_alg()
|
H A D | ccp-crypto-sha.c | 152 struct ccp_crypto_ahash_alg *alg = ccp_sha_init() local 159 rctx->type = alg->type; ccp_sha_init() 308 struct ccp_crypto_ahash_alg *alg = ccp_crypto_ahash_alg(tfm); ccp_hmac_sha_cra_init() local 311 hmac_tfm = crypto_alloc_shash(alg->child_alg, 0, 0); ccp_hmac_sha_cra_init() 314 alg->child_alg); ccp_hmac_sha_cra_init() 370 struct ahash_alg *alg; ccp_register_hmac_alg() local 385 alg = &ccp_alg->alg; ccp_register_hmac_alg() 386 alg->setkey = ccp_sha_setkey; ccp_register_hmac_alg() 388 halg = &alg->halg; ccp_register_hmac_alg() 397 ret = crypto_register_ahash(alg); ccp_register_hmac_alg() 414 struct ahash_alg *alg; ccp_register_sha_alg() local 427 alg = &ccp_alg->alg; ccp_register_sha_alg() 428 alg->init = ccp_sha_init; ccp_register_sha_alg() 429 alg->update = ccp_sha_update; ccp_register_sha_alg() 430 alg->final = ccp_sha_final; ccp_register_sha_alg() 431 alg->finup = ccp_sha_finup; ccp_register_sha_alg() 432 alg->digest = ccp_sha_digest; ccp_register_sha_alg() 433 alg->export = ccp_sha_export; ccp_register_sha_alg() 434 alg->import = ccp_sha_import; ccp_register_sha_alg() 436 halg = &alg->halg; ccp_register_sha_alg() 455 ret = crypto_register_ahash(alg); ccp_register_sha_alg()
|
H A D | ccp-crypto.h | 34 struct crypto_alg alg; member in struct:ccp_crypto_ablkcipher_alg 47 struct ahash_alg alg; member in struct:ccp_crypto_ahash_alg 53 struct crypto_alg *alg = tfm->__crt_alg; ccp_crypto_ablkcipher_alg() local 55 return container_of(alg, struct ccp_crypto_ablkcipher_alg, alg); ccp_crypto_ablkcipher_alg() 61 struct crypto_alg *alg = tfm->__crt_alg; ccp_crypto_ahash_alg() local 64 ahash_alg = container_of(alg, struct ahash_alg, halg.base); ccp_crypto_ahash_alg() 66 return container_of(ahash_alg, struct ccp_crypto_ahash_alg, alg); ccp_crypto_ahash_alg()
|
H A D | ccp-crypto-aes.c | 44 struct ccp_crypto_ablkcipher_alg *alg = ccp_aes_setkey() local 61 ctx->u.aes.mode = alg->mode; ccp_aes_setkey() 324 struct crypto_alg *alg; ccp_register_aes_alg() local 336 alg = &ccp_alg->alg; ccp_register_aes_alg() 337 *alg = *def->alg_defaults; ccp_register_aes_alg() 338 snprintf(alg->cra_name, CRYPTO_MAX_ALG_NAME, "%s", def->name); ccp_register_aes_alg() 339 snprintf(alg->cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s", ccp_register_aes_alg() 341 alg->cra_blocksize = def->blocksize; ccp_register_aes_alg() 342 alg->cra_ablkcipher.ivsize = def->ivsize; ccp_register_aes_alg() 344 ret = crypto_register_alg(alg); ccp_register_aes_alg() 347 alg->cra_name, ret); ccp_register_aes_alg()
|
H A D | ccp-crypto-aes-cmac.c | 245 struct ccp_crypto_ahash_alg *alg = ccp_aes_cmac_setkey() local 266 ctx->u.aes.mode = alg->mode; ccp_aes_cmac_setkey() 355 struct ahash_alg *alg; ccp_register_aes_cmac_algs() local 367 alg = &ccp_alg->alg; ccp_register_aes_cmac_algs() 368 alg->init = ccp_aes_cmac_init; ccp_register_aes_cmac_algs() 369 alg->update = ccp_aes_cmac_update; ccp_register_aes_cmac_algs() 370 alg->final = ccp_aes_cmac_final; ccp_register_aes_cmac_algs() 371 alg->finup = ccp_aes_cmac_finup; ccp_register_aes_cmac_algs() 372 alg->digest = ccp_aes_cmac_digest; ccp_register_aes_cmac_algs() 373 alg->export = ccp_aes_cmac_export; ccp_register_aes_cmac_algs() 374 alg->import = ccp_aes_cmac_import; ccp_register_aes_cmac_algs() 375 alg->setkey = ccp_aes_cmac_setkey; ccp_register_aes_cmac_algs() 377 halg = &alg->halg; ccp_register_aes_cmac_algs() 395 ret = crypto_register_ahash(alg); ccp_register_aes_cmac_algs()
|
H A D | ccp-crypto-main.c | 353 crypto_unregister_ahash(&ahash_alg->alg); ccp_unregister_algs() 359 crypto_unregister_alg(&ablk_alg->alg); ccp_unregister_algs()
|
/linux-4.1.27/drivers/crypto/qce/ |
H A D | ablkcipher.c | 350 struct crypto_alg *alg; qce_ablkcipher_register_one() local 357 alg = &tmpl->alg.crypto; qce_ablkcipher_register_one() 359 snprintf(alg->cra_name, CRYPTO_MAX_ALG_NAME, "%s", def->name); qce_ablkcipher_register_one() 360 snprintf(alg->cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s", qce_ablkcipher_register_one() 363 alg->cra_blocksize = def->blocksize; qce_ablkcipher_register_one() 364 alg->cra_ablkcipher.ivsize = def->ivsize; qce_ablkcipher_register_one() 365 alg->cra_ablkcipher.min_keysize = def->min_keysize; qce_ablkcipher_register_one() 366 alg->cra_ablkcipher.max_keysize = def->max_keysize; qce_ablkcipher_register_one() 367 alg->cra_ablkcipher.setkey = qce_ablkcipher_setkey; qce_ablkcipher_register_one() 368 alg->cra_ablkcipher.encrypt = qce_ablkcipher_encrypt; qce_ablkcipher_register_one() 369 alg->cra_ablkcipher.decrypt = qce_ablkcipher_decrypt; qce_ablkcipher_register_one() 371 alg->cra_priority = 300; qce_ablkcipher_register_one() 372 alg->cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC | qce_ablkcipher_register_one() 374 alg->cra_ctxsize = sizeof(struct qce_cipher_ctx); qce_ablkcipher_register_one() 375 alg->cra_alignmask = 0; qce_ablkcipher_register_one() 376 alg->cra_type = &crypto_ablkcipher_type; qce_ablkcipher_register_one() 377 alg->cra_module = THIS_MODULE; qce_ablkcipher_register_one() 378 alg->cra_init = qce_ablkcipher_init; qce_ablkcipher_register_one() 379 alg->cra_exit = qce_ablkcipher_exit; qce_ablkcipher_register_one() 380 INIT_LIST_HEAD(&alg->cra_list); qce_ablkcipher_register_one() 387 ret = crypto_register_alg(alg); qce_ablkcipher_register_one() 390 dev_err(qce->dev, "%s registration failed\n", alg->cra_name); qce_ablkcipher_register_one() 395 dev_dbg(qce->dev, "%s is registered\n", alg->cra_name); qce_ablkcipher_register_one() 404 crypto_unregister_alg(&tmpl->alg.crypto); qce_ablkcipher_unregister()
|
H A D | cipher.h | 62 struct crypto_alg *alg = tfm->__crt_alg; to_cipher_tmpl() local 63 return container_of(alg, struct qce_alg_template, alg.crypto); to_cipher_tmpl()
|
H A D | sha.h | 73 struct ahash_alg *alg = container_of(crypto_hash_alg_common(ahash), to_ahash_tmpl() local 76 return container_of(alg, struct qce_alg_template, alg.ahash); to_ahash_tmpl()
|
H A D | sha.c | 503 struct ahash_alg *alg; qce_ahash_register_one() local 513 alg = &tmpl->alg.ahash; qce_ahash_register_one() 514 alg->init = qce_ahash_init; qce_ahash_register_one() 515 alg->update = qce_ahash_update; qce_ahash_register_one() 516 alg->final = qce_ahash_final; qce_ahash_register_one() 517 alg->digest = qce_ahash_digest; qce_ahash_register_one() 518 alg->export = qce_ahash_export; qce_ahash_register_one() 519 alg->import = qce_ahash_import; qce_ahash_register_one() 521 alg->setkey = qce_ahash_hmac_setkey; qce_ahash_register_one() 522 alg->halg.digestsize = def->digestsize; qce_ahash_register_one() 523 alg->halg.statesize = def->statesize; qce_ahash_register_one() 525 base = &alg->halg.base; qce_ahash_register_one() 544 ret = crypto_register_ahash(alg); qce_ahash_register_one() 561 crypto_unregister_ahash(&tmpl->alg.ahash); qce_ahash_unregister()
|
H A D | common.h | 92 } alg; member in struct:qce_alg_template
|
/linux-4.1.27/drivers/crypto/ |
H A D | picoxcell_crypto.c | 141 struct crypto_alg alg; member in struct:spacc_alg 182 static inline struct spacc_alg *to_spacc_alg(struct crypto_alg *alg) to_spacc_alg() argument 184 return alg ? container_of(alg, struct spacc_alg, alg) : NULL; to_spacc_alg() 408 struct spacc_alg *alg = to_spacc_alg(req->req->tfm->__crt_alg); spacc_aead_free_ddts() local 411 unsigned ivsize = alg->alg.cra_aead.ivsize; spacc_aead_free_ddts() 497 struct spacc_alg *alg = to_spacc_alg(tfm->base.__crt_alg); spacc_aead_setkey() local 510 if ((alg->ctrl_default & SPACC_CRYPTO_ALG_MASK) == spacc_aead_setkey() 548 struct crypto_alg *alg = req->req->tfm->__crt_alg; spacc_aead_need_fallback() local 549 struct spacc_alg *spacc_alg = to_spacc_alg(alg); spacc_aead_need_fallback() 599 struct crypto_alg *alg = req->req->tfm->__crt_alg; spacc_aead_submit() local 600 struct spacc_alg *spacc_alg = to_spacc_alg(alg); spacc_aead_submit() 608 ctx->cipher_key_len, aead_req->iv, alg->cra_aead.ivsize, spacc_aead_submit() 684 struct crypto_alg *alg = req->base.tfm->__crt_alg; spacc_aead_setup() local 685 struct spacc_engine *engine = to_spacc_alg(alg)->engine; spacc_aead_setup() 732 struct spacc_alg *alg = to_spacc_alg(tfm->__crt_alg); spacc_aead_encrypt() local 734 return spacc_aead_setup(req, NULL, alg->type, 1); spacc_aead_encrypt() 742 struct spacc_alg *alg = to_spacc_alg(tfm->base.__crt_alg); spacc_aead_givencrypt() local 755 return spacc_aead_setup(&req->areq, req->giv, alg->type, 1); spacc_aead_givencrypt() 762 struct spacc_alg *alg = to_spacc_alg(tfm->__crt_alg); spacc_aead_decrypt() local 764 return spacc_aead_setup(req, NULL, alg->type, 0); spacc_aead_decrypt() 774 struct crypto_alg *alg = tfm->__crt_alg; spacc_aead_cra_init() local 775 struct spacc_alg *spacc_alg = to_spacc_alg(alg); spacc_aead_cra_init() 780 ctx->sw_cipher = crypto_alloc_aead(alg->cra_name, 0, spacc_aead_cra_init() 785 alg->cra_name); spacc_aead_cra_init() 914 struct crypto_alg *alg = req->req->tfm->__crt_alg; spacc_ablk_need_fallback() local 915 struct spacc_alg *spacc_alg = to_spacc_alg(alg); spacc_ablk_need_fallback() 947 struct crypto_alg *alg = req->req->tfm->__crt_alg; spacc_ablk_submit() local 948 struct spacc_alg *spacc_alg = to_spacc_alg(alg); spacc_ablk_submit() 953 ctx->key_len, ablk_req->info, alg->cra_ablkcipher.ivsize, spacc_ablk_submit() 1003 struct crypto_alg *alg = req->base.tfm->__crt_alg; spacc_ablk_setup() local 1004 struct spacc_engine *engine = to_spacc_alg(alg)->engine; spacc_ablk_setup() 1080 struct crypto_alg *alg = tfm->__crt_alg; spacc_ablk_cra_init() local 1081 struct spacc_alg *spacc_alg = to_spacc_alg(alg); spacc_ablk_cra_init() 1086 if (alg->cra_flags & CRYPTO_ALG_NEED_FALLBACK) { spacc_ablk_cra_init() 1087 ctx->sw_cipher = crypto_alloc_ablkcipher(alg->cra_name, 0, spacc_ablk_cra_init() 1091 alg->cra_name); spacc_ablk_cra_init() 1116 struct spacc_alg *alg = to_spacc_alg(tfm->__crt_alg); spacc_ablk_encrypt() local 1118 return spacc_ablk_setup(req, alg->type, 1); spacc_ablk_encrypt() 1125 struct spacc_alg *alg = to_spacc_alg(tfm->__crt_alg); spacc_ablk_decrypt() local 1127 return spacc_ablk_setup(req, alg->type, 0); spacc_ablk_decrypt() 1204 struct crypto_alg *alg = req->req->tfm->__crt_alg; spacc_req_submit() local 1206 if (CRYPTO_ALG_TYPE_AEAD == (CRYPTO_ALG_TYPE_MASK & alg->cra_flags)) spacc_req_submit() 1304 .alg = { 1332 .alg = { 1358 .alg = { 1385 .alg = { 1411 .alg = { 1438 .alg = { 1465 .alg = { 1495 .alg = { 1524 .alg = { 1553 .alg = { 1583 .alg = { 1612 .alg = { 1644 .alg = { 1803 err = crypto_register_alg(&engine->algs[i].alg); spacc_probe() 1810 dev_err(engine->dev, "failed to register alg \"%s\"\n", spacc_probe() 1811 engine->algs[i].alg.cra_name); spacc_probe() 1813 dev_dbg(engine->dev, "registered alg \"%s\"\n", spacc_probe() 1814 engine->algs[i].alg.cra_name); spacc_probe() 1822 struct spacc_alg *alg, *next; spacc_remove() local 1828 list_for_each_entry_safe(alg, next, &engine->registered_algs, entry) { spacc_remove() 1829 list_del(&alg->entry); spacc_remove() 1830 crypto_unregister_alg(&alg->alg); spacc_remove()
|
H A D | n2_core.c | 250 struct ahash_alg alg; member in struct:n2_ahash_alg 255 struct crypto_alg *alg = tfm->__crt_alg; n2_ahash_alg() local 258 ahash_alg = container_of(alg, struct ahash_alg, halg.base); n2_ahash_alg() 260 return container_of(ahash_alg, struct n2_ahash_alg, alg); n2_ahash_alg() 270 struct crypto_alg *alg = tfm->__crt_alg; n2_hmac_alg() local 273 ahash_alg = container_of(alg, struct ahash_alg, halg.base); n2_hmac_alg() 275 return container_of(ahash_alg, struct n2_hmac_alg, derived.alg); n2_hmac_alg() 700 struct crypto_alg alg; member in struct:n2_cipher_alg 705 struct crypto_alg *alg = tfm->__crt_alg; n2_cipher_alg() local 707 return container_of(alg, struct n2_cipher_alg, alg); n2_cipher_alg() 1362 struct n2_ahash_alg *alg, *alg_tmp; __n2_unregister_algs() local 1366 crypto_unregister_alg(&cipher->alg); __n2_unregister_algs() 1371 crypto_unregister_ahash(&hmac->derived.alg); __n2_unregister_algs() 1375 list_for_each_entry_safe(alg, alg_tmp, &ahash_algs, entry) { __n2_unregister_algs() 1376 crypto_unregister_ahash(&alg->alg); __n2_unregister_algs() 1377 list_del(&alg->entry); __n2_unregister_algs() 1378 kfree(alg); __n2_unregister_algs() 1391 struct crypto_alg *alg; __n2_register_one_cipher() local 1397 alg = &p->alg; __n2_register_one_cipher() 1399 snprintf(alg->cra_name, CRYPTO_MAX_ALG_NAME, "%s", tmpl->name); __n2_register_one_cipher() 1400 snprintf(alg->cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s-n2", tmpl->drv_name); __n2_register_one_cipher() 1401 alg->cra_priority = N2_CRA_PRIORITY; __n2_register_one_cipher() 1402 alg->cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | __n2_register_one_cipher() 1404 alg->cra_blocksize = tmpl->block_size; __n2_register_one_cipher() 1406 alg->cra_ctxsize = sizeof(struct n2_cipher_context); __n2_register_one_cipher() 1407 alg->cra_type = &crypto_ablkcipher_type; __n2_register_one_cipher() 1408 alg->cra_u.ablkcipher = tmpl->ablkcipher; __n2_register_one_cipher() 1409 alg->cra_init = n2_cipher_cra_init; __n2_register_one_cipher() 1410 alg->cra_module = THIS_MODULE; __n2_register_one_cipher() 1413 err = crypto_register_alg(alg); __n2_register_one_cipher() 1415 pr_err("%s alg registration failed\n", alg->cra_name); __n2_register_one_cipher() 1419 pr_info("%s alg registered\n", alg->cra_name); __n2_register_one_cipher() 1434 p->child_alg = n2ahash->alg.halg.base.cra_name; __n2_register_one_hmac() 1438 ahash = &p->derived.alg; __n2_register_one_hmac() 1453 pr_err("%s alg registration failed\n", base->cra_name); __n2_register_one_hmac() 1457 pr_info("%s alg registered\n", base->cra_name); __n2_register_one_hmac() 1480 ahash = &p->alg; __n2_register_one_ahash() 1506 pr_err("%s alg registration failed\n", base->cra_name); __n2_register_one_ahash() 1510 pr_info("%s alg registered\n", base->cra_name); __n2_register_one_ahash()
|
H A D | talitos.c | 634 * crypto alg 1914 } alg; member in struct:talitos_alg_template 1921 .alg.crypto = { 1940 .alg.crypto = { 1960 .alg.crypto = { 1979 .alg.crypto = { 1999 .alg.crypto = { 2018 .alg.crypto = { 2038 .alg.crypto = { 2057 .alg.crypto = { 2077 .alg.crypto = { 2096 .alg.crypto = { 2116 .alg.crypto = { 2135 .alg.crypto = { 2156 .alg.crypto = { 2173 .alg.crypto = { 2192 .alg.hash = { 2207 .alg.hash = { 2222 .alg.hash = { 2237 .alg.hash = { 2252 .alg.hash = { 2267 .alg.hash = { 2282 .alg.hash = { 2297 .alg.hash = { 2312 .alg.hash = { 2327 .alg.hash = { 2342 .alg.hash = { 2357 .alg.hash = { 2381 struct crypto_alg *alg = tfm->__crt_alg; talitos_cra_init() local 2386 if ((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_AHASH) talitos_cra_init() 2387 talitos_alg = container_of(__crypto_ahash_alg(alg), talitos_cra_init() 2389 algt.alg.hash); talitos_cra_init() 2391 talitos_alg = container_of(alg, struct talitos_crypto_alg, talitos_cra_init() 2392 algt.alg.crypto); talitos_cra_init() 2437 * given the alg's descriptor header template, determine whether descriptor 2467 crypto_unregister_alg(&t_alg->algt.alg.crypto); talitos_remove() 2470 crypto_unregister_ahash(&t_alg->algt.alg.hash); talitos_remove() 2508 struct crypto_alg *alg; talitos_alg_alloc() local 2518 alg = &t_alg->algt.alg.crypto; talitos_alg_alloc() 2519 alg->cra_init = talitos_cra_init; talitos_alg_alloc() 2520 alg->cra_type = &crypto_ablkcipher_type; talitos_alg_alloc() 2521 alg->cra_ablkcipher.setkey = ablkcipher_setkey; talitos_alg_alloc() 2522 alg->cra_ablkcipher.encrypt = ablkcipher_encrypt; talitos_alg_alloc() 2523 alg->cra_ablkcipher.decrypt = ablkcipher_decrypt; talitos_alg_alloc() 2524 alg->cra_ablkcipher.geniv = "eseqiv"; talitos_alg_alloc() 2527 alg = &t_alg->algt.alg.crypto; talitos_alg_alloc() 2528 alg->cra_init = talitos_cra_init_aead; talitos_alg_alloc() 2529 alg->cra_type = &crypto_aead_type; talitos_alg_alloc() 2530 alg->cra_aead.setkey = aead_setkey; talitos_alg_alloc() 2531 alg->cra_aead.setauthsize = aead_setauthsize; talitos_alg_alloc() 2532 alg->cra_aead.encrypt = aead_encrypt; talitos_alg_alloc() 2533 alg->cra_aead.decrypt = aead_decrypt; talitos_alg_alloc() 2534 alg->cra_aead.givencrypt = aead_givencrypt; talitos_alg_alloc() 2535 alg->cra_aead.geniv = "<built-in>"; talitos_alg_alloc() 2538 alg = &t_alg->algt.alg.hash.halg.base; talitos_alg_alloc() 2539 alg->cra_init = talitos_cra_init_ahash; talitos_alg_alloc() 2540 alg->cra_type = &crypto_ahash_type; talitos_alg_alloc() 2541 t_alg->algt.alg.hash.init = ahash_init; talitos_alg_alloc() 2542 t_alg->algt.alg.hash.update = ahash_update; talitos_alg_alloc() 2543 t_alg->algt.alg.hash.final = ahash_final; talitos_alg_alloc() 2544 t_alg->algt.alg.hash.finup = ahash_finup; talitos_alg_alloc() 2545 t_alg->algt.alg.hash.digest = ahash_digest; talitos_alg_alloc() 2546 t_alg->algt.alg.hash.setkey = ahash_setkey; talitos_alg_alloc() 2549 !strncmp(alg->cra_name, "hmac", 4)) { talitos_alg_alloc() 2554 (!strcmp(alg->cra_name, "sha224") || talitos_alg_alloc() 2555 !strcmp(alg->cra_name, "hmac(sha224)"))) { talitos_alg_alloc() 2556 t_alg->algt.alg.hash.init = ahash_init_sha224_swinit; talitos_alg_alloc() 2569 alg->cra_module = THIS_MODULE; talitos_alg_alloc() 2570 alg->cra_priority = TALITOS_CRA_PRIORITY; talitos_alg_alloc() 2571 alg->cra_alignmask = 0; talitos_alg_alloc() 2572 alg->cra_ctxsize = sizeof(struct talitos_ctx); talitos_alg_alloc() 2573 alg->cra_flags |= CRYPTO_ALG_KERN_DRIVER_ONLY; talitos_alg_alloc() 2768 &t_alg->algt.alg.crypto); talitos_probe() 2769 name = t_alg->algt.alg.crypto.cra_driver_name; talitos_probe() 2773 &t_alg->algt.alg.hash); talitos_probe() 2775 t_alg->algt.alg.hash.halg.base.cra_driver_name; talitos_probe() 2779 dev_err(dev, "%s alg registration failed\n", talitos_probe()
|
H A D | hifn_795x.c | 633 struct crypto_alg alg; member in struct:hifn_crypto_alg 663 #define crypto_alg_to_hifn(a) container_of(a, struct hifn_crypto_alg, alg) 2474 struct crypto_alg *alg = tfm->__crt_alg; hifn_cra_init() local 2475 struct hifn_crypto_alg *ha = crypto_alg_to_hifn(alg); hifn_cra_init() 2485 struct hifn_crypto_alg *alg; hifn_alg_alloc() local 2488 alg = kzalloc(sizeof(struct hifn_crypto_alg), GFP_KERNEL); hifn_alg_alloc() 2489 if (!alg) hifn_alg_alloc() 2492 snprintf(alg->alg.cra_name, CRYPTO_MAX_ALG_NAME, "%s", t->name); hifn_alg_alloc() 2493 snprintf(alg->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s-%s", hifn_alg_alloc() 2496 alg->alg.cra_priority = 300; hifn_alg_alloc() 2497 alg->alg.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | hifn_alg_alloc() 2499 alg->alg.cra_blocksize = t->bsize; hifn_alg_alloc() 2500 alg->alg.cra_ctxsize = sizeof(struct hifn_context); hifn_alg_alloc() 2501 alg->alg.cra_alignmask = 0; hifn_alg_alloc() 2502 alg->alg.cra_type = &crypto_ablkcipher_type; hifn_alg_alloc() 2503 alg->alg.cra_module = THIS_MODULE; hifn_alg_alloc() 2504 alg->alg.cra_u.ablkcipher = t->ablkcipher; hifn_alg_alloc() 2505 alg->alg.cra_init = hifn_cra_init; hifn_alg_alloc() 2507 alg->dev = dev; hifn_alg_alloc() 2509 list_add_tail(&alg->entry, &dev->alg_list); hifn_alg_alloc() 2511 err = crypto_register_alg(&alg->alg); hifn_alg_alloc() 2513 list_del(&alg->entry); hifn_alg_alloc() 2514 kfree(alg); hifn_alg_alloc() 2526 crypto_unregister_alg(&a->alg); hifn_unregister_alg()
|
H A D | mxs-dcp.c | 83 uint32_t alg; member in struct:dcp_async_ctx 532 desc->control1 = actx->alg; mxs_dcp_run_sha() 690 actx->alg = MXS_DCP_CONTROL1_HASH_SELECT_SHA1; dcp_sha_init() 692 actx->alg = MXS_DCP_CONTROL1_HASH_SELECT_SHA256; dcp_sha_init()
|
/linux-4.1.27/net/ceph/crush/ |
H A D | crush.c | 13 const char *crush_bucket_alg_name(int alg) crush_bucket_alg_name() argument 15 switch (alg) { crush_bucket_alg_name() 35 switch (b->alg) { crush_get_bucket_item_weight() 93 switch (b->alg) { crush_destroy_bucket()
|
H A D | mapper.c | 341 switch (in->alg) { crush_bucket_choose() 358 dprintk("unknown bucket %d alg %d\n", in->id, in->alg); crush_bucket_choose() 632 if (in->alg == CRUSH_BUCKET_UNIFORM && crush_choose_indep()
|
/linux-4.1.27/arch/arm/crypto/ |
H A D | sha1-ce-glue.c | 66 static struct shash_alg alg = { variable in typeref:struct:shash_alg 87 return crypto_register_shash(&alg); sha1_ce_mod_init() 92 crypto_unregister_shash(&alg); sha1_ce_mod_fini()
|
H A D | sha1_glue.c | 59 static struct shash_alg alg = { variable in typeref:struct:shash_alg 79 return crypto_register_shash(&alg); sha1_mod_init() 85 crypto_unregister_shash(&alg); sha1_mod_fini()
|
H A D | sha1_neon_glue.c | 75 static struct shash_alg alg = { variable in typeref:struct:shash_alg 97 return crypto_register_shash(&alg); sha1_neon_mod_init() 102 crypto_unregister_shash(&alg); sha1_neon_mod_fini()
|
/linux-4.1.27/drivers/net/wireless/ipw2x00/ |
H A D | libipw_wx.c | 527 const char *alg, *module; libipw_wx_set_encodeext() local 548 if (idx != 0 && ext->alg != IW_ENCODE_ALG_WEP) libipw_wx_set_encodeext() 558 ext->alg == IW_ENCODE_ALG_NONE) { libipw_wx_set_encodeext() 583 switch (ext->alg) { libipw_wx_set_encodeext() 585 alg = "WEP"; libipw_wx_set_encodeext() 589 alg = "TKIP"; libipw_wx_set_encodeext() 593 alg = "CCMP"; libipw_wx_set_encodeext() 597 LIBIPW_DEBUG_WX("%s: unknown crypto alg %d\n", libipw_wx_set_encodeext() 598 dev->name, ext->alg); libipw_wx_set_encodeext() 603 ops = lib80211_get_crypto_ops(alg); libipw_wx_set_encodeext() 606 ops = lib80211_get_crypto_ops(alg); libipw_wx_set_encodeext() 609 LIBIPW_DEBUG_WX("%s: unknown crypto alg %d\n", libipw_wx_set_encodeext() 610 dev->name, ext->alg); libipw_wx_set_encodeext() 651 if (ext->alg != IW_ENCODE_ALG_NONE) { libipw_wx_set_encodeext() 655 if (ext->alg == IW_ENCODE_ALG_WEP) { libipw_wx_set_encodeext() 659 } else if (ext->alg == IW_ENCODE_ALG_TKIP) { libipw_wx_set_encodeext() 663 } else if (ext->alg == IW_ENCODE_ALG_CCMP) { libipw_wx_set_encodeext() 701 ext->alg != IW_ENCODE_ALG_WEP) libipw_wx_get_encodeext() 709 ext->alg = IW_ENCODE_ALG_NONE; libipw_wx_get_encodeext() 714 ext->alg = IW_ENCODE_ALG_WEP; libipw_wx_get_encodeext() 716 ext->alg = IW_ENCODE_ALG_TKIP; libipw_wx_get_encodeext() 718 ext->alg = IW_ENCODE_ALG_CCMP; libipw_wx_get_encodeext() 726 (ext->alg == IW_ENCODE_ALG_TKIP || libipw_wx_get_encodeext() 727 ext->alg == IW_ENCODE_ALG_CCMP)) libipw_wx_get_encodeext()
|
/linux-4.1.27/arch/s390/crypto/ |
H A D | sha1_s390.c | 72 static struct shash_alg alg = { variable in typeref:struct:shash_alg 95 return crypto_register_shash(&alg); sha1_s390_init() 100 crypto_unregister_shash(&alg); sha1_s390_fini()
|
/linux-4.1.27/arch/arm64/crypto/ |
H A D | sha1-ce-glue.c | 86 static struct shash_alg alg = { variable in typeref:struct:shash_alg 105 return crypto_register_shash(&alg); sha1_ce_mod_init() 110 crypto_unregister_shash(&alg); sha1_ce_mod_fini()
|
/linux-4.1.27/include/crypto/ |
H A D | algapi.h | 25 unsigned int (*ctxsize)(struct crypto_alg *alg, u32 type, u32 mask); 26 unsigned int (*extsize)(struct crypto_alg *alg); 29 void (*show)(struct seq_file *m, struct crypto_alg *alg); 30 int (*report)(struct sk_buff *skb, struct crypto_alg *alg); 40 struct crypto_alg alg; member in struct:crypto_instance 62 struct crypto_alg *alg; member in struct:crypto_spawn 132 void crypto_mod_put(struct crypto_alg *alg); 142 int crypto_init_spawn(struct crypto_spawn *spawn, struct crypto_alg *alg, 144 int crypto_init_spawn2(struct crypto_spawn *spawn, struct crypto_alg *alg, 173 void *crypto_alloc_instance2(const char *name, struct crypto_alg *alg, 176 struct crypto_alg *alg); 218 return container_of(tfm->__crt_alg, struct crypto_instance, alg); crypto_tfm_alg_instance()
|
H A D | compress.h | 89 static inline struct pcomp_alg *__crypto_pcomp_alg(struct crypto_alg *alg) __crypto_pcomp_alg() argument 91 return container_of(alg, struct pcomp_alg, base); __crypto_pcomp_alg()
|
H A D | hash.h | 264 struct crypto_alg *alg) __crypto_hash_alg_common() 266 return container_of(alg, struct hash_alg_common, base); __crypto_hash_alg_common() 661 static inline struct shash_alg *__crypto_shash_alg(struct crypto_alg *alg) __crypto_shash_alg() argument 663 return container_of(alg, struct shash_alg, base); __crypto_shash_alg() 716 * sizeof(struct shash_desc) + crypto_shash_descsize(alg) 263 __crypto_hash_alg_common( struct crypto_alg *alg) __crypto_hash_alg_common() argument
|
/linux-4.1.27/drivers/crypto/vmx/ |
H A D | aes.c | 40 const char *alg; p8_aes_init() local 44 if (!(alg = crypto_tfm_alg_name(tfm))) { p8_aes_init() 49 fallback = crypto_alloc_cipher(alg, 0 ,CRYPTO_ALG_NEED_FALLBACK); p8_aes_init() 52 alg, PTR_ERR(fallback)); p8_aes_init()
|
H A D | aes_cbc.c | 41 const char *alg; p8_aes_cbc_init() local 45 if (!(alg = crypto_tfm_alg_name(tfm))) { p8_aes_cbc_init() 50 fallback = crypto_alloc_blkcipher(alg, 0 ,CRYPTO_ALG_NEED_FALLBACK); p8_aes_cbc_init() 53 alg, PTR_ERR(fallback)); p8_aes_cbc_init()
|
H A D | aes_ctr.c | 39 const char *alg; p8_aes_ctr_init() local 43 if (!(alg = crypto_tfm_alg_name(tfm))) { p8_aes_ctr_init() 48 fallback = crypto_alloc_blkcipher(alg, 0 ,CRYPTO_ALG_NEED_FALLBACK); p8_aes_ctr_init() 51 alg, PTR_ERR(fallback)); p8_aes_ctr_init()
|
H A D | ghash.c | 58 const char *alg; p8_ghash_init_tfm() local 63 if (!(alg = crypto_tfm_alg_name(tfm))) { p8_ghash_init_tfm() 68 fallback = crypto_alloc_shash(alg, 0 ,CRYPTO_ALG_NEED_FALLBACK); p8_ghash_init_tfm() 71 alg, PTR_ERR(fallback)); p8_ghash_init_tfm()
|
/linux-4.1.27/sound/soc/codecs/ |
H A D | wmfw.h | 81 struct wmfw_alg_hdr alg; member in struct:wmfw_adsp1_alg_hdr 87 struct wmfw_alg_hdr alg; member in struct:wmfw_adsp2_alg_hdr
|
H A D | wm_adsp.c | 817 dsp->num, region_name, region->alg); wm_adsp_create_control() 886 void *alg, *buf; wm_adsp_setup_algs() local 935 region->alg = be32_to_cpu(adsp1_id.fw.id); wm_adsp_setup_algs() 943 region->alg = be32_to_cpu(adsp1_id.fw.id); wm_adsp_setup_algs() 976 region->alg = be32_to_cpu(adsp2_id.fw.id); wm_adsp_setup_algs() 984 region->alg = be32_to_cpu(adsp2_id.fw.id); wm_adsp_setup_algs() 992 region->alg = be32_to_cpu(adsp2_id.fw.id); wm_adsp_setup_algs() 1029 alg = kzalloc((term - pos) * 2, GFP_KERNEL | GFP_DMA); wm_adsp_setup_algs() 1030 if (!alg) wm_adsp_setup_algs() 1033 ret = regmap_raw_read(regmap, mem->base + pos, alg, (term - pos) * 2); wm_adsp_setup_algs() 1040 adsp1_alg = alg; wm_adsp_setup_algs() 1041 adsp2_alg = alg; wm_adsp_setup_algs() 1047 i, be32_to_cpu(adsp1_alg[i].alg.id), wm_adsp_setup_algs() 1048 (be32_to_cpu(adsp1_alg[i].alg.ver) & 0xff0000) >> 16, wm_adsp_setup_algs() 1049 (be32_to_cpu(adsp1_alg[i].alg.ver) & 0xff00) >> 8, wm_adsp_setup_algs() 1050 be32_to_cpu(adsp1_alg[i].alg.ver) & 0xff, wm_adsp_setup_algs() 1060 region->alg = be32_to_cpu(adsp1_alg[i].alg.id); wm_adsp_setup_algs() 1071 be32_to_cpu(adsp1_alg[i].alg.id)); wm_adsp_setup_algs() 1080 region->alg = be32_to_cpu(adsp1_alg[i].alg.id); wm_adsp_setup_algs() 1091 be32_to_cpu(adsp1_alg[i].alg.id)); wm_adsp_setup_algs() 1098 i, be32_to_cpu(adsp2_alg[i].alg.id), wm_adsp_setup_algs() 1099 (be32_to_cpu(adsp2_alg[i].alg.ver) & 0xff0000) >> 16, wm_adsp_setup_algs() 1100 (be32_to_cpu(adsp2_alg[i].alg.ver) & 0xff00) >> 8, wm_adsp_setup_algs() 1101 be32_to_cpu(adsp2_alg[i].alg.ver) & 0xff, wm_adsp_setup_algs() 1112 region->alg = be32_to_cpu(adsp2_alg[i].alg.id); wm_adsp_setup_algs() 1123 be32_to_cpu(adsp2_alg[i].alg.id)); wm_adsp_setup_algs() 1132 region->alg = be32_to_cpu(adsp2_alg[i].alg.id); wm_adsp_setup_algs() 1143 be32_to_cpu(adsp2_alg[i].alg.id)); wm_adsp_setup_algs() 1152 region->alg = be32_to_cpu(adsp2_alg[i].alg.id); wm_adsp_setup_algs() 1163 be32_to_cpu(adsp2_alg[i].alg.id)); wm_adsp_setup_algs() 1170 kfree(alg); wm_adsp_setup_algs() 1293 if (le32_to_cpu(blk->id) == alg_region->alg && wm_adsp_load_coeff()
|
H A D | wm_adsp.h | 30 unsigned int alg; member in struct:wm_adsp_alg_region
|
/linux-4.1.27/net/mac80211/ |
H A D | rate.c | 34 struct rate_control_alg *alg; ieee80211_rate_control_register() local 40 list_for_each_entry(alg, &rate_ctrl_algs, list) { ieee80211_rate_control_register() 41 if (!strcmp(alg->ops->name, ops->name)) { ieee80211_rate_control_register() 49 alg = kzalloc(sizeof(*alg), GFP_KERNEL); ieee80211_rate_control_register() 50 if (alg == NULL) { ieee80211_rate_control_register() 54 alg->ops = ops; ieee80211_rate_control_register() 56 list_add_tail(&alg->list, &rate_ctrl_algs); ieee80211_rate_control_register() 65 struct rate_control_alg *alg; ieee80211_rate_control_unregister() local 68 list_for_each_entry(alg, &rate_ctrl_algs, list) { ieee80211_rate_control_unregister() 69 if (alg->ops == ops) { ieee80211_rate_control_unregister() 70 list_del(&alg->list); ieee80211_rate_control_unregister() 71 kfree(alg); ieee80211_rate_control_unregister() 82 struct rate_control_alg *alg; ieee80211_try_rate_control_ops_get() local 89 list_for_each_entry(alg, &rate_ctrl_algs, list) { ieee80211_try_rate_control_ops_get() 90 if (!strcmp(alg->ops->name, name)) { ieee80211_try_rate_control_ops_get() 91 ops = alg->ops; ieee80211_try_rate_control_ops_get() 114 /* try default if specific alg requested but not found */ ieee80211_rate_control_ops_get() 117 /* try built-in one if specific alg requested but not found */ ieee80211_rate_control_ops_get()
|
/linux-4.1.27/drivers/crypto/amcc/ |
H A D | crypto4xx_core.c | 994 struct crypto_alg *alg = tfm->__crt_alg; crypto4xx_alg_init() local 995 struct crypto4xx_alg *amcc_alg = crypto_alg_to_crypto4xx_alg(alg); crypto4xx_alg_init() 1005 switch (alg->cra_flags & CRYPTO_ALG_TYPE_MASK) { crypto4xx_alg_init() 1030 struct crypto4xx_alg *alg; crypto4xx_register_alg() local 1035 alg = kzalloc(sizeof(struct crypto4xx_alg), GFP_KERNEL); crypto4xx_register_alg() 1036 if (!alg) crypto4xx_register_alg() 1039 alg->alg = crypto_alg[i]; crypto4xx_register_alg() 1040 alg->dev = sec_dev; crypto4xx_register_alg() 1042 switch (alg->alg.type) { crypto4xx_register_alg() 1044 rc = crypto_register_ahash(&alg->alg.u.hash); crypto4xx_register_alg() 1048 rc = crypto_register_alg(&alg->alg.u.cipher); crypto4xx_register_alg() 1053 list_del(&alg->entry); crypto4xx_register_alg() 1054 kfree(alg); crypto4xx_register_alg() 1056 list_add_tail(&alg->entry, &sec_dev->alg_list); crypto4xx_register_alg() 1065 struct crypto4xx_alg *alg, *tmp; crypto4xx_unregister_alg() local 1067 list_for_each_entry_safe(alg, tmp, &sec_dev->alg_list, entry) { crypto4xx_unregister_alg() 1068 list_del(&alg->entry); crypto4xx_unregister_alg() 1069 switch (alg->alg.type) { crypto4xx_unregister_alg() 1071 crypto_unregister_ahash(&alg->alg.u.hash); crypto4xx_unregister_alg() 1075 crypto_unregister_alg(&alg->alg.u.cipher); crypto4xx_unregister_alg() 1077 kfree(alg); crypto4xx_unregister_alg()
|
H A D | crypto4xx_core.h | 153 struct crypto4xx_alg_common alg; member in struct:crypto4xx_alg 163 struct crypto4xx_alg, alg.u.hash); crypto_alg_to_crypto4xx_alg() 166 return container_of(x, struct crypto4xx_alg, alg.u.cipher); crypto_alg_to_crypto4xx_alg()
|
H A D | crypto4xx_alg.c | 185 struct crypto_alg *alg = tfm->__crt_alg; crypto4xx_hash_alg_init() local 186 struct crypto4xx_alg *my_alg = crypto_alg_to_crypto4xx_alg(alg); crypto4xx_hash_alg_init()
|
/linux-4.1.27/drivers/staging/lustre/lustre/obdclass/ |
H A D | capa.c | 262 struct capa_hmac_alg *alg; capa_hmac() local 271 alg = &capa_hmac_algs[capa_alg(capa)]; capa_hmac() 273 tfm = crypto_alloc_hash(alg->ha_name, 0, 0); capa_hmac() 278 keylen = alg->ha_keylen; capa_hmac() 300 char alg[CRYPTO_MAX_ALG_NAME+1] = "aes"; capa_encrypt_id() local 304 tfm = crypto_alloc_blkcipher(alg, 0, 0); capa_encrypt_id() 353 char alg[CRYPTO_MAX_ALG_NAME+1] = "aes"; capa_decrypt_id() local 357 tfm = crypto_alloc_blkcipher(alg, 0, 0); capa_decrypt_id() 414 " capability@%p fid " DFID " opc %#llx uid %llu gid %llu flags %u alg %d keyid %u timeout %u expiry %u\n", _debug_capa()
|
/linux-4.1.27/drivers/staging/lustre/lustre/libcfs/linux/ |
H A D | linux-crypto-adler.c | 112 static struct shash_alg alg = { variable in typeref:struct:shash_alg 135 return crypto_register_shash(&alg); cfs_crypto_adler32_register() 140 crypto_unregister_shash(&alg); cfs_crypto_adler32_unregister()
|
/linux-4.1.27/arch/sparc/crypto/ |
H A D | crc32c_glue.c | 123 static struct shash_alg alg = { variable in typeref:struct:shash_alg 162 return crypto_register_shash(&alg); crc32c_sparc64_mod_init() 170 crypto_unregister_shash(&alg); crc32c_sparc64_mod_fini()
|
H A D | md5_glue.c | 134 static struct shash_alg alg = { variable in typeref:struct:shash_alg 171 return crypto_register_shash(&alg); md5_sparc64_mod_init() 179 crypto_unregister_shash(&alg); md5_sparc64_mod_fini()
|
H A D | sha1_glue.c | 129 static struct shash_alg alg = { variable in typeref:struct:shash_alg 166 return crypto_register_shash(&alg); sha1_sparc64_mod_init() 174 crypto_unregister_shash(&alg); sha1_sparc64_mod_fini()
|
/linux-4.1.27/arch/powerpc/crypto/ |
H A D | md5-glue.c | 129 static struct shash_alg alg = { variable in typeref:struct:shash_alg 150 return crypto_register_shash(&alg); ppc_md5_mod_init() 155 crypto_unregister_shash(&alg); ppc_md5_mod_fini()
|
H A D | sha1.c | 123 static struct shash_alg alg = { variable in typeref:struct:shash_alg 143 return crypto_register_shash(&alg); sha1_powerpc_mod_init() 148 crypto_unregister_shash(&alg); sha1_powerpc_mod_fini()
|
H A D | sha1-spe-glue.c | 174 static struct shash_alg alg = { variable in typeref:struct:shash_alg 195 return crypto_register_shash(&alg); ppc_spe_sha1_mod_init() 200 crypto_unregister_shash(&alg); ppc_spe_sha1_mod_fini()
|
/linux-4.1.27/drivers/crypto/qat/qat_common/ |
H A D | qat_algs.c | 66 #define QAT_AES_HW_CONFIG_CBC_ENC(alg) \ 67 ICP_QAT_HW_CIPHER_CONFIG_BUILD(ICP_QAT_HW_CIPHER_CBC_MODE, alg, \ 71 #define QAT_AES_HW_CONFIG_CBC_DEC(alg) \ 72 ICP_QAT_HW_CIPHER_CONFIG_BUILD(ICP_QAT_HW_CIPHER_CBC_MODE, alg, \ 282 int alg, qat_alg_aead_init_enc_session() 300 cipher->aes.cipher_config.val = QAT_AES_HW_CONFIG_CBC_ENC(alg); qat_alg_aead_init_enc_session() 362 int alg, qat_alg_aead_init_dec_session() 385 cipher->aes.cipher_config.val = QAT_AES_HW_CONFIG_CBC_DEC(alg); qat_alg_aead_init_dec_session() 475 int alg, const uint8_t *key, qat_alg_ablkcipher_init_enc() 484 enc_cd->aes.cipher_config.val = QAT_AES_HW_CONFIG_CBC_ENC(alg); qat_alg_ablkcipher_init_enc() 488 int alg, const uint8_t *key, qat_alg_ablkcipher_init_dec() 497 dec_cd->aes.cipher_config.val = QAT_AES_HW_CONFIG_CBC_DEC(alg); qat_alg_ablkcipher_init_dec() 500 static int qat_alg_validate_key(int key_len, int *alg) qat_alg_validate_key() argument 504 *alg = ICP_QAT_HW_CIPHER_ALGO_AES128; qat_alg_validate_key() 507 *alg = ICP_QAT_HW_CIPHER_ALGO_AES192; qat_alg_validate_key() 510 *alg = ICP_QAT_HW_CIPHER_ALGO_AES256; qat_alg_validate_key() 522 int alg; qat_alg_aead_init_sessions() local 530 if (qat_alg_validate_key(keys.enckeylen, &alg)) qat_alg_aead_init_sessions() 533 if (qat_alg_aead_init_enc_session(ctx, alg, &keys)) qat_alg_aead_init_sessions() 536 if (qat_alg_aead_init_dec_session(ctx, alg, &keys)) qat_alg_aead_init_sessions() 551 int alg; qat_alg_ablkcipher_init_sessions() local 553 if (qat_alg_validate_key(keylen, &alg)) qat_alg_ablkcipher_init_sessions() 556 qat_alg_ablkcipher_init_enc(ctx, alg, key, keylen); qat_alg_ablkcipher_init_sessions() 557 qat_alg_ablkcipher_init_dec(ctx, alg, key, keylen); qat_alg_ablkcipher_init_sessions() 281 qat_alg_aead_init_enc_session(struct qat_alg_aead_ctx *ctx, int alg, struct crypto_authenc_keys *keys) qat_alg_aead_init_enc_session() argument 361 qat_alg_aead_init_dec_session(struct qat_alg_aead_ctx *ctx, int alg, struct crypto_authenc_keys *keys) qat_alg_aead_init_dec_session() argument 474 qat_alg_ablkcipher_init_enc(struct qat_alg_ablkcipher_ctx *ctx, int alg, const uint8_t *key, unsigned int keylen) qat_alg_ablkcipher_init_enc() argument 487 qat_alg_ablkcipher_init_dec(struct qat_alg_ablkcipher_ctx *ctx, int alg, const uint8_t *key, unsigned int keylen) qat_alg_ablkcipher_init_dec() argument
|
/linux-4.1.27/drivers/staging/rtl8192u/ |
H A D | r8192U_wx.c | 756 u8 idx = 0, alg = 0, group = 0; r8192_wx_set_enc_ext() local 758 if ((encoding->flags & IW_ENCODE_DISABLED) || ext->alg == IW_ENCODE_ALG_NONE) r8192_wx_set_enc_ext() 763 alg = (ext->alg == IW_ENCODE_ALG_CCMP)?KEY_TYPE_CCMP:ext->alg; r8192_wx_set_enc_ext() 769 if ((!group) || (IW_MODE_ADHOC == ieee->iw_mode) || (alg == KEY_TYPE_WEP40)) { r8192_wx_set_enc_ext() 770 if ((ext->key_len == 13) && (alg == KEY_TYPE_WEP40)) r8192_wx_set_enc_ext() 771 alg = KEY_TYPE_WEP104; r8192_wx_set_enc_ext() 772 ieee->pairwise_key_type = alg; r8192_wx_set_enc_ext() 777 if ((alg & KEY_TYPE_WEP40) && (ieee->auth_mode != 2)) { r8192_wx_set_enc_ext() 782 alg, /* KeyType */ r8192_wx_set_enc_ext() 787 ieee->group_key_type = alg; r8192_wx_set_enc_ext() 791 alg, /* KeyType */ r8192_wx_set_enc_ext() 799 alg, /* KeyType */ r8192_wx_set_enc_ext()
|
H A D | r8192U_core.c | 3479 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0) { rtl8192_ioctl() 3481 } else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0) { rtl8192_ioctl() 3483 } else if (strcmp(ipw->u.crypt.alg, "WEP") == 0) { rtl8192_ioctl() 3503 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0) { rtl8192_ioctl() 3505 } else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0) { rtl8192_ioctl() 3507 } else if (strcmp(ipw->u.crypt.alg, "WEP") == 0) { rtl8192_ioctl()
|
/linux-4.1.27/arch/mips/cavium-octeon/crypto/ |
H A D | octeon-md5.c | 172 static struct shash_alg alg = { variable in typeref:struct:shash_alg 195 return crypto_register_shash(&alg); md5_mod_init() 200 crypto_unregister_shash(&alg); md5_mod_fini()
|
/linux-4.1.27/drivers/staging/rtl8192e/rtl8192e/ |
H A D | rtl_wx.c | 995 u8 idx = 0, alg = 0, group = 0; r8192_wx_set_enc_ext() local 998 ext->alg == IW_ENCODE_ALG_NONE) { r8192_wx_set_enc_ext() 1006 alg = (ext->alg == IW_ENCODE_ALG_CCMP) ? KEY_TYPE_CCMP : r8192_wx_set_enc_ext() 1007 ext->alg; r8192_wx_set_enc_ext() 1014 (alg == KEY_TYPE_WEP40)) { r8192_wx_set_enc_ext() 1015 if ((ext->key_len == 13) && (alg == KEY_TYPE_WEP40)) r8192_wx_set_enc_ext() 1016 alg = KEY_TYPE_WEP104; r8192_wx_set_enc_ext() 1017 ieee->pairwise_key_type = alg; r8192_wx_set_enc_ext() 1022 if ((alg & KEY_TYPE_WEP40) && (ieee->auth_mode != 2)) { r8192_wx_set_enc_ext() 1024 ieee->pairwise_key_type = alg = KEY_TYPE_WEP104; r8192_wx_set_enc_ext() 1025 setKey(dev, idx, idx, alg, zero, 0, key); r8192_wx_set_enc_ext() 1026 set_swcam(dev, idx, idx, alg, zero, 0, key, 0); r8192_wx_set_enc_ext() 1028 ieee->group_key_type = alg; r8192_wx_set_enc_ext() 1029 setKey(dev, idx, idx, alg, broadcast_addr, 0, key); r8192_wx_set_enc_ext() 1030 set_swcam(dev, idx, idx, alg, broadcast_addr, 0, r8192_wx_set_enc_ext() 1036 setKey(dev, 4, idx, alg, (u8 *)ieee->ap_mac_addr, r8192_wx_set_enc_ext() 1038 set_swcam(dev, 4, idx, alg, (u8 *)ieee->ap_mac_addr, r8192_wx_set_enc_ext()
|
H A D | rtl_crypto.h | 122 int crypto_register_alg(struct crypto_alg *alg); 123 int crypto_unregister_alg(struct crypto_alg *alg); 225 struct crypto_alg *alg = tfm->__crt_alg; crypto_tfm_alg_modname() local 227 if (alg->cra_module) crypto_tfm_alg_modname() 228 return alg->cra_module->name; crypto_tfm_alg_modname()
|
H A D | rtl_core.c | 2597 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0) rtl8192_ioctl() 2599 else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0) rtl8192_ioctl() 2601 else if (strcmp(ipw->u.crypt.alg, "WEP") == 0) { rtl8192_ioctl() 2645 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0) rtl8192_ioctl() 2647 else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0) rtl8192_ioctl() 2649 else if (strcmp(ipw->u.crypt.alg, "WEP") == 0) { rtl8192_ioctl()
|
/linux-4.1.27/arch/cris/include/arch-v32/arch/ |
H A D | cryptocop.h | 34 cryptocop_algorithm alg; member in struct:cryptocop_transform_init 40 cryptocop_csum_type csum_mode; /* cryptocop_csum_none is not allowed when alg==cryptocop_alg_csum */
|
/linux-4.1.27/drivers/staging/lustre/include/linux/libcfs/ |
H A D | libcfs_crypto.h | 112 * @param alg id of hash algorithm 129 int cfs_crypto_hash_digest(unsigned char alg, 138 * @param alg algorithm id 146 cfs_crypto_hash_init(unsigned char alg,
|
/linux-4.1.27/arch/s390/kernel/vdso64/ |
H A D | gettimeofday.S | 36 alg %r1,__VDSO_XTIME_NSEC(%r5) /* + tk->xtime_nsec */
|
H A D | clock_gettime.S | 45 alg %r1,__VDSO_WTOM_NSEC(%r5) 90 alg %r1,__VDSO_XTIME_NSEC(%r5) /* + tk->xtime_nsec */
|
/linux-4.1.27/drivers/staging/media/davinci_vpfe/ |
H A D | dm365_ipipe.h | 49 enum vpfe_ipipe_otfdpc_alg alg; member in struct:ipipe_otfdpc_2_0 61 enum vpfe_ipipe_otfdpc_alg alg; member in struct:ipipe_otfdpc_3_0
|
H A D | davinci_vpfe_user.h | 665 /* defect detection threshold for MIN_MAX2 method (DPC 2.0 alg) */ 667 /* defect correction threshold for MIN_MAX2 method (DPC 2.0 alg) or 703 enum vpfe_ipipe_otfdpc_alg alg; member in struct:vpfe_ipipe_otfdpc 705 /* if alg is IPIPE_OTFDPC_2_0 */ 707 /* if alg is IPIPE_OTFDPC_3_0 */ 832 enum vpfe_ipipe_cfa_alg alg; member in struct:vpfe_ipipe_cfa
|
H A D | dm365_ipipe_hw.c | 484 val = (otfdpc->det_method << OTF_DET_METHOD_SHIFT) | otfdpc->alg; ipipe_set_otfdpc_regs() 498 if (otfdpc->alg == VPFE_IPIPE_OTFDPC_2_0) { ipipe_set_otfdpc_regs() 642 regw_ip(base_addr, cfa->alg, CFA_MODE); ipipe_set_cfa_regs()
|
H A D | dm365_ipipe.c | 142 if (dpc_param->alg == VPFE_IPIPE_OTFDPC_2_0) { ipipe_validate_otfdpc_params() 415 cfa->alg = VPFE_IPIPE_CFA_ALG_2DIRAC; ipipe_set_cfa_params()
|
/linux-4.1.27/include/linux/crush/ |
H A D | crush.h | 109 extern const char *crush_bucket_alg_name(int alg); 114 __u8 alg; /* one of CRUSH_BUCKET_* */ member in struct:crush_bucket
|
/linux-4.1.27/drivers/crypto/caam/ |
H A D | caamhash.c | 1754 struct ahash_alg *alg = caam_hash_cra_init() local 1757 container_of(alg, struct caam_hash_alg, ahash_alg); caam_hash_cra_init() 1843 struct crypto_alg *alg; caam_hash_alloc() local 1853 alg = &halg->halg.base; caam_hash_alloc() 1856 snprintf(alg->cra_name, CRYPTO_MAX_ALG_NAME, "%s", caam_hash_alloc() 1858 snprintf(alg->cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s", caam_hash_alloc() 1861 snprintf(alg->cra_name, CRYPTO_MAX_ALG_NAME, "%s", caam_hash_alloc() 1863 snprintf(alg->cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s", caam_hash_alloc() 1866 alg->cra_module = THIS_MODULE; caam_hash_alloc() 1867 alg->cra_init = caam_hash_cra_init; caam_hash_alloc() 1868 alg->cra_exit = caam_hash_cra_exit; caam_hash_alloc() 1869 alg->cra_ctxsize = sizeof(struct caam_hash_ctx); caam_hash_alloc() 1870 alg->cra_priority = CAAM_CRA_PRIORITY; caam_hash_alloc() 1871 alg->cra_blocksize = template->blocksize; caam_hash_alloc() 1872 alg->cra_alignmask = 0; caam_hash_alloc() 1873 alg->cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_TYPE_AHASH; caam_hash_alloc() 1874 alg->cra_type = &crypto_ahash_type; caam_hash_alloc() 1918 /* TODO: check if h/w supports alg */ caam_algapi_hash_init() 1925 pr_warn("%s alg allocation failed\n", caam_algapi_hash_init() 1932 pr_warn("%s alg registration failed\n", caam_algapi_hash_init() 1942 pr_warn("%s alg allocation failed\n", caam_algapi_hash_init() 1949 pr_warn("%s alg registration failed\n", caam_algapi_hash_init()
|
H A D | caamalg.c | 58 * crypto alg 4137 struct crypto_alg *alg = tfm->__crt_alg; caam_cra_init() local 4139 container_of(alg, struct caam_crypto_alg, crypto_alg); caam_cra_init() 4201 struct crypto_alg *alg; caam_alg_alloc() local 4209 alg = &t_alg->crypto_alg; caam_alg_alloc() 4211 snprintf(alg->cra_name, CRYPTO_MAX_ALG_NAME, "%s", template->name); caam_alg_alloc() 4212 snprintf(alg->cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s", caam_alg_alloc() 4214 alg->cra_module = THIS_MODULE; caam_alg_alloc() 4215 alg->cra_init = caam_cra_init; caam_alg_alloc() 4216 alg->cra_exit = caam_cra_exit; caam_alg_alloc() 4217 alg->cra_priority = CAAM_CRA_PRIORITY; caam_alg_alloc() 4218 alg->cra_blocksize = template->blocksize; caam_alg_alloc() 4219 alg->cra_alignmask = 0; caam_alg_alloc() 4220 alg->cra_ctxsize = sizeof(struct caam_ctx); caam_alg_alloc() 4221 alg->cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_KERN_DRIVER_ONLY | caam_alg_alloc() 4225 alg->cra_type = &crypto_givcipher_type; caam_alg_alloc() 4226 alg->cra_ablkcipher = template->template_ablkcipher; caam_alg_alloc() 4229 alg->cra_type = &crypto_ablkcipher_type; caam_alg_alloc() 4230 alg->cra_ablkcipher = template->template_ablkcipher; caam_alg_alloc() 4233 alg->cra_type = &crypto_aead_type; caam_alg_alloc() 4234 alg->cra_aead = template->template_aead; caam_alg_alloc() 4282 /* TODO: check if h/w supports alg */ caam_algapi_init() 4288 pr_warn("%s alg allocation failed\n", caam_algapi_init() 4295 pr_warn("%s alg registration failed\n", caam_algapi_init()
|
/linux-4.1.27/drivers/staging/rtl8188eu/os_dep/ |
H A D | ioctl_linux.c | 364 param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0'; wpa_set_encryption() 383 if (strcmp(param->u.crypt.alg, "WEP") == 0) { wpa_set_encryption() 384 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_err_, ("wpa_set_encryption, crypt.alg = WEP\n")); wpa_set_encryption() 385 DBG_88E("wpa_set_encryption, crypt.alg = WEP\n"); wpa_set_encryption() 450 if (strcmp(param->u.crypt.alg, "none") != 0) wpa_set_encryption() 460 if (strcmp(param->u.crypt.alg, "TKIP") == 0) { /* set mic key */ wpa_set_encryption() 486 if (strcmp(param->u.crypt.alg, "none") != 0) wpa_set_encryption() 1910 switch (pext->alg) { rtw_wx_set_enc_ext() 1930 strncpy((char *)param->u.crypt.alg, alg_name, IEEE_CRYPT_ALG_NAME_LEN); rtw_wx_set_enc_ext() 1938 if ((pext->alg != IW_ENCODE_ALG_WEP) && rtw_wx_set_enc_ext() 2148 static int set_group_key(struct adapter *padapter, u8 *key, u8 alg, int keyid) set_group_key() argument 2174 psetkeyparm->algorithm = alg; set_group_key() 2178 switch (alg) { set_group_key() 2211 u8 alg; set_wep_key() local 2215 alg = _WEP40_; set_wep_key() 2218 alg = _WEP104_; set_wep_key() 2221 alg = _NO_PRIVACY_; set_wep_key() 2224 return set_group_key(padapter, key, alg, keyid); set_wep_key() 2240 param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0'; rtw_set_encryption() 2260 if (strcmp(param->u.crypt.alg, "none") == 0 && (psta == NULL)) { rtw_set_encryption() 2266 if (strcmp(param->u.crypt.alg, "WEP") == 0 && (psta == NULL)) { rtw_set_encryption() 2267 DBG_88E("r871x_set_encryption, crypt.alg = WEP\n"); rtw_set_encryption() 2332 if (strcmp(param->u.crypt.alg, "WEP") == 0) { rtw_set_encryption() 2341 } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) { rtw_set_encryption() 2351 } else if (strcmp(param->u.crypt.alg, "CCMP") == 0) { rtw_set_encryption() 2378 if (strcmp(param->u.crypt.alg, "WEP") == 0) { rtw_set_encryption() 2384 } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) { rtw_set_encryption() 2394 } else if (strcmp(param->u.crypt.alg, "CCMP") == 0) { rtw_set_encryption() 2408 if (strcmp(param->u.crypt.alg, "WEP") == 0) { rtw_set_encryption() 2414 } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) { rtw_set_encryption() 2425 } else if (strcmp(param->u.crypt.alg, "CCMP") == 0) { rtw_set_encryption()
|
/linux-4.1.27/drivers/net/wireless/hostap/ |
H A D | hostap_ioctl.c | 3212 const char *alg, *module; prism2_ioctl_siwencodeext() local 3247 ext->alg == IW_ENCODE_ALG_NONE) { prism2_ioctl_siwencodeext() 3253 switch (ext->alg) { prism2_ioctl_siwencodeext() 3255 alg = "WEP"; prism2_ioctl_siwencodeext() 3259 alg = "TKIP"; prism2_ioctl_siwencodeext() 3263 alg = "CCMP"; prism2_ioctl_siwencodeext() 3268 local->dev->name, ext->alg); prism2_ioctl_siwencodeext() 3273 ops = lib80211_get_crypto_ops(alg); prism2_ioctl_siwencodeext() 3276 ops = lib80211_get_crypto_ops(alg); prism2_ioctl_siwencodeext() 3279 printk(KERN_DEBUG "%s: unknown crypto alg '%s'\n", prism2_ioctl_siwencodeext() 3280 local->dev->name, alg); prism2_ioctl_siwencodeext() 3285 if (sta_ptr || ext->alg != IW_ENCODE_ALG_WEP) { prism2_ioctl_siwencodeext() 3410 ext->alg = IW_ENCODE_ALG_NONE; prism2_ioctl_giwencodeext() 3415 ext->alg = IW_ENCODE_ALG_WEP; prism2_ioctl_giwencodeext() 3417 ext->alg = IW_ENCODE_ALG_TKIP; prism2_ioctl_giwencodeext() 3419 ext->alg = IW_ENCODE_ALG_CCMP; prism2_ioctl_giwencodeext() 3430 (ext->alg == IW_ENCODE_ALG_TKIP || prism2_ioctl_giwencodeext() 3431 ext->alg == IW_ENCODE_ALG_CCMP)) prism2_ioctl_giwencodeext() 3453 param->u.crypt.alg[HOSTAP_CRYPT_ALG_NAME_LEN - 1] = '\0'; prism2_ioctl_set_encryption() 3479 if (strcmp(param->u.crypt.alg, "none") == 0) { prism2_ioctl_set_encryption() 3485 ops = lib80211_get_crypto_ops(param->u.crypt.alg); prism2_ioctl_set_encryption() 3486 if (ops == NULL && strcmp(param->u.crypt.alg, "WEP") == 0) { prism2_ioctl_set_encryption() 3488 ops = lib80211_get_crypto_ops(param->u.crypt.alg); prism2_ioctl_set_encryption() 3489 } else if (ops == NULL && strcmp(param->u.crypt.alg, "TKIP") == 0) { prism2_ioctl_set_encryption() 3491 ops = lib80211_get_crypto_ops(param->u.crypt.alg); prism2_ioctl_set_encryption() 3492 } else if (ops == NULL && strcmp(param->u.crypt.alg, "CCMP") == 0) { prism2_ioctl_set_encryption() 3494 ops = lib80211_get_crypto_ops(param->u.crypt.alg); prism2_ioctl_set_encryption() 3497 printk(KERN_DEBUG "%s: unknown crypto alg '%s'\n", prism2_ioctl_set_encryption() 3498 local->dev->name, param->u.crypt.alg); prism2_ioctl_set_encryption() 3610 memcpy(param->u.crypt.alg, "none", 5); prism2_ioctl_get_encryption() 3614 strncpy(param->u.crypt.alg, (*crypt)->ops->name, prism2_ioctl_get_encryption()
|
H A D | hostap_common.h | 374 u8 alg[HOSTAP_CRYPT_ALG_NAME_LEN]; member in struct:prism2_hostapd_param::__anon7854::__anon7857
|
H A D | hostap_80211_tx.c | 412 * AP code if STA has own alg/key */ hostap_master_start_xmit()
|
/linux-4.1.27/drivers/net/wireless/orinoco/ |
H A D | wext.c | 31 enum orinoco_alg alg, const u8 *key, int key_len, orinoco_set_key() 59 switch (alg) { orinoco_set_key() 727 int idx, alg = ext->alg, set_key = 1; orinoco_ioctl_set_encodeext() local 744 alg = IW_ENCODE_ALG_NONE; orinoco_ioctl_set_encodeext() 746 if (priv->has_wpa && (alg != IW_ENCODE_ALG_TKIP)) { orinoco_ioctl_set_encodeext() 753 set_key = ((alg == IW_ENCODE_ALG_TKIP) || orinoco_ioctl_set_encodeext() 759 switch (alg) { orinoco_ioctl_set_encodeext() 846 ext->alg = IW_ENCODE_ALG_NONE; orinoco_ioctl_get_encodeext() 851 ext->alg = IW_ENCODE_ALG_WEP; orinoco_ioctl_get_encodeext() 857 ext->alg = IW_ENCODE_ALG_TKIP; orinoco_ioctl_get_encodeext() 1027 /* Looks like wl_lkm wants to check the auth alg, and orinoco_ioctl_set_genie() 30 orinoco_set_key(struct orinoco_private *priv, int index, enum orinoco_alg alg, const u8 *key, int key_len, const u8 *seq, int seq_len) orinoco_set_key() argument
|
/linux-4.1.27/drivers/staging/rtl8723au/include/ |
H A D | rtw_security.h | 23 #define is_wep_enc(alg) (alg == WLAN_CIPHER_SUITE_WEP40 || \ 24 alg == WLAN_CIPHER_SUITE_WEP104)
|
/linux-4.1.27/net/sunrpc/auth_gss/ |
H A D | gss_krb5_mech.c | 223 int alg; get_key() local 225 p = simple_get_bytes(p, end, &alg, sizeof(alg)); get_key() 229 switch (alg) { get_key() 234 alg = ENCTYPE_DES_CBC_RAW; get_key() 238 if (!supported_gss_krb5_enctype(alg)) { get_key() 240 "encryption key algorithm %d\n", alg); get_key()
|
/linux-4.1.27/drivers/staging/lustre/lustre/ptlrpc/ |
H A D | sec_bulk.c | 843 int sptlrpc_get_bulk_checksum(struct ptlrpc_bulk_desc *desc, __u8 alg, sptlrpc_get_bulk_checksum() argument 852 LASSERT(alg > BULK_HASH_ALG_NULL && alg < BULK_HASH_ALG_MAX); sptlrpc_get_bulk_checksum() 855 hdesc = cfs_crypto_hash_init(cfs_hash_alg_id[alg], NULL, 0); sptlrpc_get_bulk_checksum() 858 cfs_crypto_hash_name(cfs_hash_alg_id[alg])); sptlrpc_get_bulk_checksum() 862 hashsize = cfs_crypto_hash_digestsize(cfs_hash_alg_id[alg]); sptlrpc_get_bulk_checksum()
|
H A D | sec_config.c | 98 char *bulk, *alg; sptlrpc_parse_flavor() local 127 alg = strchr(bulk, ':'); sptlrpc_parse_flavor() 128 if (alg == NULL) sptlrpc_parse_flavor() 130 *alg++ = '\0'; sptlrpc_parse_flavor() 135 flvr->u_bulk.hash.hash_alg = sptlrpc_get_hash_alg(alg); sptlrpc_parse_flavor()
|
/linux-4.1.27/drivers/staging/rtl8188eu/include/ |
H A D | rtw_security.h | 35 #define is_wep_enc(alg) (((alg) == _WEP40_) || ((alg) == _WEP104_))
|
/linux-4.1.27/include/net/netns/ |
H A D | sctp.h | 66 /* The namespace default hmac alg */
|
/linux-4.1.27/drivers/media/platform/davinci/ |
H A D | isif.c | 79 .alg = ISIF_ALAW, 601 if (module_params->compress.alg == ISIF_ALAW) isif_config_raw() 608 if (module_params->compress.alg == ISIF_DPCM) { isif_config_raw() 747 if ((isif_cfg.bayer.config_params.compress.alg != isif_set_pixel_format() 749 (isif_cfg.bayer.config_params.compress.alg != isif_set_pixel_format() 757 isif_cfg.bayer.config_params.compress.alg = isif_set_pixel_format() 780 if (isif_cfg.bayer.config_params.compress.alg == ISIF_ALAW || isif_get_pixel_format() 781 isif_cfg.bayer.config_params.compress.alg == ISIF_DPCM) isif_get_pixel_format()
|
/linux-4.1.27/include/linux/ |
H A D | nfs4.h | 239 NFS4ERR_HASH_ALG_UNSUPP = 10072, /* hash alg. not supp. */ 246 NFS4ERR_ENCR_ALG_UNSUPP = 10079, /* SSV alg mismatch */
|
H A D | crypto.h | 567 void (*cra_destroy)(struct crypto_alg *alg); 575 int crypto_register_alg(struct crypto_alg *alg); 576 int crypto_unregister_alg(struct crypto_alg *alg); 759 int alg_test(const char *driver, const char *alg, u32 type, u32 mask);
|
/linux-4.1.27/arch/cris/arch-v32/drivers/ |
H A D | cryptocop.c | 452 if ((tc->tctx->init.alg == cryptocop_alg_aes) && (tc->tcfg->flags & CRYPTOCOP_DECRYPT)) { setup_key_dl_desc() 843 switch (tctx->init.alg){ cryptocop_setup_dma_list() 886 switch (tctx->init.alg){ cryptocop_setup_dma_list() 903 panic("cryptocop_setup_dma_list: impossible algorithm %d\n", tctx->init.alg); cryptocop_setup_dma_list() 918 switch (tctx->init.alg){ cryptocop_setup_dma_list() 946 DEBUG_API(printk("cryptocop_setup_dma_list: invalid algorithm %d specified in tfrm %d.\n", tctx->init.alg, tcfg->tid)); cryptocop_setup_dma_list() 953 if (cipher_ctx.tcfg && (cipher_ctx.tctx->init.alg != cryptocop_alg_mem2mem)){ cryptocop_setup_dma_list() 1450 switch (tinit->alg){ transform_ok() 1488 DEBUG_API(printk("transform_ok: no such algorithm %d\n", tinit->alg)); transform_ok() 1492 switch (tinit->alg){ transform_ok() 2606 cblocklen = tc->init.alg == cryptocop_alg_aes ? AES_BLOCK_LENGTH : DES_BLOCK_LENGTH; cryptocop_ioctl_process() 2651 digest_length = tc->init.alg == cryptocop_alg_md5 ? 16 : 20; cryptocop_ioctl_process() 3004 ti_cipher.alg = cryptocop_alg_des; cryptocop_ioctl_create_session() 3007 ti_cipher.alg = cryptocop_alg_3des; cryptocop_ioctl_create_session() 3010 ti_cipher.alg = cryptocop_alg_aes; cryptocop_ioctl_create_session() 3016 DEBUG(printk("setting cipher transform %d\n", ti_cipher.alg)); cryptocop_ioctl_create_session() 3052 ti_digest.alg = cryptocop_alg_md5; cryptocop_ioctl_create_session() 3055 ti_digest.alg = cryptocop_alg_sha1; cryptocop_ioctl_create_session() 3076 ti_csum.alg = cryptocop_alg_csum; cryptocop_ioctl_create_session()
|
/linux-4.1.27/security/integrity/ima/ |
H A D | ima_template.c | 74 pr_err("template does not support hash alg\n"); ima_template_setup()
|
/linux-4.1.27/drivers/net/ethernet/toshiba/ |
H A D | ps3_gelic_wireless.c | 1208 __u16 alg; gelic_wl_set_encodeext() local 1216 alg = ext->alg; gelic_wl_set_encodeext() 1242 if (alg == IW_ENCODE_ALG_NONE || (flags & IW_ENCODE_DISABLED)) { gelic_wl_set_encodeext() 1243 pr_debug("%s: alg disabled\n", __func__); gelic_wl_set_encodeext() 1248 } else if (alg == IW_ENCODE_ALG_WEP) { gelic_wl_set_encodeext() 1271 } else if (alg == IW_ENCODE_ALG_PMK) { gelic_wl_set_encodeext() 1326 ext->alg = IW_ENCODE_ALG_WEP; gelic_wl_get_encodeext() 1330 ext->alg = IW_ENCODE_ALG_TKIP; gelic_wl_get_encodeext() 1334 ext->alg = IW_ENCODE_ALG_CCMP; gelic_wl_get_encodeext() 1339 ext->alg = IW_ENCODE_ALG_NONE; gelic_wl_get_encodeext()
|
/linux-4.1.27/arch/s390/kernel/ |
H A D | swsusp.S | 78 alg %r0,__LC_SYSTEM_TIMER 83 alg %r0,__LC_STEAL_TIMER
|
H A D | entry.S | 141 alg \scratch,__LC_USER_TIMER 145 alg \scratch,__LC_SYSTEM_TIMER 877 alg %r15,__LC_USER_TIMER 884 alg %r15,__LC_SYSTEM_TIMER 963 alg %r9,__CLOCK_IDLE_ENTER(%r2) 968 alg %r9,__LC_LAST_UPDATE_TIMER
|
/linux-4.1.27/include/linux/mfd/ |
H A D | abx500.h | 245 * @interval_charging charge alg cycle period time when charging (sec) 246 * @interval_not_charging charge alg cycle period time when not charging (sec)
|
/linux-4.1.27/net/ceph/ |
H A D | osdmap.c | 199 u32 alg; crush_decode() local 202 ceph_decode_32_safe(p, end, alg, bad); crush_decode() 203 if (alg == 0) { crush_decode() 210 switch (alg) { crush_decode() 238 b->alg = ceph_decode_8(p); crush_decode() 258 switch (b->alg) { crush_decode()
|
/linux-4.1.27/include/net/ |
H A D | xfrm.h | 910 * Otherwise, both must have a context and the sids, doi, alg must match 1689 static inline int aead_len(struct xfrm_algo_aead *alg) aead_len() argument 1691 return sizeof(*alg) + ((alg->alg_key_len + 7) / 8); aead_len() 1694 static inline int xfrm_alg_len(const struct xfrm_algo *alg) xfrm_alg_len() argument 1696 return sizeof(*alg) + ((alg->alg_key_len + 7) / 8); xfrm_alg_len() 1699 static inline int xfrm_alg_auth_len(const struct xfrm_algo_auth *alg) xfrm_alg_auth_len() argument 1701 return sizeof(*alg) + ((alg->alg_key_len + 7) / 8); xfrm_alg_auth_len()
|
/linux-4.1.27/drivers/net/wireless/iwlwifi/mvm/ |
H A D | rx.c | 194 /* packet was encrypted with unknown alg */ iwl_mvm_set_mac80211_rx_flag() 201 /* alg is CCM: check MIC only */ iwl_mvm_set_mac80211_rx_flag() 234 IWL_ERR(mvm, "Unhandled alg: 0x%x\n", rx_pkt_status); iwl_mvm_set_mac80211_rx_flag()
|
H A D | fw-api.h | 1131 * @RX_MPDU_RES_STATUS_MIC_OK: used for CCM alg only. TKIP MIC is checked 1134 * @RX_MPDU_RES_STATUS_MNG_FRAME_REPLAY_ERR: valid for alg = CCM_CMAC or 1135 * alg = CCM only. Checks replay attack for 11w frames. Relevant only if
|
/linux-4.1.27/include/linux/mfd/abx500/ |
H A D | ab8500-bm.h | 418 * @interval_charging charge alg cycle period time when charging (sec) 419 * @interval_not_charging charge alg cycle period time when not charging (sec)
|
/linux-4.1.27/arch/mips/kernel/ |
H A D | smp-mt.c | 44 /* set config to be the same as vpe0, particularly kseg0 coherency alg */ smvp_copy_vpe_config()
|
H A D | vpe-mt.c | 442 * particularly kseg0 coherency alg vpe_module_init()
|
/linux-4.1.27/drivers/crypto/ux500/hash/ |
H A D | hash_core.c | 1347 const u8 *key, unsigned int keylen, int alg) hash_setkey() 1358 __func__, alg); hash_setkey() 1498 struct crypto_alg *alg = tfm->__crt_alg; hash_cra_init() local 1501 hash_alg = container_of(__crypto_ahash_alg(alg), hash_cra_init() 1626 dev_err(device_data->dev, "%s: alg registration failed\n", ahash_algs_register_all() 1346 hash_setkey(struct crypto_ahash *tfm, const u8 *key, unsigned int keylen, int alg) hash_setkey() argument
|
/linux-4.1.27/drivers/net/wireless/rtlwifi/ |
H A D | core.c | 1513 /* <1> get encryption alg */ rtl_op_set_key() 1518 RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG, "alg:WEP40\n"); rtl_op_set_key() 1521 RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG, "alg:WEP104\n"); rtl_op_set_key() 1526 RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG, "alg:TKIP\n"); rtl_op_set_key() 1530 RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG, "alg:CCMP\n"); rtl_op_set_key() 1537 RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG, "alg:CMAC\n"); rtl_op_set_key()
|
/linux-4.1.27/drivers/staging/rtl8712/ |
H A D | rtl871x_ioctl_linux.c | 128 if (strcmp(param->u.crypt.alg, "TKIP") == 0) { /* set mic key */ handle_pairwise_key() 403 param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0'; wpa_set_encryption() 414 if (strcmp(param->u.crypt.alg, "WEP") == 0) { wpa_set_encryption() 415 netdev_info(dev, "r8712u: %s: crypt.alg = WEP\n", __func__); wpa_set_encryption() 1795 switch (pext->alg) { r871x_wx_set_enc_ext() 1819 strncpy((char *)param->u.crypt.alg, alg_name, IEEE_CRYPT_ALG_NAME_LEN); r871x_wx_set_enc_ext()
|
H A D | ieee80211.h | 110 u8 alg[IEEE_CRYPT_ALG_NAME_LEN]; member in struct:ieee_param::__anon10218::__anon10222
|
/linux-4.1.27/drivers/block/drbd/ |
H A D | drbd_receiver.c | 3359 drbd_err(connection, "incompatible %s settings\n", "data-integrity-alg"); receive_protocol() 3380 drbd_err(connection, "peer data-integrity-alg %s not supported\n", receive_protocol() 3423 drbd_info(connection, "peer data-integrity-alg: %s\n", receive_protocol() 3441 * input: alg name, feature name 3442 * return: NULL (alg name was "") 3446 const char *alg, const char *name) drbd_crypto_alloc_digest_safe() 3450 if (!alg[0]) drbd_crypto_alloc_digest_safe() 3453 tfm = crypto_alloc_hash(alg, 0, CRYPTO_ALG_ASYNC); drbd_crypto_alloc_digest_safe() 3456 alg, name, PTR_ERR(tfm)); drbd_crypto_alloc_digest_safe() 3573 drbd_err(device, "verify-alg of wrong size, " receive_SyncParam() 3599 drbd_err(device, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n", receive_SyncParam() 3604 p->verify_alg, "verify-alg"); receive_SyncParam() 3613 drbd_err(device, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n", receive_SyncParam() 3618 p->csums_alg, "csums-alg"); receive_SyncParam() 3656 drbd_info(device, "using verify-alg: \"%s\"\n", p->verify_alg); receive_SyncParam() 3663 drbd_info(device, "using csums-alg: \"%s\"\n", p->csums_alg); receive_SyncParam() 4881 drbd_err(connection, "You need to disable 'cram-hmac-alg' in drbd.conf.\n"); drbd_do_auth() 3445 drbd_crypto_alloc_digest_safe(const struct drbd_device *device, const char *alg, const char *name) drbd_crypto_alloc_digest_safe() argument
|
/linux-4.1.27/security/keys/encrypted-keys/ |
H A D | encrypted.c | 324 static struct sdesc *alloc_sdesc(struct crypto_shash *alg) alloc_sdesc() argument 329 size = sizeof(struct shash_desc) + crypto_shash_descsize(alg); alloc_sdesc() 333 sdesc->shash.tfm = alg; alloc_sdesc()
|
/linux-4.1.27/security/keys/ |
H A D | trusted.c | 45 static struct sdesc *init_sdesc(struct crypto_shash *alg) init_sdesc() argument 50 size = sizeof(struct shash_desc) + crypto_shash_descsize(alg); init_sdesc() 54 sdesc->shash.tfm = alg; init_sdesc()
|
/linux-4.1.27/drivers/net/wireless/prism54/ |
H A D | isl_ioctl.c | 1545 int idx, alg = ext->alg, set_key = 1; prism54_set_encodeext() local 1566 alg = IW_ENCODE_ALG_NONE; prism54_set_encodeext() 1578 switch (alg) { prism54_set_encodeext() 1706 ext->alg = IW_ENCODE_ALG_NONE; prism54_get_encodeext() 1725 ext->alg = IW_ENCODE_ALG_TKIP; prism54_get_encodeext() 1729 ext->alg = IW_ENCODE_ALG_WEP; prism54_get_encodeext()
|
/linux-4.1.27/drivers/staging/rtl8723au/os_dep/ |
H A D | ioctl_cfg80211.c | 423 u32 alg, u8 keyid) set_group_key() 450 if (is_wep_enc(alg)) set_group_key() 453 psetkeyparm->algorithm = alg; set_group_key() 497 DBG_8723A("r871x_set_encryption, crypt.alg = WEP\n"); rtw_cfg80211_ap_set_encryption() 732 "wpa_set_encryption, crypt.alg = WEP\n"); rtw_cfg80211_set_encryption() 733 DBG_8723A("wpa_set_encryption, crypt.alg = WEP\n"); rtw_cfg80211_set_encryption() 422 set_group_key(struct rtw_adapter *padapter, struct key_params *parms, u32 alg, u8 keyid) set_group_key() argument
|
/linux-4.1.27/drivers/mtd/nand/ |
H A D | docg4.c | 213 #define DOCG4_T 4 /* BCH alg corrects up to 4 bit errors */ 421 * data in a bit order that is the reverse of that of the bch alg, correct_data() 439 /* undo last step in BCH alg (modulo mirroring not needed) */ correct_data()
|
/linux-4.1.27/drivers/media/i2c/ |
H A D | s5k5baf.c | 652 static void s5k5baf_hw_set_alg(struct s5k5baf *state, u16 alg, bool enable) s5k5baf_hw_set_alg() argument 661 new_alg = enable ? (cur_alg | alg) : (cur_alg & ~alg); s5k5baf_hw_set_alg()
|
/linux-4.1.27/drivers/staging/lustre/lustre/include/ |
H A D | dt_object.h | 176 __u32 alg, struct lustre_capa_key *keys); 1422 __u32 alg, struct lustre_capa_key *keys) dt_init_capa_ctxt() 1428 timeout, alg, keys); dt_init_capa_ctxt() 1419 dt_init_capa_ctxt(const struct lu_env *env, struct dt_device *dev, int mode, unsigned long timeout, __u32 alg, struct lustre_capa_key *keys) dt_init_capa_ctxt() argument
|
/linux-4.1.27/drivers/crypto/ux500/cryp/ |
H A D | cryp_core.c | 1096 struct crypto_alg *alg = tfm->__crt_alg; cryp_cra_init() local 1097 struct cryp_algo_template *cryp_alg = container_of(alg, cryp_cra_init() 1379 pr_err("[%s] alg registration failed", cryp_algs_register_all()
|
/linux-4.1.27/drivers/net/wireless/ |
H A D | atmel.c | 1854 int idx, key_len, alg = ext->alg, set_key = 1; atmel_set_encodeext() local 1866 alg = IW_ENCODE_ALG_NONE; atmel_set_encodeext() 1875 switch (alg) { atmel_set_encodeext() 1932 ext->alg = IW_ENCODE_ALG_NONE; atmel_get_encodeext() 1937 ext->alg = IW_ENCODE_ALG_WEP; atmel_get_encodeext() 2719 __le16 alg; member in struct:auth_body 2883 auth.alg = cpu_to_le16(system); send_authentication_request() 3053 u16 system = le16_to_cpu(auth->alg); authenticate()
|
H A D | rndis_wlan.c | 2296 int ret, alg, length, chan = -1; rndis_join_ibss() local 2308 alg = RNDIS_WLAN_ALG_WEP; rndis_join_ibss() 2311 alg = RNDIS_WLAN_ALG_NONE; rndis_join_ibss() 2336 ret = set_encr_mode(usbdev, alg, RNDIS_WLAN_ALG_NONE); rndis_join_ibss()
|
/linux-4.1.27/include/media/davinci/ |
H A D | isif.h | 407 __u8 alg; member in struct:isif_compress
|
/linux-4.1.27/net/sched/ |
H A D | cls_tcindex.c | 97 pr_debug("alg 0x%x\n", res->classid); tcindex_classify()
|
/linux-4.1.27/drivers/net/wireless/iwlwifi/dvm/ |
H A D | rx.c | 808 /* packet was encrypted with unknown alg */ iwlagn_translate_rx_status() 821 /* alg is CCM: check MIC only */ iwlagn_translate_rx_status()
|
/linux-4.1.27/drivers/infiniband/hw/qib/ |
H A D | qib_file_ops.c | 1430 unsigned alg) get_a_ctxt() 1446 if (alg == QIB_PORT_ALG_ACROSS) { get_a_ctxt() 1612 unsigned swmajor, swminor, alg = QIB_PORT_ALG_ACROSS; qib_assign_ctxt() local 1630 alg = uinfo->spu_port_alg; qib_assign_ctxt() 1660 ret = get_a_ctxt(fp, uinfo, alg); qib_assign_ctxt() 1429 get_a_ctxt(struct file *fp, const struct qib_user_info *uinfo, unsigned alg) get_a_ctxt() argument
|
/linux-4.1.27/fs/ecryptfs/ |
H A D | keystore.c | 2212 struct blkcipher_alg *alg = crypto_blkcipher_alg(desc.tfm); write_tag_3_packet() local 2215 "defaulting to [%d]\n", alg->max_keysize); write_tag_3_packet() 2217 alg->max_keysize; write_tag_3_packet()
|
/linux-4.1.27/include/uapi/linux/ |
H A D | wireless.h | 620 /* struct iw_encode_ext ->alg */ 838 __u16 alg; /* IW_ENCODE_ALG_* */ member in struct:iw_encode_ext
|
/linux-4.1.27/drivers/staging/rtl8723au/core/ |
H A D | rtw_mlme_ext.c | 942 DBG_8723A("auth alg =%x, seq =%X\n", algorithm, seq); OnAuth23a() 953 DBG_8723A("auth rejected due to bad alg [alg =%d, auth_mib " OnAuth23a() 5883 DBG_8723A_LEVEL(_drv_always_, "set group key to hw: alg:%d(WEP40-1 " setkey_hdl23a() 5917 DBG_8723A_LEVEL(_drv_always_, "set pairwise key to hw: alg:%d(WEP40-1 " set_stakey_hdl23a()
|
/linux-4.1.27/drivers/staging/rtl8188eu/core/ |
H A D | rtw_mlme_ext.c | 677 DBG_88E("auth alg=%x, seq=%X\n", algorithm, seq); OnAuth() 685 DBG_88E("auth rejected due to bad alg [alg=%d, auth_mib=%d] %02X%02X%02X%02X%02X%02X\n", OnAuth() 5316 DBG_88E_LEVEL(_drv_info_, "set group key to hw: alg:%d(WEP40-1 WEP104-5 TKIP-2 AES-4) " setkey_hdl() 5346 DBG_88E_LEVEL(_drv_info_, "set pairwise key to hw: alg:%d(WEP40-1 WEP104-5 TKIP-2 AES-4) camid:%d\n", set_stakey_hdl()
|
/linux-4.1.27/drivers/scsi/aic7xxx/ |
H A D | aic7xxx_osm.c | 1275 struct ahc_devinfo *devinfo, ahc_queue_alg alg) ahc_platform_set_tags() 1286 switch (alg) { ahc_platform_set_tags() 1324 } else if (alg == AHC_QUEUE_TAGGED) { ahc_platform_set_tags() 1274 ahc_platform_set_tags(struct ahc_softc *ahc, struct scsi_device *sdev, struct ahc_devinfo *devinfo, ahc_queue_alg alg) ahc_platform_set_tags() argument
|
H A D | aic79xx_osm.c | 1405 struct ahd_devinfo *devinfo, ahd_queue_alg alg) ahd_platform_set_tags() 1419 switch (alg) { ahd_platform_set_tags() 1457 } else if (alg == AHD_QUEUE_TAGGED) { ahd_platform_set_tags() 1404 ahd_platform_set_tags(struct ahd_softc *ahd, struct scsi_device *sdev, struct ahd_devinfo *devinfo, ahd_queue_alg alg) ahd_platform_set_tags() argument
|