1 /* SPDX-License-Identifier: GPL-2.0-or-later */ 2 /* 3 * Symmetric key ciphers. 4 * 5 * Copyright (c) 2007-2015 Herbert Xu <herbert@gondor.apana.org.au> 6 */ 7 8 #ifndef _CRYPTO_SKCIPHER_H 9 #define _CRYPTO_SKCIPHER_H 10 11 #include <linux/atomic.h> 12 #include <linux/container_of.h> 13 #include <linux/crypto.h> 14 #include <linux/slab.h> 15 #include <linux/string.h> 16 #include <linux/types.h> 17 18 /* Set this bit if the lskcipher operation is a continuation. */ 19 #define CRYPTO_LSKCIPHER_FLAG_CONT 0x00000001 20 /* Set this bit if the lskcipher operation is final. */ 21 #define CRYPTO_LSKCIPHER_FLAG_FINAL 0x00000002 22 /* The bit CRYPTO_TFM_REQ_MAY_SLEEP can also be set if needed. */ 23 24 /* Set this bit if the skcipher operation is a continuation. */ 25 #define CRYPTO_SKCIPHER_REQ_CONT 0x00000001 26 /* Set this bit if the skcipher operation is not final. */ 27 #define CRYPTO_SKCIPHER_REQ_NOTFINAL 0x00000002 28 29 struct scatterlist; 30 31 /** 32 * struct skcipher_request - Symmetric key cipher request 33 * @cryptlen: Number of bytes to encrypt or decrypt 34 * @iv: Initialisation Vector 35 * @src: Source SG list 36 * @dst: Destination SG list 37 * @base: Underlying async request 38 * @__ctx: Start of private context data 39 */ 40 struct skcipher_request { 41 unsigned int cryptlen; 42 43 u8 *iv; 44 45 struct scatterlist *src; 46 struct scatterlist *dst; 47 48 struct crypto_async_request base; 49 50 void *__ctx[] CRYPTO_MINALIGN_ATTR; 51 }; 52 53 struct crypto_skcipher { 54 unsigned int reqsize; 55 56 struct crypto_tfm base; 57 }; 58 59 struct crypto_sync_skcipher { 60 struct crypto_skcipher base; 61 }; 62 63 struct crypto_lskcipher { 64 struct crypto_tfm base; 65 }; 66 67 /* 68 * struct crypto_istat_cipher - statistics for cipher algorithm 69 * @encrypt_cnt: number of encrypt requests 70 * @encrypt_tlen: total data size handled by encrypt requests 71 * @decrypt_cnt: number of decrypt requests 72 * @decrypt_tlen: total data size handled by decrypt requests 73 * @err_cnt: number of error for cipher requests 74 */ 75 struct crypto_istat_cipher { 76 atomic64_t encrypt_cnt; 77 atomic64_t encrypt_tlen; 78 atomic64_t decrypt_cnt; 79 atomic64_t decrypt_tlen; 80 atomic64_t err_cnt; 81 }; 82 83 #ifdef CONFIG_CRYPTO_STATS 84 #define SKCIPHER_ALG_COMMON_STAT struct crypto_istat_cipher stat; 85 #else 86 #define SKCIPHER_ALG_COMMON_STAT 87 #endif 88 89 /* 90 * struct skcipher_alg_common - common properties of skcipher_alg 91 * @min_keysize: Minimum key size supported by the transformation. This is the 92 * smallest key length supported by this transformation algorithm. 93 * This must be set to one of the pre-defined values as this is 94 * not hardware specific. Possible values for this field can be 95 * found via git grep "_MIN_KEY_SIZE" include/crypto/ 96 * @max_keysize: Maximum key size supported by the transformation. This is the 97 * largest key length supported by this transformation algorithm. 98 * This must be set to one of the pre-defined values as this is 99 * not hardware specific. Possible values for this field can be 100 * found via git grep "_MAX_KEY_SIZE" include/crypto/ 101 * @ivsize: IV size applicable for transformation. The consumer must provide an 102 * IV of exactly that size to perform the encrypt or decrypt operation. 103 * @chunksize: Equal to the block size except for stream ciphers such as 104 * CTR where it is set to the underlying block size. 105 * @statesize: Size of the internal state for the algorithm. 106 * @stat: Statistics for cipher algorithm 107 * @base: Definition of a generic crypto algorithm. 108 */ 109 #define SKCIPHER_ALG_COMMON { \ 110 unsigned int min_keysize; \ 111 unsigned int max_keysize; \ 112 unsigned int ivsize; \ 113 unsigned int chunksize; \ 114 unsigned int statesize; \ 115 \ 116 SKCIPHER_ALG_COMMON_STAT \ 117 \ 118 struct crypto_alg base; \ 119 } 120 struct skcipher_alg_common SKCIPHER_ALG_COMMON; 121 122 /** 123 * struct skcipher_alg - symmetric key cipher definition 124 * @setkey: Set key for the transformation. This function is used to either 125 * program a supplied key into the hardware or store the key in the 126 * transformation context for programming it later. Note that this 127 * function does modify the transformation context. This function can 128 * be called multiple times during the existence of the transformation 129 * object, so one must make sure the key is properly reprogrammed into 130 * the hardware. This function is also responsible for checking the key 131 * length for validity. In case a software fallback was put in place in 132 * the @cra_init call, this function might need to use the fallback if 133 * the algorithm doesn't support all of the key sizes. 134 * @encrypt: Encrypt a scatterlist of blocks. This function is used to encrypt 135 * the supplied scatterlist containing the blocks of data. The crypto 136 * API consumer is responsible for aligning the entries of the 137 * scatterlist properly and making sure the chunks are correctly 138 * sized. In case a software fallback was put in place in the 139 * @cra_init call, this function might need to use the fallback if 140 * the algorithm doesn't support all of the key sizes. In case the 141 * key was stored in transformation context, the key might need to be 142 * re-programmed into the hardware in this function. This function 143 * shall not modify the transformation context, as this function may 144 * be called in parallel with the same transformation object. 145 * @decrypt: Decrypt a single block. This is a reverse counterpart to @encrypt 146 * and the conditions are exactly the same. 147 * @export: Export partial state of the transformation. This function dumps the 148 * entire state of the ongoing transformation into a provided block of 149 * data so it can be @import 'ed back later on. This is useful in case 150 * you want to save partial result of the transformation after 151 * processing certain amount of data and reload this partial result 152 * multiple times later on for multiple re-use. No data processing 153 * happens at this point. 154 * @import: Import partial state of the transformation. This function loads the 155 * entire state of the ongoing transformation from a provided block of 156 * data so the transformation can continue from this point onward. No 157 * data processing happens at this point. 158 * @init: Initialize the cryptographic transformation object. This function 159 * is used to initialize the cryptographic transformation object. 160 * This function is called only once at the instantiation time, right 161 * after the transformation context was allocated. In case the 162 * cryptographic hardware has some special requirements which need to 163 * be handled by software, this function shall check for the precise 164 * requirement of the transformation and put any software fallbacks 165 * in place. 166 * @exit: Deinitialize the cryptographic transformation object. This is a 167 * counterpart to @init, used to remove various changes set in 168 * @init. 169 * @walksize: Equal to the chunk size except in cases where the algorithm is 170 * considerably more efficient if it can operate on multiple chunks 171 * in parallel. Should be a multiple of chunksize. 172 * @co: see struct skcipher_alg_common 173 * 174 * All fields except @ivsize are mandatory and must be filled. 175 */ 176 struct skcipher_alg { 177 int (*setkey)(struct crypto_skcipher *tfm, const u8 *key, 178 unsigned int keylen); 179 int (*encrypt)(struct skcipher_request *req); 180 int (*decrypt)(struct skcipher_request *req); 181 int (*export)(struct skcipher_request *req, void *out); 182 int (*import)(struct skcipher_request *req, const void *in); 183 int (*init)(struct crypto_skcipher *tfm); 184 void (*exit)(struct crypto_skcipher *tfm); 185 186 unsigned int walksize; 187 188 union { 189 struct SKCIPHER_ALG_COMMON; 190 struct skcipher_alg_common co; 191 }; 192 }; 193 194 /** 195 * struct lskcipher_alg - linear symmetric key cipher definition 196 * @setkey: Set key for the transformation. This function is used to either 197 * program a supplied key into the hardware or store the key in the 198 * transformation context for programming it later. Note that this 199 * function does modify the transformation context. This function can 200 * be called multiple times during the existence of the transformation 201 * object, so one must make sure the key is properly reprogrammed into 202 * the hardware. This function is also responsible for checking the key 203 * length for validity. In case a software fallback was put in place in 204 * the @cra_init call, this function might need to use the fallback if 205 * the algorithm doesn't support all of the key sizes. 206 * @encrypt: Encrypt a number of bytes. This function is used to encrypt 207 * the supplied data. This function shall not modify 208 * the transformation context, as this function may be called 209 * in parallel with the same transformation object. Data 210 * may be left over if length is not a multiple of blocks 211 * and there is more to come (final == false). The number of 212 * left-over bytes should be returned in case of success. 213 * The siv field shall be as long as ivsize + statesize with 214 * the IV placed at the front. The state will be used by the 215 * algorithm internally. 216 * @decrypt: Decrypt a number of bytes. This is a reverse counterpart to 217 * @encrypt and the conditions are exactly the same. 218 * @init: Initialize the cryptographic transformation object. This function 219 * is used to initialize the cryptographic transformation object. 220 * This function is called only once at the instantiation time, right 221 * after the transformation context was allocated. 222 * @exit: Deinitialize the cryptographic transformation object. This is a 223 * counterpart to @init, used to remove various changes set in 224 * @init. 225 * @co: see struct skcipher_alg_common 226 */ 227 struct lskcipher_alg { 228 int (*setkey)(struct crypto_lskcipher *tfm, const u8 *key, 229 unsigned int keylen); 230 int (*encrypt)(struct crypto_lskcipher *tfm, const u8 *src, 231 u8 *dst, unsigned len, u8 *siv, u32 flags); 232 int (*decrypt)(struct crypto_lskcipher *tfm, const u8 *src, 233 u8 *dst, unsigned len, u8 *siv, u32 flags); 234 int (*init)(struct crypto_lskcipher *tfm); 235 void (*exit)(struct crypto_lskcipher *tfm); 236 237 struct skcipher_alg_common co; 238 }; 239 240 #define MAX_SYNC_SKCIPHER_REQSIZE 384 241 /* 242 * This performs a type-check against the "tfm" argument to make sure 243 * all users have the correct skcipher tfm for doing on-stack requests. 244 */ 245 #define SYNC_SKCIPHER_REQUEST_ON_STACK(name, tfm) \ 246 char __##name##_desc[sizeof(struct skcipher_request) + \ 247 MAX_SYNC_SKCIPHER_REQSIZE + \ 248 (!(sizeof((struct crypto_sync_skcipher *)1 == \ 249 (typeof(tfm))1))) \ 250 ] CRYPTO_MINALIGN_ATTR; \ 251 struct skcipher_request *name = (void *)__##name##_desc 252 253 /** 254 * DOC: Symmetric Key Cipher API 255 * 256 * Symmetric key cipher API is used with the ciphers of type 257 * CRYPTO_ALG_TYPE_SKCIPHER (listed as type "skcipher" in /proc/crypto). 258 * 259 * Asynchronous cipher operations imply that the function invocation for a 260 * cipher request returns immediately before the completion of the operation. 261 * The cipher request is scheduled as a separate kernel thread and therefore 262 * load-balanced on the different CPUs via the process scheduler. To allow 263 * the kernel crypto API to inform the caller about the completion of a cipher 264 * request, the caller must provide a callback function. That function is 265 * invoked with the cipher handle when the request completes. 266 * 267 * To support the asynchronous operation, additional information than just the 268 * cipher handle must be supplied to the kernel crypto API. That additional 269 * information is given by filling in the skcipher_request data structure. 270 * 271 * For the symmetric key cipher API, the state is maintained with the tfm 272 * cipher handle. A single tfm can be used across multiple calls and in 273 * parallel. For asynchronous block cipher calls, context data supplied and 274 * only used by the caller can be referenced the request data structure in 275 * addition to the IV used for the cipher request. The maintenance of such 276 * state information would be important for a crypto driver implementer to 277 * have, because when calling the callback function upon completion of the 278 * cipher operation, that callback function may need some information about 279 * which operation just finished if it invoked multiple in parallel. This 280 * state information is unused by the kernel crypto API. 281 */ 282 283 static inline struct crypto_skcipher *__crypto_skcipher_cast( 284 struct crypto_tfm *tfm) 285 { 286 return container_of(tfm, struct crypto_skcipher, base); 287 } 288 289 /** 290 * crypto_alloc_skcipher() - allocate symmetric key cipher handle 291 * @alg_name: is the cra_name / name or cra_driver_name / driver name of the 292 * skcipher cipher 293 * @type: specifies the type of the cipher 294 * @mask: specifies the mask for the cipher 295 * 296 * Allocate a cipher handle for an skcipher. The returned struct 297 * crypto_skcipher is the cipher handle that is required for any subsequent 298 * API invocation for that skcipher. 299 * 300 * Return: allocated cipher handle in case of success; IS_ERR() is true in case 301 * of an error, PTR_ERR() returns the error code. 302 */ 303 struct crypto_skcipher *crypto_alloc_skcipher(const char *alg_name, 304 u32 type, u32 mask); 305 306 struct crypto_sync_skcipher *crypto_alloc_sync_skcipher(const char *alg_name, 307 u32 type, u32 mask); 308 309 310 /** 311 * crypto_alloc_lskcipher() - allocate linear symmetric key cipher handle 312 * @alg_name: is the cra_name / name or cra_driver_name / driver name of the 313 * lskcipher 314 * @type: specifies the type of the cipher 315 * @mask: specifies the mask for the cipher 316 * 317 * Allocate a cipher handle for an lskcipher. The returned struct 318 * crypto_lskcipher is the cipher handle that is required for any subsequent 319 * API invocation for that lskcipher. 320 * 321 * Return: allocated cipher handle in case of success; IS_ERR() is true in case 322 * of an error, PTR_ERR() returns the error code. 323 */ 324 struct crypto_lskcipher *crypto_alloc_lskcipher(const char *alg_name, 325 u32 type, u32 mask); 326 327 static inline struct crypto_tfm *crypto_skcipher_tfm( 328 struct crypto_skcipher *tfm) 329 { 330 return &tfm->base; 331 } 332 333 static inline struct crypto_tfm *crypto_lskcipher_tfm( 334 struct crypto_lskcipher *tfm) 335 { 336 return &tfm->base; 337 } 338 339 /** 340 * crypto_free_skcipher() - zeroize and free cipher handle 341 * @tfm: cipher handle to be freed 342 * 343 * If @tfm is a NULL or error pointer, this function does nothing. 344 */ 345 static inline void crypto_free_skcipher(struct crypto_skcipher *tfm) 346 { 347 crypto_destroy_tfm(tfm, crypto_skcipher_tfm(tfm)); 348 } 349 350 static inline void crypto_free_sync_skcipher(struct crypto_sync_skcipher *tfm) 351 { 352 crypto_free_skcipher(&tfm->base); 353 } 354 355 /** 356 * crypto_free_lskcipher() - zeroize and free cipher handle 357 * @tfm: cipher handle to be freed 358 * 359 * If @tfm is a NULL or error pointer, this function does nothing. 360 */ 361 static inline void crypto_free_lskcipher(struct crypto_lskcipher *tfm) 362 { 363 crypto_destroy_tfm(tfm, crypto_lskcipher_tfm(tfm)); 364 } 365 366 /** 367 * crypto_has_skcipher() - Search for the availability of an skcipher. 368 * @alg_name: is the cra_name / name or cra_driver_name / driver name of the 369 * skcipher 370 * @type: specifies the type of the skcipher 371 * @mask: specifies the mask for the skcipher 372 * 373 * Return: true when the skcipher is known to the kernel crypto API; false 374 * otherwise 375 */ 376 int crypto_has_skcipher(const char *alg_name, u32 type, u32 mask); 377 378 static inline const char *crypto_skcipher_driver_name( 379 struct crypto_skcipher *tfm) 380 { 381 return crypto_tfm_alg_driver_name(crypto_skcipher_tfm(tfm)); 382 } 383 384 static inline const char *crypto_lskcipher_driver_name( 385 struct crypto_lskcipher *tfm) 386 { 387 return crypto_tfm_alg_driver_name(crypto_lskcipher_tfm(tfm)); 388 } 389 390 static inline struct skcipher_alg_common *crypto_skcipher_alg_common( 391 struct crypto_skcipher *tfm) 392 { 393 return container_of(crypto_skcipher_tfm(tfm)->__crt_alg, 394 struct skcipher_alg_common, base); 395 } 396 397 static inline struct skcipher_alg *crypto_skcipher_alg( 398 struct crypto_skcipher *tfm) 399 { 400 return container_of(crypto_skcipher_tfm(tfm)->__crt_alg, 401 struct skcipher_alg, base); 402 } 403 404 static inline struct lskcipher_alg *crypto_lskcipher_alg( 405 struct crypto_lskcipher *tfm) 406 { 407 return container_of(crypto_lskcipher_tfm(tfm)->__crt_alg, 408 struct lskcipher_alg, co.base); 409 } 410 411 /** 412 * crypto_skcipher_ivsize() - obtain IV size 413 * @tfm: cipher handle 414 * 415 * The size of the IV for the skcipher referenced by the cipher handle is 416 * returned. This IV size may be zero if the cipher does not need an IV. 417 * 418 * Return: IV size in bytes 419 */ 420 static inline unsigned int crypto_skcipher_ivsize(struct crypto_skcipher *tfm) 421 { 422 return crypto_skcipher_alg_common(tfm)->ivsize; 423 } 424 425 static inline unsigned int crypto_sync_skcipher_ivsize( 426 struct crypto_sync_skcipher *tfm) 427 { 428 return crypto_skcipher_ivsize(&tfm->base); 429 } 430 431 /** 432 * crypto_lskcipher_ivsize() - obtain IV size 433 * @tfm: cipher handle 434 * 435 * The size of the IV for the lskcipher referenced by the cipher handle is 436 * returned. This IV size may be zero if the cipher does not need an IV. 437 * 438 * Return: IV size in bytes 439 */ 440 static inline unsigned int crypto_lskcipher_ivsize( 441 struct crypto_lskcipher *tfm) 442 { 443 return crypto_lskcipher_alg(tfm)->co.ivsize; 444 } 445 446 /** 447 * crypto_skcipher_blocksize() - obtain block size of cipher 448 * @tfm: cipher handle 449 * 450 * The block size for the skcipher referenced with the cipher handle is 451 * returned. The caller may use that information to allocate appropriate 452 * memory for the data returned by the encryption or decryption operation 453 * 454 * Return: block size of cipher 455 */ 456 static inline unsigned int crypto_skcipher_blocksize( 457 struct crypto_skcipher *tfm) 458 { 459 return crypto_tfm_alg_blocksize(crypto_skcipher_tfm(tfm)); 460 } 461 462 /** 463 * crypto_lskcipher_blocksize() - obtain block size of cipher 464 * @tfm: cipher handle 465 * 466 * The block size for the lskcipher referenced with the cipher handle is 467 * returned. The caller may use that information to allocate appropriate 468 * memory for the data returned by the encryption or decryption operation 469 * 470 * Return: block size of cipher 471 */ 472 static inline unsigned int crypto_lskcipher_blocksize( 473 struct crypto_lskcipher *tfm) 474 { 475 return crypto_tfm_alg_blocksize(crypto_lskcipher_tfm(tfm)); 476 } 477 478 /** 479 * crypto_skcipher_chunksize() - obtain chunk size 480 * @tfm: cipher handle 481 * 482 * The block size is set to one for ciphers such as CTR. However, 483 * you still need to provide incremental updates in multiples of 484 * the underlying block size as the IV does not have sub-block 485 * granularity. This is known in this API as the chunk size. 486 * 487 * Return: chunk size in bytes 488 */ 489 static inline unsigned int crypto_skcipher_chunksize( 490 struct crypto_skcipher *tfm) 491 { 492 return crypto_skcipher_alg_common(tfm)->chunksize; 493 } 494 495 /** 496 * crypto_lskcipher_chunksize() - obtain chunk size 497 * @tfm: cipher handle 498 * 499 * The block size is set to one for ciphers such as CTR. However, 500 * you still need to provide incremental updates in multiples of 501 * the underlying block size as the IV does not have sub-block 502 * granularity. This is known in this API as the chunk size. 503 * 504 * Return: chunk size in bytes 505 */ 506 static inline unsigned int crypto_lskcipher_chunksize( 507 struct crypto_lskcipher *tfm) 508 { 509 return crypto_lskcipher_alg(tfm)->co.chunksize; 510 } 511 512 /** 513 * crypto_skcipher_statesize() - obtain state size 514 * @tfm: cipher handle 515 * 516 * Some algorithms cannot be chained with the IV alone. They carry 517 * internal state which must be replicated if data is to be processed 518 * incrementally. The size of that state can be obtained with this 519 * function. 520 * 521 * Return: state size in bytes 522 */ 523 static inline unsigned int crypto_skcipher_statesize( 524 struct crypto_skcipher *tfm) 525 { 526 return crypto_skcipher_alg_common(tfm)->statesize; 527 } 528 529 /** 530 * crypto_lskcipher_statesize() - obtain state size 531 * @tfm: cipher handle 532 * 533 * Some algorithms cannot be chained with the IV alone. They carry 534 * internal state which must be replicated if data is to be processed 535 * incrementally. The size of that state can be obtained with this 536 * function. 537 * 538 * Return: state size in bytes 539 */ 540 static inline unsigned int crypto_lskcipher_statesize( 541 struct crypto_lskcipher *tfm) 542 { 543 return crypto_lskcipher_alg(tfm)->co.statesize; 544 } 545 546 static inline unsigned int crypto_sync_skcipher_blocksize( 547 struct crypto_sync_skcipher *tfm) 548 { 549 return crypto_skcipher_blocksize(&tfm->base); 550 } 551 552 static inline unsigned int crypto_skcipher_alignmask( 553 struct crypto_skcipher *tfm) 554 { 555 return crypto_tfm_alg_alignmask(crypto_skcipher_tfm(tfm)); 556 } 557 558 static inline unsigned int crypto_lskcipher_alignmask( 559 struct crypto_lskcipher *tfm) 560 { 561 return crypto_tfm_alg_alignmask(crypto_lskcipher_tfm(tfm)); 562 } 563 564 static inline u32 crypto_skcipher_get_flags(struct crypto_skcipher *tfm) 565 { 566 return crypto_tfm_get_flags(crypto_skcipher_tfm(tfm)); 567 } 568 569 static inline void crypto_skcipher_set_flags(struct crypto_skcipher *tfm, 570 u32 flags) 571 { 572 crypto_tfm_set_flags(crypto_skcipher_tfm(tfm), flags); 573 } 574 575 static inline void crypto_skcipher_clear_flags(struct crypto_skcipher *tfm, 576 u32 flags) 577 { 578 crypto_tfm_clear_flags(crypto_skcipher_tfm(tfm), flags); 579 } 580 581 static inline u32 crypto_sync_skcipher_get_flags( 582 struct crypto_sync_skcipher *tfm) 583 { 584 return crypto_skcipher_get_flags(&tfm->base); 585 } 586 587 static inline void crypto_sync_skcipher_set_flags( 588 struct crypto_sync_skcipher *tfm, u32 flags) 589 { 590 crypto_skcipher_set_flags(&tfm->base, flags); 591 } 592 593 static inline void crypto_sync_skcipher_clear_flags( 594 struct crypto_sync_skcipher *tfm, u32 flags) 595 { 596 crypto_skcipher_clear_flags(&tfm->base, flags); 597 } 598 599 static inline u32 crypto_lskcipher_get_flags(struct crypto_lskcipher *tfm) 600 { 601 return crypto_tfm_get_flags(crypto_lskcipher_tfm(tfm)); 602 } 603 604 static inline void crypto_lskcipher_set_flags(struct crypto_lskcipher *tfm, 605 u32 flags) 606 { 607 crypto_tfm_set_flags(crypto_lskcipher_tfm(tfm), flags); 608 } 609 610 static inline void crypto_lskcipher_clear_flags(struct crypto_lskcipher *tfm, 611 u32 flags) 612 { 613 crypto_tfm_clear_flags(crypto_lskcipher_tfm(tfm), flags); 614 } 615 616 /** 617 * crypto_skcipher_setkey() - set key for cipher 618 * @tfm: cipher handle 619 * @key: buffer holding the key 620 * @keylen: length of the key in bytes 621 * 622 * The caller provided key is set for the skcipher referenced by the cipher 623 * handle. 624 * 625 * Note, the key length determines the cipher type. Many block ciphers implement 626 * different cipher modes depending on the key size, such as AES-128 vs AES-192 627 * vs. AES-256. When providing a 16 byte key for an AES cipher handle, AES-128 628 * is performed. 629 * 630 * Return: 0 if the setting of the key was successful; < 0 if an error occurred 631 */ 632 int crypto_skcipher_setkey(struct crypto_skcipher *tfm, 633 const u8 *key, unsigned int keylen); 634 635 static inline int crypto_sync_skcipher_setkey(struct crypto_sync_skcipher *tfm, 636 const u8 *key, unsigned int keylen) 637 { 638 return crypto_skcipher_setkey(&tfm->base, key, keylen); 639 } 640 641 /** 642 * crypto_lskcipher_setkey() - set key for cipher 643 * @tfm: cipher handle 644 * @key: buffer holding the key 645 * @keylen: length of the key in bytes 646 * 647 * The caller provided key is set for the lskcipher referenced by the cipher 648 * handle. 649 * 650 * Note, the key length determines the cipher type. Many block ciphers implement 651 * different cipher modes depending on the key size, such as AES-128 vs AES-192 652 * vs. AES-256. When providing a 16 byte key for an AES cipher handle, AES-128 653 * is performed. 654 * 655 * Return: 0 if the setting of the key was successful; < 0 if an error occurred 656 */ 657 int crypto_lskcipher_setkey(struct crypto_lskcipher *tfm, 658 const u8 *key, unsigned int keylen); 659 660 static inline unsigned int crypto_skcipher_min_keysize( 661 struct crypto_skcipher *tfm) 662 { 663 return crypto_skcipher_alg_common(tfm)->min_keysize; 664 } 665 666 static inline unsigned int crypto_skcipher_max_keysize( 667 struct crypto_skcipher *tfm) 668 { 669 return crypto_skcipher_alg_common(tfm)->max_keysize; 670 } 671 672 static inline unsigned int crypto_lskcipher_min_keysize( 673 struct crypto_lskcipher *tfm) 674 { 675 return crypto_lskcipher_alg(tfm)->co.min_keysize; 676 } 677 678 static inline unsigned int crypto_lskcipher_max_keysize( 679 struct crypto_lskcipher *tfm) 680 { 681 return crypto_lskcipher_alg(tfm)->co.max_keysize; 682 } 683 684 /** 685 * crypto_skcipher_reqtfm() - obtain cipher handle from request 686 * @req: skcipher_request out of which the cipher handle is to be obtained 687 * 688 * Return the crypto_skcipher handle when furnishing an skcipher_request 689 * data structure. 690 * 691 * Return: crypto_skcipher handle 692 */ 693 static inline struct crypto_skcipher *crypto_skcipher_reqtfm( 694 struct skcipher_request *req) 695 { 696 return __crypto_skcipher_cast(req->base.tfm); 697 } 698 699 static inline struct crypto_sync_skcipher *crypto_sync_skcipher_reqtfm( 700 struct skcipher_request *req) 701 { 702 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 703 704 return container_of(tfm, struct crypto_sync_skcipher, base); 705 } 706 707 /** 708 * crypto_skcipher_encrypt() - encrypt plaintext 709 * @req: reference to the skcipher_request handle that holds all information 710 * needed to perform the cipher operation 711 * 712 * Encrypt plaintext data using the skcipher_request handle. That data 713 * structure and how it is filled with data is discussed with the 714 * skcipher_request_* functions. 715 * 716 * Return: 0 if the cipher operation was successful; < 0 if an error occurred 717 */ 718 int crypto_skcipher_encrypt(struct skcipher_request *req); 719 720 /** 721 * crypto_skcipher_decrypt() - decrypt ciphertext 722 * @req: reference to the skcipher_request handle that holds all information 723 * needed to perform the cipher operation 724 * 725 * Decrypt ciphertext data using the skcipher_request handle. That data 726 * structure and how it is filled with data is discussed with the 727 * skcipher_request_* functions. 728 * 729 * Return: 0 if the cipher operation was successful; < 0 if an error occurred 730 */ 731 int crypto_skcipher_decrypt(struct skcipher_request *req); 732 733 /** 734 * crypto_skcipher_export() - export partial state 735 * @req: reference to the skcipher_request handle that holds all information 736 * needed to perform the operation 737 * @out: output buffer of sufficient size that can hold the state 738 * 739 * Export partial state of the transformation. This function dumps the 740 * entire state of the ongoing transformation into a provided block of 741 * data so it can be @import 'ed back later on. This is useful in case 742 * you want to save partial result of the transformation after 743 * processing certain amount of data and reload this partial result 744 * multiple times later on for multiple re-use. No data processing 745 * happens at this point. 746 * 747 * Return: 0 if the cipher operation was successful; < 0 if an error occurred 748 */ 749 int crypto_skcipher_export(struct skcipher_request *req, void *out); 750 751 /** 752 * crypto_skcipher_import() - import partial state 753 * @req: reference to the skcipher_request handle that holds all information 754 * needed to perform the operation 755 * @in: buffer holding the state 756 * 757 * Import partial state of the transformation. This function loads the 758 * entire state of the ongoing transformation from a provided block of 759 * data so the transformation can continue from this point onward. No 760 * data processing happens at this point. 761 * 762 * Return: 0 if the cipher operation was successful; < 0 if an error occurred 763 */ 764 int crypto_skcipher_import(struct skcipher_request *req, const void *in); 765 766 /** 767 * crypto_lskcipher_encrypt() - encrypt plaintext 768 * @tfm: lskcipher handle 769 * @src: source buffer 770 * @dst: destination buffer 771 * @len: number of bytes to process 772 * @siv: IV + state for the cipher operation. The length of the IV must 773 * comply with the IV size defined by crypto_lskcipher_ivsize. The 774 * IV is then followed with a buffer with the length as specified by 775 * crypto_lskcipher_statesize. 776 * Encrypt plaintext data using the lskcipher handle. 777 * 778 * Return: >=0 if the cipher operation was successful, if positive 779 * then this many bytes have been left unprocessed; 780 * < 0 if an error occurred 781 */ 782 int crypto_lskcipher_encrypt(struct crypto_lskcipher *tfm, const u8 *src, 783 u8 *dst, unsigned len, u8 *siv); 784 785 /** 786 * crypto_lskcipher_decrypt() - decrypt ciphertext 787 * @tfm: lskcipher handle 788 * @src: source buffer 789 * @dst: destination buffer 790 * @len: number of bytes to process 791 * @siv: IV + state for the cipher operation. The length of the IV must 792 * comply with the IV size defined by crypto_lskcipher_ivsize. The 793 * IV is then followed with a buffer with the length as specified by 794 * crypto_lskcipher_statesize. 795 * 796 * Decrypt ciphertext data using the lskcipher handle. 797 * 798 * Return: >=0 if the cipher operation was successful, if positive 799 * then this many bytes have been left unprocessed; 800 * < 0 if an error occurred 801 */ 802 int crypto_lskcipher_decrypt(struct crypto_lskcipher *tfm, const u8 *src, 803 u8 *dst, unsigned len, u8 *siv); 804 805 /** 806 * DOC: Symmetric Key Cipher Request Handle 807 * 808 * The skcipher_request data structure contains all pointers to data 809 * required for the symmetric key cipher operation. This includes the cipher 810 * handle (which can be used by multiple skcipher_request instances), pointer 811 * to plaintext and ciphertext, asynchronous callback function, etc. It acts 812 * as a handle to the skcipher_request_* API calls in a similar way as 813 * skcipher handle to the crypto_skcipher_* API calls. 814 */ 815 816 /** 817 * crypto_skcipher_reqsize() - obtain size of the request data structure 818 * @tfm: cipher handle 819 * 820 * Return: number of bytes 821 */ 822 static inline unsigned int crypto_skcipher_reqsize(struct crypto_skcipher *tfm) 823 { 824 return tfm->reqsize; 825 } 826 827 /** 828 * skcipher_request_set_tfm() - update cipher handle reference in request 829 * @req: request handle to be modified 830 * @tfm: cipher handle that shall be added to the request handle 831 * 832 * Allow the caller to replace the existing skcipher handle in the request 833 * data structure with a different one. 834 */ 835 static inline void skcipher_request_set_tfm(struct skcipher_request *req, 836 struct crypto_skcipher *tfm) 837 { 838 req->base.tfm = crypto_skcipher_tfm(tfm); 839 } 840 841 static inline void skcipher_request_set_sync_tfm(struct skcipher_request *req, 842 struct crypto_sync_skcipher *tfm) 843 { 844 skcipher_request_set_tfm(req, &tfm->base); 845 } 846 847 static inline struct skcipher_request *skcipher_request_cast( 848 struct crypto_async_request *req) 849 { 850 return container_of(req, struct skcipher_request, base); 851 } 852 853 /** 854 * skcipher_request_alloc() - allocate request data structure 855 * @tfm: cipher handle to be registered with the request 856 * @gfp: memory allocation flag that is handed to kmalloc by the API call. 857 * 858 * Allocate the request data structure that must be used with the skcipher 859 * encrypt and decrypt API calls. During the allocation, the provided skcipher 860 * handle is registered in the request data structure. 861 * 862 * Return: allocated request handle in case of success, or NULL if out of memory 863 */ 864 static inline struct skcipher_request *skcipher_request_alloc( 865 struct crypto_skcipher *tfm, gfp_t gfp) 866 { 867 struct skcipher_request *req; 868 869 req = kmalloc(sizeof(struct skcipher_request) + 870 crypto_skcipher_reqsize(tfm), gfp); 871 872 if (likely(req)) 873 skcipher_request_set_tfm(req, tfm); 874 875 return req; 876 } 877 878 /** 879 * skcipher_request_free() - zeroize and free request data structure 880 * @req: request data structure cipher handle to be freed 881 */ 882 static inline void skcipher_request_free(struct skcipher_request *req) 883 { 884 kfree_sensitive(req); 885 } 886 887 static inline void skcipher_request_zero(struct skcipher_request *req) 888 { 889 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 890 891 memzero_explicit(req, sizeof(*req) + crypto_skcipher_reqsize(tfm)); 892 } 893 894 /** 895 * skcipher_request_set_callback() - set asynchronous callback function 896 * @req: request handle 897 * @flags: specify zero or an ORing of the flags 898 * CRYPTO_TFM_REQ_MAY_BACKLOG the request queue may back log and 899 * increase the wait queue beyond the initial maximum size; 900 * CRYPTO_TFM_REQ_MAY_SLEEP the request processing may sleep 901 * @compl: callback function pointer to be registered with the request handle 902 * @data: The data pointer refers to memory that is not used by the kernel 903 * crypto API, but provided to the callback function for it to use. Here, 904 * the caller can provide a reference to memory the callback function can 905 * operate on. As the callback function is invoked asynchronously to the 906 * related functionality, it may need to access data structures of the 907 * related functionality which can be referenced using this pointer. The 908 * callback function can access the memory via the "data" field in the 909 * crypto_async_request data structure provided to the callback function. 910 * 911 * This function allows setting the callback function that is triggered once the 912 * cipher operation completes. 913 * 914 * The callback function is registered with the skcipher_request handle and 915 * must comply with the following template:: 916 * 917 * void callback_function(struct crypto_async_request *req, int error) 918 */ 919 static inline void skcipher_request_set_callback(struct skcipher_request *req, 920 u32 flags, 921 crypto_completion_t compl, 922 void *data) 923 { 924 req->base.complete = compl; 925 req->base.data = data; 926 req->base.flags = flags; 927 } 928 929 /** 930 * skcipher_request_set_crypt() - set data buffers 931 * @req: request handle 932 * @src: source scatter / gather list 933 * @dst: destination scatter / gather list 934 * @cryptlen: number of bytes to process from @src 935 * @iv: IV for the cipher operation which must comply with the IV size defined 936 * by crypto_skcipher_ivsize 937 * 938 * This function allows setting of the source data and destination data 939 * scatter / gather lists. 940 * 941 * For encryption, the source is treated as the plaintext and the 942 * destination is the ciphertext. For a decryption operation, the use is 943 * reversed - the source is the ciphertext and the destination is the plaintext. 944 */ 945 static inline void skcipher_request_set_crypt( 946 struct skcipher_request *req, 947 struct scatterlist *src, struct scatterlist *dst, 948 unsigned int cryptlen, void *iv) 949 { 950 req->src = src; 951 req->dst = dst; 952 req->cryptlen = cryptlen; 953 req->iv = iv; 954 } 955 956 #endif /* _CRYPTO_SKCIPHER_H */ 957 958