1Code Examples 2============= 3 4Code Example For Symmetric Key Cipher Operation 5----------------------------------------------- 6 7This code encrypts some data with AES-256-XTS. For sake of example, 8all inputs are random bytes, the encryption is done in-place, and it's 9assumed the code is running in a context where it can sleep. 10 11:: 12 13 static int test_skcipher(void) 14 { 15 struct crypto_skcipher *tfm = NULL; 16 struct skcipher_request *req = NULL; 17 u8 *data = NULL; 18 const size_t datasize = 512; /* data size in bytes */ 19 struct scatterlist sg; 20 DECLARE_CRYPTO_WAIT(wait); 21 u8 iv[16]; /* AES-256-XTS takes a 16-byte IV */ 22 u8 key[64]; /* AES-256-XTS takes a 64-byte key */ 23 int err; 24 25 /* 26 * Allocate a tfm (a transformation object) and set the key. 27 * 28 * In real-world use, a tfm and key are typically used for many 29 * encryption/decryption operations. But in this example, we'll just do a 30 * single encryption operation with it (which is not very efficient). 31 */ 32 33 tfm = crypto_alloc_skcipher("xts(aes)", 0, 0); 34 if (IS_ERR(tfm)) { 35 pr_err("Error allocating xts(aes) handle: %ld\n", PTR_ERR(tfm)); 36 return PTR_ERR(tfm); 37 } 38 39 get_random_bytes(key, sizeof(key)); 40 err = crypto_skcipher_setkey(tfm, key, sizeof(key)); 41 if (err) { 42 pr_err("Error setting key: %d\n", err); 43 goto out; 44 } 45 46 /* Allocate a request object */ 47 req = skcipher_request_alloc(tfm, GFP_KERNEL); 48 if (!req) { 49 err = -ENOMEM; 50 goto out; 51 } 52 53 /* Prepare the input data */ 54 data = kmalloc(datasize, GFP_KERNEL); 55 if (!data) { 56 err = -ENOMEM; 57 goto out; 58 } 59 get_random_bytes(data, datasize); 60 61 /* Initialize the IV */ 62 get_random_bytes(iv, sizeof(iv)); 63 64 /* 65 * Encrypt the data in-place. 66 * 67 * For simplicity, in this example we wait for the request to complete 68 * before proceeding, even if the underlying implementation is asynchronous. 69 * 70 * To decrypt instead of encrypt, just change crypto_skcipher_encrypt() to 71 * crypto_skcipher_decrypt(). 72 */ 73 sg_init_one(&sg, data, datasize); 74 skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG | 75 CRYPTO_TFM_REQ_MAY_SLEEP, 76 crypto_req_done, &wait); 77 skcipher_request_set_crypt(req, &sg, &sg, datasize, iv); 78 err = crypto_wait_req(crypto_skcipher_encrypt(req), &wait); 79 if (err) { 80 pr_err("Error encrypting data: %d\n", err); 81 goto out; 82 } 83 84 pr_debug("Encryption was successful\n"); 85 out: 86 crypto_free_skcipher(tfm); 87 skcipher_request_free(req); 88 kfree(data); 89 return err; 90 } 91 92 93Code Example For Use of Operational State Memory With SHASH 94----------------------------------------------------------- 95 96:: 97 98 99 struct sdesc { 100 struct shash_desc shash; 101 char ctx[]; 102 }; 103 104 static struct sdesc *init_sdesc(struct crypto_shash *alg) 105 { 106 struct sdesc *sdesc; 107 int size; 108 109 size = sizeof(struct shash_desc) + crypto_shash_descsize(alg); 110 sdesc = kmalloc(size, GFP_KERNEL); 111 if (!sdesc) 112 return ERR_PTR(-ENOMEM); 113 sdesc->shash.tfm = alg; 114 return sdesc; 115 } 116 117 static int calc_hash(struct crypto_shash *alg, 118 const unsigned char *data, unsigned int datalen, 119 unsigned char *digest) 120 { 121 struct sdesc *sdesc; 122 int ret; 123 124 sdesc = init_sdesc(alg); 125 if (IS_ERR(sdesc)) { 126 pr_info("can't alloc sdesc\n"); 127 return PTR_ERR(sdesc); 128 } 129 130 ret = crypto_shash_digest(&sdesc->shash, data, datalen, digest); 131 kfree(sdesc); 132 return ret; 133 } 134 135 static int test_hash(const unsigned char *data, unsigned int datalen, 136 unsigned char *digest) 137 { 138 struct crypto_shash *alg; 139 char *hash_alg_name = "sha1-padlock-nano"; 140 int ret; 141 142 alg = crypto_alloc_shash(hash_alg_name, 0, 0); 143 if (IS_ERR(alg)) { 144 pr_info("can't alloc alg %s\n", hash_alg_name); 145 return PTR_ERR(alg); 146 } 147 ret = calc_hash(alg, data, datalen, digest); 148 crypto_free_shash(alg); 149 return ret; 150 } 151 152 153Code Example For Random Number Generator Usage 154---------------------------------------------- 155 156:: 157 158 159 static int get_random_numbers(u8 *buf, unsigned int len) 160 { 161 struct crypto_rng *rng = NULL; 162 char *drbg = "drbg_nopr_sha256"; /* Hash DRBG with SHA-256, no PR */ 163 int ret; 164 165 if (!buf || !len) { 166 pr_debug("No output buffer provided\n"); 167 return -EINVAL; 168 } 169 170 rng = crypto_alloc_rng(drbg, 0, 0); 171 if (IS_ERR(rng)) { 172 pr_debug("could not allocate RNG handle for %s\n", drbg); 173 return PTR_ERR(rng); 174 } 175 176 ret = crypto_rng_get_bytes(rng, buf, len); 177 if (ret < 0) 178 pr_debug("generation of random numbers failed\n"); 179 else if (ret == 0) 180 pr_debug("RNG returned no data"); 181 else 182 pr_debug("RNG returned %d bytes of data\n", ret); 183 184 out: 185 crypto_free_rng(rng); 186 return ret; 187 } 188