Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
Something went wrong. Try again.
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416341734183419342034213422342334243425342634273428342934303431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461346234633464346534663467346834693470347134723473347434753476347734783479348034813482348334843485348634873488348934903491349234933494349534963497349834993500350135023503350435053506350735083509351035113512351335143515351635173518351935203521352235233524352535263527352835293530353135323533353435353536353735383539354035413542354335443545354635473548354935503551355235533554355535563557355835593560356135623563356435653566356735683569357035713572357335743575357635773578357935803581358235833584358535863587358835893590359135923593359435953596359735983599360036013602360336043605360636073608360936103611361236133614361536163617361836193620362136223623362436253626362736283629363036313632363336343635363636373638363936403641364236433644364536463647364836493650365136523653365436553656365736583659366036613662366336643665366636673668366936703671367236733674367536763677367836793680368136823683368436853686368736883689369036913692369336943695369636973698369937003701370237033704370537063707370837093710371137123713371437153716371737183719372037213722372337243725372637273728372937303731373237333734373537363737373837393740374137423743374437453746374737483749// SPDX-License-Identifier: GPL-2.0-only/* * Copyright (C) 2003 Jana Saout <jana@saout.de> * Copyright (C) 2004 Clemens Fruhwirth <clemens@endorphin.org> * Copyright (C) 2006-2020 Red Hat, Inc. All rights reserved. * Copyright (C) 2013-2020 Milan Broz <gmazyland@gmail.com> * * This file is released under the GPL. */
#include <linux/completion.h>#include <linux/err.h>#include <linux/module.h>#include <linux/hex.h>#include <linux/init.h>#include <linux/kernel.h>#include <linux/key.h>#include <linux/bio.h>#include <linux/blkdev.h>#include <linux/blk-integrity.h>#include <linux/crc32.h>#include <linux/mempool.h>#include <linux/slab.h>#include <linux/crypto.h>#include <linux/fips.h>#include <linux/workqueue.h>#include <linux/kthread.h>#include <linux/backing-dev.h>#include <linux/atomic.h>#include <linux/scatterlist.h>#include <linux/rbtree.h>#include <linux/ctype.h>#include <asm/page.h>#include <linux/unaligned.h>#include <crypto/aes.h>#include <crypto/hash.h>#include <crypto/md5.h>#include <crypto/skcipher.h>#include <crypto/aead.h>#include <crypto/authenc.h>#include <crypto/utils.h>#include <linux/rtnetlink.h> /* for struct rtattr and RTA macros only */#include <linux/key-type.h>#include <keys/user-type.h>#include <keys/encrypted-type.h>#include <keys/trusted-type.h>
#include <linux/device-mapper.h>
#include "dm-audit.h"
#define DM_MSG_PREFIX "crypt"
static DEFINE_IDA(workqueue_ida);
/* * context holding the current state of a multi-part conversion */struct convert_context { struct completion restart; struct bio *bio_in; struct bvec_iter iter_in; struct bio *bio_out; struct bvec_iter iter_out; atomic_t cc_pending; unsigned int tag_offset; u64 cc_sector; union { struct skcipher_request *req; struct aead_request *req_aead; } r; bool aead_recheck; bool aead_failed;
};
/* * per bio private data */struct dm_crypt_io { struct crypt_config *cc; struct bio *base_bio; u8 *integrity_metadata; bool integrity_metadata_from_pool:1;
struct work_struct work;
struct convert_context ctx;
atomic_t io_pending; blk_status_t error; sector_t sector;
struct bvec_iter saved_bi_iter;
struct rb_node rb_node;} CRYPTO_MINALIGN_ATTR;
struct dm_crypt_request { struct convert_context *ctx; struct scatterlist sg_in[4]; struct scatterlist sg_out[4]; u64 iv_sector;};
struct crypt_config;
struct crypt_iv_operations { int (*ctr)(struct crypt_config *cc, struct dm_target *ti, const char *opts); void (*dtr)(struct crypt_config *cc); int (*init)(struct crypt_config *cc); void (*wipe)(struct crypt_config *cc); int (*generator)(struct crypt_config *cc, u8 *iv, struct dm_crypt_request *dmreq); void (*post)(struct crypt_config *cc, u8 *iv, struct dm_crypt_request *dmreq);};
struct iv_benbi_private { int shift;};
#define LMK_SEED_SIZE 64 /* hash + 0 */struct iv_lmk_private { u8 *seed;};
#define TCW_WHITENING_SIZE 16struct iv_tcw_private { u8 *iv_seed; u8 *whitening;};
#define ELEPHANT_MAX_KEY_SIZE 32struct iv_elephant_private { struct aes_enckey *key;};
/* * Crypt: maps a linear range of a block device * and encrypts / decrypts at the same time. */enum flags { DM_CRYPT_SUSPENDED, DM_CRYPT_KEY_VALID, DM_CRYPT_SAME_CPU, DM_CRYPT_HIGH_PRIORITY, DM_CRYPT_NO_OFFLOAD, DM_CRYPT_NO_READ_WORKQUEUE, DM_CRYPT_NO_WRITE_WORKQUEUE, DM_CRYPT_WRITE_INLINE };
enum cipher_flags { CRYPT_MODE_INTEGRITY_AEAD, /* Use authenticated mode for cipher */ CRYPT_IV_LARGE_SECTORS, /* Calculate IV from sector_size, not 512B sectors */ CRYPT_ENCRYPT_PREPROCESS, /* Must preprocess data for encryption (elephant) */ CRYPT_KEY_MAC_SIZE_SET, /* The integrity_key_size option was used */};
/* * The fields in here must be read only after initialization. */struct crypt_config { struct dm_dev *dev; sector_t start;
struct percpu_counter n_allocated_pages;
struct workqueue_struct *io_queue; struct workqueue_struct *crypt_queue;
spinlock_t write_thread_lock; struct task_struct *write_thread; struct rb_root write_tree;
char *cipher_string; char *cipher_auth; char *key_string;
const struct crypt_iv_operations *iv_gen_ops; union { struct iv_benbi_private benbi; struct iv_lmk_private lmk; struct iv_tcw_private tcw; struct iv_elephant_private elephant; } iv_gen_private; u64 iv_offset; unsigned int iv_size; unsigned int sector_size; unsigned char sector_shift;
union { struct crypto_skcipher **tfms; struct crypto_aead **tfms_aead; } cipher_tfm; unsigned int tfms_count; int workqueue_id; unsigned long cipher_flags;
/* * Layout of each crypto request: * * struct skcipher_request * context * padding * struct dm_crypt_request * padding * IV * * The padding is added so that dm_crypt_request and the IV are * correctly aligned. */ unsigned int dmreq_start;
unsigned int per_bio_data_size;
unsigned long flags; unsigned int key_size; unsigned int key_parts; /* independent parts in key buffer */ unsigned int key_extra_size; /* additional keys length */ unsigned int key_mac_size; /* MAC key size for authenc(...) */
unsigned int integrity_tag_size; unsigned int integrity_iv_size; unsigned int used_tag_size; unsigned int tuple_size;
/* * pool for per bio private data, crypto requests, * encryption requeusts/buffer pages and integrity tags */ unsigned int tag_pool_max_sectors; mempool_t tag_pool; mempool_t req_pool; mempool_t page_pool;
struct bio_set bs; struct mutex bio_alloc_lock;
u8 *authenc_key; /* space for keys in authenc() format (if used) */ u8 key[] __counted_by(key_size);};
#define MIN_IOS 64#define MAX_TAG_SIZE 480#define POOL_ENTRY_SIZE 512
/* * Largest encryption sector size that can be requested with the * "sector_size:<bytes>" option. * * A sector is handed to the crypto API as a single scatterlist entry, so it * has to be covered by one bio_vec. bio_iter_iovec() never returns more than * PAGE_SIZE bytes, and crypt_alloc_buffer() may fall back to order-0 pages * for the write bounce buffer, so PAGE_SIZE is the ceiling. * * crypt_io_hints() announces the sector size as the logical block size, which * the block layer caps at BLK_MAX_BLOCK_SIZE. That cap is never below * PAGE_SIZE in any configuration today, so it does not lower the limit; take * the minimum anyway so that this target cannot announce a block size * blk_validate_limits() would reject. */#define DM_CRYPT_MAX_SECTOR_SIZE MIN_T(unsigned int, PAGE_SIZE, \ BLK_MAX_BLOCK_SIZE)
static DEFINE_SPINLOCK(dm_crypt_clients_lock);static unsigned int dm_crypt_clients_n;static volatile unsigned long dm_crypt_pages_per_client;#define DM_CRYPT_MEMORY_PERCENT 2#define DM_CRYPT_MIN_PAGES_PER_CLIENT (BIO_MAX_VECS * 16)#define DM_CRYPT_DEFAULT_MAX_READ_SIZE 131072#define DM_CRYPT_DEFAULT_MAX_WRITE_SIZE 131072
static unsigned int max_read_size = 0;module_param(max_read_size, uint, 0644);MODULE_PARM_DESC(max_read_size, "Maximum size of a read request");static unsigned int max_write_size = 0;module_param(max_write_size, uint, 0644);MODULE_PARM_DESC(max_write_size, "Maximum size of a write request");
static unsigned get_max_request_sectors(struct dm_target *ti, struct bio *bio, bool no_split){ struct crypt_config *cc = ti->private; unsigned val, sector_align; bool wrt = op_is_write(bio_op(bio));
if (no_split) { val = -1; } else if (wrt) { val = min_not_zero(READ_ONCE(max_write_size), DM_CRYPT_DEFAULT_MAX_WRITE_SIZE); } else { val = min_not_zero(READ_ONCE(max_read_size), DM_CRYPT_DEFAULT_MAX_READ_SIZE); }
if (wrt || cc->used_tag_size) val = min(val, BIO_MAX_VECS << PAGE_SHIFT);
sector_align = max(bdev_logical_block_size(cc->dev->bdev), (unsigned)cc->sector_size); val = round_down(val, sector_align); if (unlikely(!val)) val = sector_align; return val >> SECTOR_SHIFT;}
static void crypt_endio(struct bio *clone);static void kcryptd_queue_crypt(struct dm_crypt_io *io);static struct scatterlist *crypt_get_sg_data(struct crypt_config *cc, struct scatterlist *sg);
static bool crypt_integrity_aead(struct crypt_config *cc);
/* * Use this to access cipher attributes that are independent of the key. */static struct crypto_skcipher *any_tfm(struct crypt_config *cc){ return cc->cipher_tfm.tfms[0];}
static struct crypto_aead *any_tfm_aead(struct crypt_config *cc){ return cc->cipher_tfm.tfms_aead[0];}
/* * Different IV generation algorithms: * * plain: the initial vector is the 32-bit little-endian version of the sector * number, padded with zeros if necessary. * * plain64: the initial vector is the 64-bit little-endian version of the sector * number, padded with zeros if necessary. * * plain64be: the initial vector is the 64-bit big-endian version of the sector * number, padded with zeros if necessary. * * essiv: "encrypted sector|salt initial vector", the sector number is * encrypted with the bulk cipher using a salt as key. The salt * should be derived from the bulk cipher's key via hashing. * * benbi: the 64-bit "big-endian 'narrow block'-count", starting at 1 * (needed for LRW-32-AES and possible other narrow block modes) * * null: the initial vector is always zero. Provides compatibility with * obsolete loop_fish2 devices. Do not use for new devices. * * lmk: Compatible implementation of the block chaining mode used * by the Loop-AES block device encryption system * designed by Jari Ruusu. See http://loop-aes.sourceforge.net/ * It operates on full 512 byte sectors and uses CBC * with an IV derived from the sector number, the data and * optionally extra IV seed. * This means that after decryption the first block * of sector must be tweaked according to decrypted data. * Loop-AES can use three encryption schemes: * version 1: is plain aes-cbc mode * version 2: uses 64 multikey scheme with lmk IV generator * version 3: the same as version 2 with additional IV seed * (it uses 65 keys, last key is used as IV seed) * * tcw: Compatible implementation of the block chaining mode used * by the TrueCrypt device encryption system (prior to version 4.1). * For more info see: https://gitlab.com/cryptsetup/cryptsetup/wikis/TrueCryptOnDiskFormat * It operates on full 512 byte sectors and uses CBC * with an IV derived from initial key and the sector number. * In addition, whitening value is applied on every sector, whitening * is calculated from initial key, sector number and mixed using CRC32. * Note that this encryption scheme is vulnerable to watermarking attacks * and should be used for old compatible containers access only. * * eboiv: Encrypted byte-offset IV (used in Bitlocker in CBC mode) * The IV is encrypted little-endian byte-offset (with the same key * and cipher as the volume). * * elephant: The extended version of eboiv with additional Elephant diffuser * used with Bitlocker CBC mode. * This mode was used in older Windows systems * https://download.microsoft.com/download/0/2/3/0238acaf-d3bf-4a6d-b3d6-0a0be4bbb36e/bitlockercipher200608.pdf */
static int crypt_iv_plain_gen(struct crypt_config *cc, u8 *iv, struct dm_crypt_request *dmreq){ memset(iv, 0, cc->iv_size); *(__le32 *)iv = cpu_to_le32(dmreq->iv_sector & 0xffffffff);
return 0;}
static int crypt_iv_plain64_gen(struct crypt_config *cc, u8 *iv, struct dm_crypt_request *dmreq){ memset(iv, 0, cc->iv_size); *(__le64 *)iv = cpu_to_le64(dmreq->iv_sector);
return 0;}
static int crypt_iv_plain64be_gen(struct crypt_config *cc, u8 *iv, struct dm_crypt_request *dmreq){ memset(iv, 0, cc->iv_size); /* iv_size is at least of size u64; usually it is 16 bytes */ *(__be64 *)&iv[cc->iv_size - sizeof(u64)] = cpu_to_be64(dmreq->iv_sector);
return 0;}
static int crypt_iv_essiv_gen(struct crypt_config *cc, u8 *iv, struct dm_crypt_request *dmreq){ /* * ESSIV encryption of the IV is now handled by the crypto API, * so just pass the plain sector number here. */ memset(iv, 0, cc->iv_size); *(__le64 *)iv = cpu_to_le64(dmreq->iv_sector);
return 0;}
static int crypt_iv_benbi_ctr(struct crypt_config *cc, struct dm_target *ti, const char *opts){ unsigned int bs; int log;
if (crypt_integrity_aead(cc)) bs = crypto_aead_blocksize(any_tfm_aead(cc)); else bs = crypto_skcipher_blocksize(any_tfm(cc)); log = ilog2(bs);
/* * We need to calculate how far we must shift the sector count * to get the cipher block count, we use this shift in _gen. */ if (1 << log != bs) { ti->error = "cypher blocksize is not a power of 2"; return -EINVAL; }
if (log > 9) { ti->error = "cypher blocksize is > 512"; return -EINVAL; }
cc->iv_gen_private.benbi.shift = 9 - log;
return 0;}
static void crypt_iv_benbi_dtr(struct crypt_config *cc){}
static int crypt_iv_benbi_gen(struct crypt_config *cc, u8 *iv, struct dm_crypt_request *dmreq){ __be64 val;
memset(iv, 0, cc->iv_size - sizeof(u64)); /* rest is cleared below */
val = cpu_to_be64(((u64)dmreq->iv_sector << cc->iv_gen_private.benbi.shift) + 1); put_unaligned(val, (__be64 *)(iv + cc->iv_size - sizeof(u64)));
return 0;}
static int crypt_iv_null_gen(struct crypt_config *cc, u8 *iv, struct dm_crypt_request *dmreq){ memset(iv, 0, cc->iv_size);
return 0;}
static void crypt_iv_lmk_dtr(struct crypt_config *cc){ struct iv_lmk_private *lmk = &cc->iv_gen_private.lmk;
kfree_sensitive(lmk->seed); lmk->seed = NULL;}
static int crypt_iv_lmk_ctr(struct crypt_config *cc, struct dm_target *ti, const char *opts){ struct iv_lmk_private *lmk = &cc->iv_gen_private.lmk;
if (cc->sector_size != (1 << SECTOR_SHIFT)) { ti->error = "Unsupported sector size for LMK"; return -EINVAL; }
if (fips_enabled) { ti->error = "LMK support is disabled due to FIPS"; /* ... because it uses MD5. */ return -EINVAL; }
/* No seed in LMK version 2 */ if (cc->key_parts == cc->tfms_count) { lmk->seed = NULL; return 0; }
lmk->seed = kzalloc(LMK_SEED_SIZE, GFP_KERNEL); if (!lmk->seed) { ti->error = "Error kmallocing seed storage in LMK"; return -ENOMEM; }
return 0;}
static int crypt_iv_lmk_init(struct crypt_config *cc){ struct iv_lmk_private *lmk = &cc->iv_gen_private.lmk; int subkey_size = cc->key_size / cc->key_parts;
/* LMK seed is on the position of LMK_KEYS + 1 key */ if (lmk->seed) memcpy(lmk->seed, cc->key + (cc->tfms_count * subkey_size), MD5_DIGEST_SIZE);
return 0;}
static void crypt_iv_lmk_wipe(struct crypt_config *cc){ struct iv_lmk_private *lmk = &cc->iv_gen_private.lmk;
if (lmk->seed) memzero_explicit(lmk->seed, LMK_SEED_SIZE);}
static void crypt_iv_lmk_one(struct crypt_config *cc, u8 *iv, struct dm_crypt_request *dmreq, u8 *data){ struct iv_lmk_private *lmk = &cc->iv_gen_private.lmk; struct md5_ctx ctx; __le32 buf[4];
md5_init(&ctx);
if (lmk->seed) md5_update(&ctx, lmk->seed, LMK_SEED_SIZE);
/* Sector is always 512B, block size 16, add data of blocks 1-31 */ md5_update(&ctx, data + 16, 16 * 31);
/* Sector is cropped to 56 bits here */ buf[0] = cpu_to_le32(dmreq->iv_sector & 0xFFFFFFFF); buf[1] = cpu_to_le32((((u64)dmreq->iv_sector >> 32) & 0x00FFFFFF) | 0x80000000); buf[2] = cpu_to_le32(4024); buf[3] = 0; md5_update(&ctx, (u8 *)buf, sizeof(buf));
/* No MD5 padding here */ cpu_to_le32_array(ctx.state.h, ARRAY_SIZE(ctx.state.h)); memcpy(iv, ctx.state.h, cc->iv_size);}
static int crypt_iv_lmk_gen(struct crypt_config *cc, u8 *iv, struct dm_crypt_request *dmreq){ struct scatterlist *sg; u8 *src;
if (bio_data_dir(dmreq->ctx->bio_in) == WRITE) { sg = crypt_get_sg_data(cc, dmreq->sg_in); src = kmap_local_page(sg_page(sg)); crypt_iv_lmk_one(cc, iv, dmreq, src + sg->offset); kunmap_local(src); } else memset(iv, 0, cc->iv_size); return 0;}
static void crypt_iv_lmk_post(struct crypt_config *cc, u8 *iv, struct dm_crypt_request *dmreq){ struct scatterlist *sg; u8 *dst;
if (bio_data_dir(dmreq->ctx->bio_in) == WRITE) return;
sg = crypt_get_sg_data(cc, dmreq->sg_out); dst = kmap_local_page(sg_page(sg)); crypt_iv_lmk_one(cc, iv, dmreq, dst + sg->offset);
/* Tweak the first block of plaintext sector */ crypto_xor(dst + sg->offset, iv, cc->iv_size);
kunmap_local(dst);}
static void crypt_iv_tcw_dtr(struct crypt_config *cc){ struct iv_tcw_private *tcw = &cc->iv_gen_private.tcw;
kfree_sensitive(tcw->iv_seed); tcw->iv_seed = NULL; kfree_sensitive(tcw->whitening); tcw->whitening = NULL;}
static int crypt_iv_tcw_ctr(struct crypt_config *cc, struct dm_target *ti, const char *opts){ struct iv_tcw_private *tcw = &cc->iv_gen_private.tcw;
if (cc->sector_size != (1 << SECTOR_SHIFT)) { ti->error = "Unsupported sector size for TCW"; return -EINVAL; }
if (cc->key_size <= (cc->iv_size + TCW_WHITENING_SIZE)) { ti->error = "Wrong key size for TCW"; return -EINVAL; }
tcw->iv_seed = kzalloc(cc->iv_size, GFP_KERNEL); tcw->whitening = kzalloc(TCW_WHITENING_SIZE, GFP_KERNEL); if (!tcw->iv_seed || !tcw->whitening) { crypt_iv_tcw_dtr(cc); ti->error = "Error allocating seed storage in TCW"; return -ENOMEM; }
return 0;}
static int crypt_iv_tcw_init(struct crypt_config *cc){ struct iv_tcw_private *tcw = &cc->iv_gen_private.tcw; int key_offset = cc->key_size - cc->iv_size - TCW_WHITENING_SIZE;
memcpy(tcw->iv_seed, &cc->key[key_offset], cc->iv_size); memcpy(tcw->whitening, &cc->key[key_offset + cc->iv_size], TCW_WHITENING_SIZE);
return 0;}
static void crypt_iv_tcw_wipe(struct crypt_config *cc){ struct iv_tcw_private *tcw = &cc->iv_gen_private.tcw;
memzero_explicit(tcw->iv_seed, cc->iv_size); memzero_explicit(tcw->whitening, TCW_WHITENING_SIZE);}
static void crypt_iv_tcw_whitening(struct crypt_config *cc, struct dm_crypt_request *dmreq, u8 *data){ struct iv_tcw_private *tcw = &cc->iv_gen_private.tcw; __le64 sector = cpu_to_le64(dmreq->iv_sector); u8 buf[TCW_WHITENING_SIZE]; int i;
/* xor whitening with sector number */ crypto_xor_cpy(buf, tcw->whitening, (u8 *)§or, 8); crypto_xor_cpy(&buf[8], tcw->whitening + 8, (u8 *)§or, 8);
/* calculate crc32 for every 32bit part and xor it */ for (i = 0; i < 4; i++) put_unaligned_le32(crc32(0, &buf[i * 4], 4), &buf[i * 4]); crypto_xor(&buf[0], &buf[12], 4); crypto_xor(&buf[4], &buf[8], 4);
/* apply whitening (8 bytes) to whole sector */ for (i = 0; i < ((1 << SECTOR_SHIFT) / 8); i++) crypto_xor(data + i * 8, buf, 8); memzero_explicit(buf, sizeof(buf));}
static int crypt_iv_tcw_gen(struct crypt_config *cc, u8 *iv, struct dm_crypt_request *dmreq){ struct scatterlist *sg; struct iv_tcw_private *tcw = &cc->iv_gen_private.tcw; __le64 sector = cpu_to_le64(dmreq->iv_sector); u8 *src;
/* Remove whitening from ciphertext */ if (bio_data_dir(dmreq->ctx->bio_in) != WRITE) { sg = crypt_get_sg_data(cc, dmreq->sg_in); src = kmap_local_page(sg_page(sg)); crypt_iv_tcw_whitening(cc, dmreq, src + sg->offset); kunmap_local(src); }
/* Calculate IV */ crypto_xor_cpy(iv, tcw->iv_seed, (u8 *)§or, 8); if (cc->iv_size > 8) crypto_xor_cpy(&iv[8], tcw->iv_seed + 8, (u8 *)§or, cc->iv_size - 8);
return 0;}
static void crypt_iv_tcw_post(struct crypt_config *cc, u8 *iv, struct dm_crypt_request *dmreq){ struct scatterlist *sg; u8 *dst;
if (bio_data_dir(dmreq->ctx->bio_in) != WRITE) return;
/* Apply whitening on ciphertext */ sg = crypt_get_sg_data(cc, dmreq->sg_out); dst = kmap_local_page(sg_page(sg)); crypt_iv_tcw_whitening(cc, dmreq, dst + sg->offset); kunmap_local(dst);}
static int crypt_iv_random_gen(struct crypt_config *cc, u8 *iv, struct dm_crypt_request *dmreq){ /* Used only for writes, there must be an additional space to store IV */ get_random_bytes(iv, cc->iv_size); return 0;}
static int crypt_iv_eboiv_ctr(struct crypt_config *cc, struct dm_target *ti, const char *opts){ if (crypt_integrity_aead(cc)) { ti->error = "AEAD transforms not supported for EBOIV"; return -EINVAL; }
if (crypto_skcipher_blocksize(any_tfm(cc)) != cc->iv_size) { ti->error = "Block size of EBOIV cipher does not match IV size of block cipher"; return -EINVAL; }
return 0;}
static int crypt_iv_eboiv_gen(struct crypt_config *cc, u8 *iv, struct dm_crypt_request *dmreq){ struct crypto_skcipher *tfm = any_tfm(cc); struct skcipher_request *req; struct scatterlist src, dst; DECLARE_CRYPTO_WAIT(wait); unsigned int reqsize; int err; u8 *buf;
reqsize = sizeof(*req) + crypto_skcipher_reqsize(tfm); reqsize = ALIGN(reqsize, __alignof__(__le64));
req = kmalloc(reqsize + cc->iv_size, GFP_NOIO); if (!req) return -ENOMEM;
skcipher_request_set_tfm(req, tfm);
buf = (u8 *)req + reqsize; memset(buf, 0, cc->iv_size); *(__le64 *)buf = cpu_to_le64(dmreq->iv_sector * cc->sector_size);
sg_init_one(&src, page_address(ZERO_PAGE(0)), cc->iv_size); sg_init_one(&dst, iv, cc->iv_size); skcipher_request_set_crypt(req, &src, &dst, cc->iv_size, buf); skcipher_request_set_callback(req, 0, crypto_req_done, &wait); err = crypto_wait_req(crypto_skcipher_encrypt(req), &wait); kfree_sensitive(req);
return err;}
static void crypt_iv_elephant_dtr(struct crypt_config *cc){ struct iv_elephant_private *elephant = &cc->iv_gen_private.elephant;
kfree_sensitive(elephant->key); elephant->key = NULL;}
static int crypt_iv_elephant_ctr(struct crypt_config *cc, struct dm_target *ti, const char *opts){ struct iv_elephant_private *elephant = &cc->iv_gen_private.elephant; int r;
elephant->key = kmalloc_obj(*elephant->key); if (!elephant->key) return -ENOMEM;
r = crypt_iv_eboiv_ctr(cc, ti, NULL); if (r) crypt_iv_elephant_dtr(cc); return r;}
static void diffuser_disk_to_cpu(u32 *d, size_t n){#ifndef __LITTLE_ENDIAN int i;
for (i = 0; i < n; i++) d[i] = le32_to_cpu((__le32)d[i]);#endif}
static void diffuser_cpu_to_disk(__le32 *d, size_t n){#ifndef __LITTLE_ENDIAN int i;
for (i = 0; i < n; i++) d[i] = cpu_to_le32((u32)d[i]);#endif}
static void diffuser_a_decrypt(u32 *d, size_t n){ int i, i1, i2, i3;
for (i = 0; i < 5; i++) { i1 = 0; i2 = n - 2; i3 = n - 5;
while (i1 < (n - 1)) { d[i1] += d[i2] ^ (d[i3] << 9 | d[i3] >> 23); i1++; i2++; i3++;
if (i3 >= n) i3 -= n;
d[i1] += d[i2] ^ d[i3]; i1++; i2++; i3++;
if (i2 >= n) i2 -= n;
d[i1] += d[i2] ^ (d[i3] << 13 | d[i3] >> 19); i1++; i2++; i3++;
d[i1] += d[i2] ^ d[i3]; i1++; i2++; i3++; } }}
static void diffuser_a_encrypt(u32 *d, size_t n){ int i, i1, i2, i3;
for (i = 0; i < 5; i++) { i1 = n - 1; i2 = n - 2 - 1; i3 = n - 5 - 1;
while (i1 > 0) { d[i1] -= d[i2] ^ d[i3]; i1--; i2--; i3--;
d[i1] -= d[i2] ^ (d[i3] << 13 | d[i3] >> 19); i1--; i2--; i3--;
if (i2 < 0) i2 += n;
d[i1] -= d[i2] ^ d[i3]; i1--; i2--; i3--;
if (i3 < 0) i3 += n;
d[i1] -= d[i2] ^ (d[i3] << 9 | d[i3] >> 23); i1--; i2--; i3--; } }}
static void diffuser_b_decrypt(u32 *d, size_t n){ int i, i1, i2, i3;
for (i = 0; i < 3; i++) { i1 = 0; i2 = 2; i3 = 5;
while (i1 < (n - 1)) { d[i1] += d[i2] ^ d[i3]; i1++; i2++; i3++;
d[i1] += d[i2] ^ (d[i3] << 10 | d[i3] >> 22); i1++; i2++; i3++;
if (i2 >= n) i2 -= n;
d[i1] += d[i2] ^ d[i3]; i1++; i2++; i3++;
if (i3 >= n) i3 -= n;
d[i1] += d[i2] ^ (d[i3] << 25 | d[i3] >> 7); i1++; i2++; i3++; } }}
static void diffuser_b_encrypt(u32 *d, size_t n){ int i, i1, i2, i3;
for (i = 0; i < 3; i++) { i1 = n - 1; i2 = 2 - 1; i3 = 5 - 1;
while (i1 > 0) { d[i1] -= d[i2] ^ (d[i3] << 25 | d[i3] >> 7); i1--; i2--; i3--;
if (i3 < 0) i3 += n;
d[i1] -= d[i2] ^ d[i3]; i1--; i2--; i3--;
if (i2 < 0) i2 += n;
d[i1] -= d[i2] ^ (d[i3] << 10 | d[i3] >> 22); i1--; i2--; i3--;
d[i1] -= d[i2] ^ d[i3]; i1--; i2--; i3--; } }}
static void crypt_iv_elephant(struct crypt_config *cc, struct dm_crypt_request *dmreq){ struct iv_elephant_private *elephant = &cc->iv_gen_private.elephant; u8 *data, *data2, *data_offset; struct scatterlist *sg, *sg2; union { __le64 w[2]; u8 b[16]; } es; u8 ks[32] __aligned(__alignof(long)); /* Elephant sector key */ int i;
es.w[0] = cpu_to_le64(dmreq->iv_sector * cc->sector_size); es.w[1] = 0;
/* E(Ks, e(s)) */ aes_encrypt(elephant->key, &ks[0], es.b);
/* E(Ks, e'(s)) */ es.b[15] = 0x80; aes_encrypt(elephant->key, &ks[16], es.b);
sg = crypt_get_sg_data(cc, dmreq->sg_out); data = kmap_local_page(sg_page(sg)); data_offset = data + sg->offset;
/* Cannot modify original bio, copy to sg_out and apply Elephant to it */ if (bio_data_dir(dmreq->ctx->bio_in) == WRITE) { sg2 = crypt_get_sg_data(cc, dmreq->sg_in); data2 = kmap_local_page(sg_page(sg2)); memcpy(data_offset, data2 + sg2->offset, cc->sector_size); kunmap_local(data2); }
if (bio_data_dir(dmreq->ctx->bio_in) != WRITE) { diffuser_disk_to_cpu((u32 *)data_offset, cc->sector_size / sizeof(u32)); diffuser_b_decrypt((u32 *)data_offset, cc->sector_size / sizeof(u32)); diffuser_a_decrypt((u32 *)data_offset, cc->sector_size / sizeof(u32)); diffuser_cpu_to_disk((__le32 *)data_offset, cc->sector_size / sizeof(u32)); }
for (i = 0; i < (cc->sector_size / 32); i++) crypto_xor(data_offset + i * 32, ks, 32);
if (bio_data_dir(dmreq->ctx->bio_in) == WRITE) { diffuser_disk_to_cpu((u32 *)data_offset, cc->sector_size / sizeof(u32)); diffuser_a_encrypt((u32 *)data_offset, cc->sector_size / sizeof(u32)); diffuser_b_encrypt((u32 *)data_offset, cc->sector_size / sizeof(u32)); diffuser_cpu_to_disk((__le32 *)data_offset, cc->sector_size / sizeof(u32)); }
kunmap_local(data); memzero_explicit(ks, sizeof(ks)); memzero_explicit(&es, sizeof(es));}
static int crypt_iv_elephant_gen(struct crypt_config *cc, u8 *iv, struct dm_crypt_request *dmreq){ if (bio_data_dir(dmreq->ctx->bio_in) == WRITE) crypt_iv_elephant(cc, dmreq);
return crypt_iv_eboiv_gen(cc, iv, dmreq);}
static void crypt_iv_elephant_post(struct crypt_config *cc, u8 *iv, struct dm_crypt_request *dmreq){ if (bio_data_dir(dmreq->ctx->bio_in) != WRITE) crypt_iv_elephant(cc, dmreq);}
static int crypt_iv_elephant_init(struct crypt_config *cc){ struct iv_elephant_private *elephant = &cc->iv_gen_private.elephant; int key_offset = cc->key_size - cc->key_extra_size;
return aes_prepareenckey(elephant->key, &cc->key[key_offset], cc->key_extra_size);}
static void crypt_iv_elephant_wipe(struct crypt_config *cc){ struct iv_elephant_private *elephant = &cc->iv_gen_private.elephant;
memzero_explicit(elephant->key, sizeof(*elephant->key));}
static const struct crypt_iv_operations crypt_iv_plain_ops = { .generator = crypt_iv_plain_gen};
static const struct crypt_iv_operations crypt_iv_plain64_ops = { .generator = crypt_iv_plain64_gen};
static const struct crypt_iv_operations crypt_iv_plain64be_ops = { .generator = crypt_iv_plain64be_gen};
static const struct crypt_iv_operations crypt_iv_essiv_ops = { .generator = crypt_iv_essiv_gen};
static const struct crypt_iv_operations crypt_iv_benbi_ops = { .ctr = crypt_iv_benbi_ctr, .dtr = crypt_iv_benbi_dtr, .generator = crypt_iv_benbi_gen};
static const struct crypt_iv_operations crypt_iv_null_ops = { .generator = crypt_iv_null_gen};
static const struct crypt_iv_operations crypt_iv_lmk_ops = { .ctr = crypt_iv_lmk_ctr, .dtr = crypt_iv_lmk_dtr, .init = crypt_iv_lmk_init, .wipe = crypt_iv_lmk_wipe, .generator = crypt_iv_lmk_gen, .post = crypt_iv_lmk_post};
static const struct crypt_iv_operations crypt_iv_tcw_ops = { .ctr = crypt_iv_tcw_ctr, .dtr = crypt_iv_tcw_dtr, .init = crypt_iv_tcw_init, .wipe = crypt_iv_tcw_wipe, .generator = crypt_iv_tcw_gen, .post = crypt_iv_tcw_post};
static const struct crypt_iv_operations crypt_iv_random_ops = { .generator = crypt_iv_random_gen};
static const struct crypt_iv_operations crypt_iv_eboiv_ops = { .ctr = crypt_iv_eboiv_ctr, .generator = crypt_iv_eboiv_gen};
static const struct crypt_iv_operations crypt_iv_elephant_ops = { .ctr = crypt_iv_elephant_ctr, .dtr = crypt_iv_elephant_dtr, .init = crypt_iv_elephant_init, .wipe = crypt_iv_elephant_wipe, .generator = crypt_iv_elephant_gen, .post = crypt_iv_elephant_post};
/* * Integrity extensions */static bool crypt_integrity_aead(struct crypt_config *cc){ return test_bit(CRYPT_MODE_INTEGRITY_AEAD, &cc->cipher_flags);}
static bool crypt_integrity_hmac(struct crypt_config *cc){ return crypt_integrity_aead(cc) && cc->key_mac_size;}
/* Get sg containing data */static struct scatterlist *crypt_get_sg_data(struct crypt_config *cc, struct scatterlist *sg){ if (unlikely(crypt_integrity_aead(cc))) return &sg[2];
return sg;}
static int dm_crypt_integrity_io_alloc(struct dm_crypt_io *io, struct bio *bio){ struct bio_integrity_payload *bip; unsigned int tag_len; int ret;
if (!bio_sectors(bio) || !io->cc->tuple_size) return 0;
bip = bio_integrity_alloc(bio, GFP_NOIO, 1); if (IS_ERR(bip)) return PTR_ERR(bip);
tag_len = io->cc->tuple_size * (bio_sectors(bio) >> io->cc->sector_shift);
bip->bip_iter.bi_sector = bio->bi_iter.bi_sector;
ret = bio_integrity_add_page(bio, virt_to_page(io->integrity_metadata), tag_len, offset_in_page(io->integrity_metadata)); if (unlikely(ret != tag_len)) return -ENOMEM;
return 0;}
static int crypt_integrity_ctr(struct crypt_config *cc, struct dm_target *ti){#ifdef CONFIG_BLK_DEV_INTEGRITY struct blk_integrity *bi = blk_get_integrity(cc->dev->bdev->bd_disk); struct mapped_device *md = dm_table_get_md(ti->table);
/* We require an underlying device with non-PI metadata */ if (!bi || bi->csum_type != BLK_INTEGRITY_CSUM_NONE) { ti->error = "Integrity profile not supported."; return -EINVAL; }
if (bi->metadata_size < cc->used_tag_size) { ti->error = "Integrity profile tag size mismatch."; return -EINVAL; } cc->tuple_size = bi->metadata_size; if (1 << bi->interval_exp != cc->sector_size) { ti->error = "Integrity profile sector size mismatch."; return -EINVAL; }
if (crypt_integrity_aead(cc)) { cc->integrity_tag_size = cc->used_tag_size - cc->integrity_iv_size; DMDEBUG("%s: Integrity AEAD, tag size %u, IV size %u.", dm_device_name(md), cc->integrity_tag_size, cc->integrity_iv_size);
if (crypto_aead_setauthsize(any_tfm_aead(cc), cc->integrity_tag_size)) { ti->error = "Integrity AEAD auth tag size is not supported."; return -EINVAL; } } else if (cc->integrity_iv_size) DMDEBUG("%s: Additional per-sector space %u bytes for IV.", dm_device_name(md), cc->integrity_iv_size);
if ((cc->integrity_tag_size + cc->integrity_iv_size) > cc->tuple_size) { ti->error = "Not enough space for integrity tag in the profile."; return -EINVAL; }
return 0;#else ti->error = "Integrity profile not supported."; return -EINVAL;#endif}
static void crypt_convert_init(struct crypt_config *cc, struct convert_context *ctx, struct bio *bio_out, struct bio *bio_in, sector_t sector){ ctx->bio_in = bio_in; ctx->bio_out = bio_out; if (bio_in) ctx->iter_in = bio_in->bi_iter; if (bio_out) ctx->iter_out = bio_out->bi_iter; ctx->cc_sector = sector + cc->iv_offset; ctx->tag_offset = 0; init_completion(&ctx->restart);}
static struct dm_crypt_request *dmreq_of_req(struct crypt_config *cc, void *req){ return (struct dm_crypt_request *)((char *)req + cc->dmreq_start);}
static void *req_of_dmreq(struct crypt_config *cc, struct dm_crypt_request *dmreq){ return (void *)((char *)dmreq - cc->dmreq_start);}
static u8 *iv_of_dmreq(struct crypt_config *cc, struct dm_crypt_request *dmreq){ if (crypt_integrity_aead(cc)) return (u8 *)ALIGN((unsigned long)(dmreq + 1), crypto_aead_alignmask(any_tfm_aead(cc)) + 1); else return (u8 *)ALIGN((unsigned long)(dmreq + 1), crypto_skcipher_alignmask(any_tfm(cc)) + 1);}
static u8 *org_iv_of_dmreq(struct crypt_config *cc, struct dm_crypt_request *dmreq){ return iv_of_dmreq(cc, dmreq) + cc->iv_size;}
static __le64 *org_sector_of_dmreq(struct crypt_config *cc, struct dm_crypt_request *dmreq){ u8 *ptr = iv_of_dmreq(cc, dmreq) + cc->iv_size + cc->iv_size;
return (__le64 *) ptr;}
static unsigned int *org_tag_of_dmreq(struct crypt_config *cc, struct dm_crypt_request *dmreq){ u8 *ptr = iv_of_dmreq(cc, dmreq) + cc->iv_size + cc->iv_size + sizeof(uint64_t);
return (unsigned int *)ptr;}
static void *tag_from_dmreq(struct crypt_config *cc, struct dm_crypt_request *dmreq){ struct convert_context *ctx = dmreq->ctx; struct dm_crypt_io *io = container_of(ctx, struct dm_crypt_io, ctx);
return &io->integrity_metadata[*org_tag_of_dmreq(cc, dmreq) * cc->tuple_size];}
static void *iv_tag_from_dmreq(struct crypt_config *cc, struct dm_crypt_request *dmreq){ return tag_from_dmreq(cc, dmreq) + cc->integrity_tag_size;}
static int crypt_convert_block_aead(struct crypt_config *cc, struct convert_context *ctx, struct aead_request *req, unsigned int tag_offset){ struct bio_vec bv_in = bio_iter_iovec(ctx->bio_in, ctx->iter_in); struct bio_vec bv_out = bio_iter_iovec(ctx->bio_out, ctx->iter_out); struct dm_crypt_request *dmreq; u8 *iv, *org_iv, *tag_iv, *tag; __le64 *sector; int r = 0;
BUG_ON(cc->integrity_iv_size && cc->integrity_iv_size != cc->iv_size);
/* Reject unexpected unaligned bio. */ if (unlikely(bv_in.bv_len & (cc->sector_size - 1))) return -EIO;
dmreq = dmreq_of_req(cc, req); dmreq->iv_sector = ctx->cc_sector; if (test_bit(CRYPT_IV_LARGE_SECTORS, &cc->cipher_flags)) dmreq->iv_sector >>= cc->sector_shift; dmreq->ctx = ctx;
*org_tag_of_dmreq(cc, dmreq) = tag_offset;
sector = org_sector_of_dmreq(cc, dmreq); *sector = cpu_to_le64(ctx->cc_sector - cc->iv_offset);
iv = iv_of_dmreq(cc, dmreq); org_iv = org_iv_of_dmreq(cc, dmreq); tag = tag_from_dmreq(cc, dmreq); tag_iv = iv_tag_from_dmreq(cc, dmreq);
/* AEAD request: * |----- AAD -------|------ DATA -------|-- AUTH TAG --| * | (authenticated) | (auth+encryption) | | * | sector_LE | IV | sector in/out | tag in/out | */ sg_init_table(dmreq->sg_in, 4); sg_set_buf(&dmreq->sg_in[0], sector, sizeof(uint64_t)); sg_set_buf(&dmreq->sg_in[1], org_iv, cc->iv_size); sg_set_page(&dmreq->sg_in[2], bv_in.bv_page, cc->sector_size, bv_in.bv_offset); sg_set_buf(&dmreq->sg_in[3], tag, cc->integrity_tag_size);
sg_init_table(dmreq->sg_out, 4); sg_set_buf(&dmreq->sg_out[0], sector, sizeof(uint64_t)); sg_set_buf(&dmreq->sg_out[1], org_iv, cc->iv_size); sg_set_page(&dmreq->sg_out[2], bv_out.bv_page, cc->sector_size, bv_out.bv_offset); sg_set_buf(&dmreq->sg_out[3], tag, cc->integrity_tag_size);
if (cc->iv_gen_ops) { /* For READs use IV stored in integrity metadata */ if (cc->integrity_iv_size && bio_data_dir(ctx->bio_in) != WRITE) { memcpy(org_iv, tag_iv, cc->iv_size); } else { r = cc->iv_gen_ops->generator(cc, org_iv, dmreq); if (r < 0) return r; /* Store generated IV in integrity metadata */ if (cc->integrity_iv_size) memcpy(tag_iv, org_iv, cc->iv_size); } /* Working copy of IV, to be modified in crypto API */ memcpy(iv, org_iv, cc->iv_size); }
aead_request_set_ad(req, sizeof(uint64_t) + cc->iv_size); if (bio_data_dir(ctx->bio_in) == WRITE) { aead_request_set_crypt(req, dmreq->sg_in, dmreq->sg_out, cc->sector_size, iv); r = crypto_aead_encrypt(req); if (cc->integrity_tag_size + cc->integrity_iv_size != cc->tuple_size) memset(tag + cc->integrity_tag_size + cc->integrity_iv_size, 0, cc->tuple_size - (cc->integrity_tag_size + cc->integrity_iv_size)); } else { aead_request_set_crypt(req, dmreq->sg_in, dmreq->sg_out, cc->sector_size + cc->integrity_tag_size, iv); r = crypto_aead_decrypt(req); }
if (r == -EBADMSG) { sector_t s = le64_to_cpu(*sector);
ctx->aead_failed = true; if (ctx->aead_recheck) { DMERR_LIMIT("%pg: INTEGRITY AEAD ERROR, sector %llu", ctx->bio_in->bi_bdev, s); dm_audit_log_bio(DM_MSG_PREFIX, "integrity-aead", ctx->bio_in, s, 0); } }
if (!r && cc->iv_gen_ops && cc->iv_gen_ops->post) cc->iv_gen_ops->post(cc, org_iv, dmreq);
bio_advance_iter(ctx->bio_in, &ctx->iter_in, cc->sector_size); bio_advance_iter(ctx->bio_out, &ctx->iter_out, cc->sector_size);
return r;}
static int crypt_convert_block_skcipher(struct crypt_config *cc, struct convert_context *ctx, struct skcipher_request *req, unsigned int tag_offset){ struct bio_vec bv_in = bio_iter_iovec(ctx->bio_in, ctx->iter_in); struct bio_vec bv_out = bio_iter_iovec(ctx->bio_out, ctx->iter_out); struct scatterlist *sg_in, *sg_out; struct dm_crypt_request *dmreq; u8 *iv, *org_iv, *tag_iv; __le64 *sector; int r = 0;
/* Reject unexpected unaligned bio. */ if (unlikely(bv_in.bv_len & (cc->sector_size - 1))) return -EIO;
dmreq = dmreq_of_req(cc, req); dmreq->iv_sector = ctx->cc_sector; if (test_bit(CRYPT_IV_LARGE_SECTORS, &cc->cipher_flags)) dmreq->iv_sector >>= cc->sector_shift; dmreq->ctx = ctx;
*org_tag_of_dmreq(cc, dmreq) = tag_offset;
iv = iv_of_dmreq(cc, dmreq); org_iv = org_iv_of_dmreq(cc, dmreq); tag_iv = iv_tag_from_dmreq(cc, dmreq);
sector = org_sector_of_dmreq(cc, dmreq); *sector = cpu_to_le64(ctx->cc_sector - cc->iv_offset);
/* For skcipher we use only the first sg item */ sg_in = &dmreq->sg_in[0]; sg_out = &dmreq->sg_out[0];
sg_init_table(sg_in, 1); sg_set_page(sg_in, bv_in.bv_page, cc->sector_size, bv_in.bv_offset);
sg_init_table(sg_out, 1); sg_set_page(sg_out, bv_out.bv_page, cc->sector_size, bv_out.bv_offset);
if (cc->iv_gen_ops) { /* For READs use IV stored in integrity metadata */ if (cc->integrity_iv_size && bio_data_dir(ctx->bio_in) != WRITE) { memcpy(org_iv, tag_iv, cc->integrity_iv_size); } else { r = cc->iv_gen_ops->generator(cc, org_iv, dmreq); if (r < 0) return r; /* Data can be already preprocessed in generator */ if (test_bit(CRYPT_ENCRYPT_PREPROCESS, &cc->cipher_flags)) sg_in = sg_out; /* Store generated IV in integrity metadata */ if (cc->integrity_iv_size) memcpy(tag_iv, org_iv, cc->integrity_iv_size); } /* Working copy of IV, to be modified in crypto API */ memcpy(iv, org_iv, cc->iv_size); }
skcipher_request_set_crypt(req, sg_in, sg_out, cc->sector_size, iv);
if (bio_data_dir(ctx->bio_in) == WRITE) r = crypto_skcipher_encrypt(req); else r = crypto_skcipher_decrypt(req);
if (!r && cc->iv_gen_ops && cc->iv_gen_ops->post) cc->iv_gen_ops->post(cc, org_iv, dmreq);
bio_advance_iter(ctx->bio_in, &ctx->iter_in, cc->sector_size); bio_advance_iter(ctx->bio_out, &ctx->iter_out, cc->sector_size);
return r;}
static void kcryptd_async_done(void *async_req, int error);
static int crypt_alloc_req_skcipher(struct crypt_config *cc, struct convert_context *ctx){ unsigned int key_index = ctx->cc_sector & (cc->tfms_count - 1);
if (!ctx->r.req) { ctx->r.req = mempool_alloc(&cc->req_pool, in_interrupt() ? GFP_ATOMIC : GFP_NOIO); if (!ctx->r.req) return -ENOMEM; }
skcipher_request_set_tfm(ctx->r.req, cc->cipher_tfm.tfms[key_index]);
/* * Use REQ_MAY_BACKLOG so a cipher driver internally backlogs * requests if driver request queue is full. */ skcipher_request_set_callback(ctx->r.req, CRYPTO_TFM_REQ_MAY_BACKLOG, kcryptd_async_done, dmreq_of_req(cc, ctx->r.req));
return 0;}
static int crypt_alloc_req_aead(struct crypt_config *cc, struct convert_context *ctx){ if (!ctx->r.req_aead) { ctx->r.req_aead = mempool_alloc(&cc->req_pool, in_interrupt() ? GFP_ATOMIC : GFP_NOIO); if (!ctx->r.req_aead) return -ENOMEM; }
aead_request_set_tfm(ctx->r.req_aead, cc->cipher_tfm.tfms_aead[0]);
/* * Use REQ_MAY_BACKLOG so a cipher driver internally backlogs * requests if driver request queue is full. */ aead_request_set_callback(ctx->r.req_aead, CRYPTO_TFM_REQ_MAY_BACKLOG, kcryptd_async_done, dmreq_of_req(cc, ctx->r.req_aead));
return 0;}
static int crypt_alloc_req(struct crypt_config *cc, struct convert_context *ctx){ if (crypt_integrity_aead(cc)) return crypt_alloc_req_aead(cc, ctx); else return crypt_alloc_req_skcipher(cc, ctx);}
static void crypt_free_req_skcipher(struct crypt_config *cc, struct skcipher_request *req, struct bio *base_bio){ struct dm_crypt_io *io = dm_per_bio_data(base_bio, cc->per_bio_data_size);
if ((struct skcipher_request *)(io + 1) != req) mempool_free(req, &cc->req_pool);}
static void crypt_free_req_aead(struct crypt_config *cc, struct aead_request *req, struct bio *base_bio){ struct dm_crypt_io *io = dm_per_bio_data(base_bio, cc->per_bio_data_size);
if ((struct aead_request *)(io + 1) != req) mempool_free(req, &cc->req_pool);}
static void crypt_free_req(struct crypt_config *cc, void *req, struct bio *base_bio){ if (crypt_integrity_aead(cc)) crypt_free_req_aead(cc, req, base_bio); else crypt_free_req_skcipher(cc, req, base_bio);}
/* * Encrypt / decrypt data from one bio to another one (can be the same one) */static blk_status_t crypt_convert(struct crypt_config *cc, struct convert_context *ctx, bool atomic, bool reset_pending){ unsigned int sector_step = cc->sector_size >> SECTOR_SHIFT; int r;
/* * if reset_pending is set we are dealing with the bio for the first time, * else we're continuing to work on the previous bio, so don't mess with * the cc_pending counter */ if (reset_pending) atomic_set(&ctx->cc_pending, 1);
while (ctx->iter_in.bi_size && ctx->iter_out.bi_size) {
r = crypt_alloc_req(cc, ctx); if (r) { complete(&ctx->restart); return BLK_STS_DEV_RESOURCE; }
atomic_inc(&ctx->cc_pending);
if (crypt_integrity_aead(cc)) r = crypt_convert_block_aead(cc, ctx, ctx->r.req_aead, ctx->tag_offset); else r = crypt_convert_block_skcipher(cc, ctx, ctx->r.req, ctx->tag_offset);
switch (r) { /* * The request was queued by a crypto driver * but the driver request queue is full, let's wait. */ case -EBUSY: if (in_interrupt()) { if (try_wait_for_completion(&ctx->restart)) { /* * we don't have to block to wait for completion, * so proceed */ } else { /* * we can't wait for completion without blocking * exit and continue processing in a workqueue */ ctx->r.req = NULL; ctx->tag_offset++; ctx->cc_sector += sector_step; return BLK_STS_DEV_RESOURCE; } } else { wait_for_completion(&ctx->restart); } reinit_completion(&ctx->restart); fallthrough; /* * The request is queued and processed asynchronously, * completion function kcryptd_async_done() will be called. */ case -EINPROGRESS: ctx->r.req = NULL; ctx->tag_offset++; ctx->cc_sector += sector_step; continue; /* * The request was already processed (synchronously). */ case 0: atomic_dec(&ctx->cc_pending); ctx->cc_sector += sector_step; ctx->tag_offset++; if (!atomic) cond_resched(); continue; /* * There was a data integrity error. */ case -EBADMSG: atomic_dec(&ctx->cc_pending); return BLK_STS_PROTECTION; /* * There was an error while processing the request. */ default: atomic_dec(&ctx->cc_pending); return BLK_STS_IOERR; } }
return 0;}
static void crypt_free_buffer_pages(struct crypt_config *cc, struct bio *clone);
/* * Generate a new unfragmented bio with the given size * This should never violate the device limitations (but if it did then block * core should split the bio as needed). * * This function may be called concurrently. If we allocate from the mempool * concurrently, there is a possibility of deadlock. For example, if we have * mempool of 256 pages, two processes, each wanting 256, pages allocate from * the mempool concurrently, it may deadlock in a situation where both processes * have allocated 128 pages and the mempool is exhausted. * * In order to avoid this scenario we allocate the pages under a mutex. * * In order to not degrade performance with excessive locking, we try * non-blocking allocations without a mutex first but on failure we fallback * to blocking allocations with a mutex. * * In order to reduce allocation overhead, we try to allocate compound pages in * the first pass. If they are not available, we fall back to the mempool. */static struct bio *crypt_alloc_buffer(struct dm_crypt_io *io, unsigned int size){ struct crypt_config *cc = io->cc; struct bio *clone; unsigned int nr_iovecs = (size + PAGE_SIZE - 1) >> PAGE_SHIFT; gfp_t gfp_mask = GFP_NOWAIT | __GFP_HIGHMEM; unsigned int remaining_size; unsigned int order = MAX_PAGE_ORDER;
retry: if (unlikely(gfp_mask & __GFP_DIRECT_RECLAIM)) mutex_lock(&cc->bio_alloc_lock);
clone = bio_alloc_bioset(cc->dev->bdev, nr_iovecs, io->base_bio->bi_opf, GFP_NOIO, &cc->bs); clone->bi_private = io; clone->bi_end_io = crypt_endio; clone->bi_ioprio = io->base_bio->bi_ioprio; clone->bi_iter.bi_sector = cc->start + io->sector;
remaining_size = size;
while (remaining_size) { struct page *pages; unsigned size_to_add; unsigned remaining_order = __fls((remaining_size + PAGE_SIZE - 1) >> PAGE_SHIFT); order = min(order, remaining_order);
while (order > 0) { if (unlikely(percpu_counter_read_positive(&cc->n_allocated_pages) + (1 << order) > dm_crypt_pages_per_client)) goto decrease_order; pages = alloc_pages(gfp_mask | __GFP_NOMEMALLOC | __GFP_NORETRY | __GFP_NOWARN | __GFP_COMP, order); if (likely(pages != NULL)) { percpu_counter_add(&cc->n_allocated_pages, 1 << order); goto have_pages; }decrease_order: order--; }
pages = mempool_alloc(&cc->page_pool, gfp_mask); if (!pages) { crypt_free_buffer_pages(cc, clone); bio_put(clone); gfp_mask |= __GFP_DIRECT_RECLAIM; order = 0; goto retry; }
have_pages: size_to_add = min((unsigned)PAGE_SIZE << order, remaining_size); __bio_add_page(clone, pages, size_to_add, 0); remaining_size -= size_to_add; }
/* Allocate space for integrity tags */ if (dm_crypt_integrity_io_alloc(io, clone)) { crypt_free_buffer_pages(cc, clone); bio_put(clone); clone = NULL; }
if (unlikely(gfp_mask & __GFP_DIRECT_RECLAIM)) mutex_unlock(&cc->bio_alloc_lock);
return clone;}
static void crypt_free_buffer_pages(struct crypt_config *cc, struct bio *clone){ struct folio_iter fi;
if (clone->bi_vcnt > 0) { /* bio_for_each_folio_all crashes with an empty bio */ bio_for_each_folio_all(fi, clone) { if (folio_test_large(fi.folio)) { percpu_counter_sub(&cc->n_allocated_pages, folio_nr_pages(fi.folio)); folio_put(fi.folio); } else { mempool_free(&fi.folio->page, &cc->page_pool); } } }}
static void crypt_io_init(struct dm_crypt_io *io, struct crypt_config *cc, struct bio *bio, sector_t sector){ io->cc = cc; io->base_bio = bio; io->sector = sector; io->error = 0; io->ctx.aead_recheck = false; io->ctx.aead_failed = false; io->ctx.r.req = NULL; io->integrity_metadata = NULL; io->integrity_metadata_from_pool = false; atomic_set(&io->io_pending, 0);}
static void crypt_inc_pending(struct dm_crypt_io *io){ atomic_inc(&io->io_pending);}
static void kcryptd_queue_read(struct dm_crypt_io *io);
/* * One of the bios was finished. Check for completion of * the whole request and correctly clean up the buffer. */static void crypt_dec_pending(struct dm_crypt_io *io){ struct crypt_config *cc = io->cc; struct bio *base_bio = io->base_bio;
if (!atomic_dec_and_test(&io->io_pending)) return;
if (likely(!io->ctx.aead_recheck) && unlikely(io->ctx.aead_failed) && cc->used_tag_size && bio_data_dir(base_bio) == READ) { io->ctx.aead_recheck = true; io->ctx.aead_failed = false; io->error = 0; kcryptd_queue_read(io); return; }
if (io->ctx.r.req) crypt_free_req(cc, io->ctx.r.req, base_bio);
if (unlikely(io->integrity_metadata_from_pool)) mempool_free(io->integrity_metadata, &io->cc->tag_pool); else kfree(io->integrity_metadata);
base_bio->bi_status = io->error;
bio_endio(base_bio);}
/* * kcryptd/kcryptd_io: * * Needed because it would be very unwise to do decryption in an * interrupt context. * * kcryptd performs the actual encryption or decryption. * * kcryptd_io performs the IO submission. * * They must be separated as otherwise the final stages could be * starved by new requests which can block in the first stages due * to memory allocation. * * The work is done per CPU global for all dm-crypt instances. * They should not depend on each other and do not block. */static void crypt_endio(struct bio *clone){ struct dm_crypt_io *io = clone->bi_private; struct crypt_config *cc = io->cc; unsigned int rw = bio_data_dir(clone); blk_status_t error = clone->bi_status;
if (io->ctx.aead_recheck && !error) { kcryptd_queue_crypt(io); return; }
/* * free the processed pages */ if (rw == WRITE || io->ctx.aead_recheck) crypt_free_buffer_pages(cc, clone);
bio_put(clone);
if (rw == READ && !error) { kcryptd_queue_crypt(io); return; }
if (unlikely(error)) io->error = error;
crypt_dec_pending(io);}
#define CRYPT_MAP_READ_GFP GFP_NOWAIT
static int kcryptd_io_read(struct dm_crypt_io *io, gfp_t gfp){ struct crypt_config *cc = io->cc; struct bio *clone;
if (io->ctx.aead_recheck) { if (!(gfp & __GFP_DIRECT_RECLAIM)) return 1; crypt_inc_pending(io); clone = crypt_alloc_buffer(io, io->base_bio->bi_iter.bi_size); if (unlikely(!clone)) { crypt_dec_pending(io); return 1; } crypt_convert_init(cc, &io->ctx, clone, clone, io->sector); io->saved_bi_iter = clone->bi_iter; dm_submit_bio_remap(io->base_bio, clone); return 0; }
/* * We need the original biovec array in order to decrypt the whole bio * data *afterwards* -- thanks to immutable biovecs we don't need to * worry about the block layer modifying the biovec array; so leverage * bio_alloc_clone(). */ clone = bio_alloc_clone(cc->dev->bdev, io->base_bio, gfp, &cc->bs); if (!clone) return 1;
clone->bi_iter.bi_sector = cc->start + io->sector; clone->bi_private = io; clone->bi_end_io = crypt_endio;
crypt_inc_pending(io);
if (dm_crypt_integrity_io_alloc(io, clone)) { crypt_dec_pending(io); bio_put(clone); return 1; }
dm_submit_bio_remap(io->base_bio, clone); return 0;}
static void kcryptd_io_read_work(struct work_struct *work){ struct dm_crypt_io *io = container_of(work, struct dm_crypt_io, work);
crypt_inc_pending(io); if (kcryptd_io_read(io, GFP_NOIO)) io->error = BLK_STS_RESOURCE; crypt_dec_pending(io);}
static void kcryptd_queue_read(struct dm_crypt_io *io){ struct crypt_config *cc = io->cc;
INIT_WORK(&io->work, kcryptd_io_read_work); queue_work(cc->io_queue, &io->work);}
static void kcryptd_io_write(struct dm_crypt_io *io){ struct bio *clone = io->ctx.bio_out;
dm_submit_bio_remap(io->base_bio, clone);}
#define crypt_io_from_node(node) rb_entry((node), struct dm_crypt_io, rb_node)
static int dmcrypt_write(void *data){ struct crypt_config *cc = data; struct dm_crypt_io *io;
while (1) { struct rb_root write_tree; struct blk_plug plug;
spin_lock_irq(&cc->write_thread_lock);continue_locked:
if (!RB_EMPTY_ROOT(&cc->write_tree)) goto pop_from_list;
set_current_state(TASK_INTERRUPTIBLE);
spin_unlock_irq(&cc->write_thread_lock);
if (unlikely(kthread_should_stop())) { set_current_state(TASK_RUNNING); break; }
schedule();
spin_lock_irq(&cc->write_thread_lock); goto continue_locked;
pop_from_list: write_tree = cc->write_tree; cc->write_tree = RB_ROOT; spin_unlock_irq(&cc->write_thread_lock);
BUG_ON(rb_parent(write_tree.rb_node));
/* * Note: we cannot walk the tree here with rb_next because * the structures may be freed when kcryptd_io_write is called. */ blk_start_plug(&plug); do { io = crypt_io_from_node(rb_first(&write_tree)); rb_erase(&io->rb_node, &write_tree); kcryptd_io_write(io); cond_resched(); } while (!RB_EMPTY_ROOT(&write_tree)); blk_finish_plug(&plug); } return 0;}
static void kcryptd_crypt_write_io_submit(struct dm_crypt_io *io, int async){ struct bio *clone = io->ctx.bio_out; struct crypt_config *cc = io->cc; unsigned long flags; sector_t sector; struct rb_node **rbp, *parent;
if (unlikely(io->error)) { crypt_free_buffer_pages(cc, clone); bio_put(clone); crypt_dec_pending(io); return; }
/* crypt_convert should have filled the clone bio */ BUG_ON(io->ctx.iter_out.bi_size);
if ((likely(!async) && test_bit(DM_CRYPT_NO_OFFLOAD, &cc->flags)) || test_bit(DM_CRYPT_NO_WRITE_WORKQUEUE, &cc->flags)) { dm_submit_bio_remap(io->base_bio, clone); return; }
spin_lock_irqsave(&cc->write_thread_lock, flags); if (RB_EMPTY_ROOT(&cc->write_tree)) wake_up_process(cc->write_thread); rbp = &cc->write_tree.rb_node; parent = NULL; sector = io->sector; while (*rbp) { parent = *rbp; if (sector < crypt_io_from_node(parent)->sector) rbp = &(*rbp)->rb_left; else rbp = &(*rbp)->rb_right; } rb_link_node(&io->rb_node, parent, rbp); rb_insert_color(&io->rb_node, &cc->write_tree); spin_unlock_irqrestore(&cc->write_thread_lock, flags);}
static bool kcryptd_crypt_write_inline(struct crypt_config *cc, struct convert_context *ctx)
{ if (!test_bit(DM_CRYPT_WRITE_INLINE, &cc->flags)) return false;
/* * Note: zone append writes (REQ_OP_ZONE_APPEND) do not have ordering * constraints so they do not need to be issued inline by * kcryptd_crypt_write_convert(). */ switch (bio_op(ctx->bio_in)) { case REQ_OP_WRITE: case REQ_OP_WRITE_ZEROES: return true; default: return false; }}
static void kcryptd_crypt_write_continue(struct work_struct *work){ struct dm_crypt_io *io = container_of(work, struct dm_crypt_io, work); struct crypt_config *cc = io->cc; struct convert_context *ctx = &io->ctx; int crypt_finished; blk_status_t r;
wait_for_completion(&ctx->restart); reinit_completion(&ctx->restart);
r = crypt_convert(cc, &io->ctx, false, false); if (r) io->error = r; crypt_finished = atomic_dec_and_test(&ctx->cc_pending); if (!crypt_finished && kcryptd_crypt_write_inline(cc, ctx)) { /* Wait for completion signaled by kcryptd_async_done() */ wait_for_completion(&ctx->restart); crypt_finished = 1; }
/* Encryption was already finished, submit io now */ if (crypt_finished) kcryptd_crypt_write_io_submit(io, 0);
crypt_dec_pending(io);}
static void kcryptd_crypt_write_convert(struct dm_crypt_io *io){ struct crypt_config *cc = io->cc; struct convert_context *ctx = &io->ctx; struct bio *clone; int crypt_finished; blk_status_t r;
/* * Prevent io from disappearing until this function completes. */ crypt_inc_pending(io); crypt_convert_init(cc, ctx, NULL, io->base_bio, io->sector);
clone = crypt_alloc_buffer(io, io->base_bio->bi_iter.bi_size); if (unlikely(!clone)) { io->error = BLK_STS_IOERR; goto dec; }
io->ctx.bio_out = clone; io->ctx.iter_out = clone->bi_iter;
if (crypt_integrity_aead(cc)) { bio_copy_data(clone, io->base_bio); io->ctx.bio_in = clone; io->ctx.iter_in = clone->bi_iter; }
crypt_inc_pending(io); r = crypt_convert(cc, ctx, test_bit(DM_CRYPT_NO_WRITE_WORKQUEUE, &cc->flags), true); /* * Crypto API backlogged the request, because its queue was full * and we're in softirq context, so continue from a workqueue * (TODO: is it actually possible to be in softirq in the write path?) */ if (r == BLK_STS_DEV_RESOURCE) { INIT_WORK(&io->work, kcryptd_crypt_write_continue); queue_work(cc->crypt_queue, &io->work); return; } if (r) io->error = r; crypt_finished = atomic_dec_and_test(&ctx->cc_pending); if (!crypt_finished && kcryptd_crypt_write_inline(cc, ctx)) { /* Wait for completion signaled by kcryptd_async_done() */ wait_for_completion(&ctx->restart); crypt_finished = 1; }
/* Encryption was already finished, submit io now */ if (crypt_finished) kcryptd_crypt_write_io_submit(io, 0);
dec: crypt_dec_pending(io);}
static void kcryptd_crypt_read_done(struct dm_crypt_io *io){ if (io->ctx.aead_recheck) { if (!io->error) { io->ctx.bio_in->bi_iter = io->saved_bi_iter; bio_copy_data(io->base_bio, io->ctx.bio_in); } crypt_free_buffer_pages(io->cc, io->ctx.bio_in); bio_put(io->ctx.bio_in); } crypt_dec_pending(io);}
static void kcryptd_crypt_read_continue(struct work_struct *work){ struct dm_crypt_io *io = container_of(work, struct dm_crypt_io, work); struct crypt_config *cc = io->cc; blk_status_t r;
wait_for_completion(&io->ctx.restart); reinit_completion(&io->ctx.restart);
r = crypt_convert(cc, &io->ctx, false, false); if (r) io->error = r;
if (atomic_dec_and_test(&io->ctx.cc_pending)) kcryptd_crypt_read_done(io);
crypt_dec_pending(io);}
static void kcryptd_crypt_read_convert(struct dm_crypt_io *io){ struct crypt_config *cc = io->cc; blk_status_t r;
crypt_inc_pending(io);
if (io->ctx.aead_recheck) { r = crypt_convert(cc, &io->ctx, test_bit(DM_CRYPT_NO_READ_WORKQUEUE, &cc->flags), true); } else { crypt_convert_init(cc, &io->ctx, io->base_bio, io->base_bio, io->sector);
r = crypt_convert(cc, &io->ctx, test_bit(DM_CRYPT_NO_READ_WORKQUEUE, &cc->flags), true); } /* * Crypto API backlogged the request, because its queue was full * and we're in softirq context, so continue from a workqueue */ if (r == BLK_STS_DEV_RESOURCE) { INIT_WORK(&io->work, kcryptd_crypt_read_continue); queue_work(cc->crypt_queue, &io->work); return; } if (r) io->error = r;
if (atomic_dec_and_test(&io->ctx.cc_pending)) kcryptd_crypt_read_done(io);
crypt_dec_pending(io);}
static void kcryptd_async_done(void *data, int error){ struct dm_crypt_request *dmreq = data; struct convert_context *ctx = dmreq->ctx; struct dm_crypt_io *io = container_of(ctx, struct dm_crypt_io, ctx); struct crypt_config *cc = io->cc;
/* * A request from crypto driver backlog is going to be processed now, * finish the completion and continue in crypt_convert(). * (Callback will be called for the second time for this request.) */ if (error == -EINPROGRESS) { complete(&ctx->restart); return; }
if (!error && cc->iv_gen_ops && cc->iv_gen_ops->post) cc->iv_gen_ops->post(cc, org_iv_of_dmreq(cc, dmreq), dmreq);
if (error == -EBADMSG) { sector_t s = le64_to_cpu(*org_sector_of_dmreq(cc, dmreq));
ctx->aead_failed = true; if (ctx->aead_recheck) { DMERR_LIMIT("%pg: INTEGRITY AEAD ERROR, sector %llu", ctx->bio_in->bi_bdev, s); dm_audit_log_bio(DM_MSG_PREFIX, "integrity-aead", ctx->bio_in, s, 0); } io->error = BLK_STS_PROTECTION; } else if (error < 0) io->error = BLK_STS_IOERR;
crypt_free_req(cc, req_of_dmreq(cc, dmreq), io->base_bio);
if (!atomic_dec_and_test(&ctx->cc_pending)) return;
/* * The request is fully completed: for inline writes, let * kcryptd_crypt_write_convert() do the IO submission. */ if (bio_data_dir(io->base_bio) == READ) { kcryptd_crypt_read_done(io); return; }
if (kcryptd_crypt_write_inline(cc, ctx)) { complete(&ctx->restart); return; }
kcryptd_crypt_write_io_submit(io, 1);}
static void kcryptd_crypt(struct work_struct *work){ struct dm_crypt_io *io = container_of(work, struct dm_crypt_io, work);
if (bio_data_dir(io->base_bio) == READ) kcryptd_crypt_read_convert(io); else kcryptd_crypt_write_convert(io);}
static void kcryptd_queue_crypt(struct dm_crypt_io *io){ struct crypt_config *cc = io->cc;
if ((bio_data_dir(io->base_bio) == READ && test_bit(DM_CRYPT_NO_READ_WORKQUEUE, &cc->flags)) || (bio_data_dir(io->base_bio) == WRITE && test_bit(DM_CRYPT_NO_WRITE_WORKQUEUE, &cc->flags))) { /* * in_hardirq(): Crypto API's skcipher_walk_first() refuses to work in hard IRQ context. * irqs_disabled(): the kernel may run some IO completion from the idle thread, but * it is being executed with irqs disabled. */ if (in_hardirq() || irqs_disabled()) { INIT_WORK(&io->work, kcryptd_crypt); queue_work(system_bh_wq, &io->work); return; } else { kcryptd_crypt(&io->work); return; } }
INIT_WORK(&io->work, kcryptd_crypt); queue_work(cc->crypt_queue, &io->work);}
static void crypt_free_tfms_aead(struct crypt_config *cc){ if (!cc->cipher_tfm.tfms_aead) return;
if (cc->cipher_tfm.tfms_aead[0] && !IS_ERR(cc->cipher_tfm.tfms_aead[0])) { crypto_free_aead(cc->cipher_tfm.tfms_aead[0]); cc->cipher_tfm.tfms_aead[0] = NULL; }
kfree(cc->cipher_tfm.tfms_aead); cc->cipher_tfm.tfms_aead = NULL;}
static void crypt_free_tfms_skcipher(struct crypt_config *cc){ unsigned int i;
if (!cc->cipher_tfm.tfms) return;
for (i = 0; i < cc->tfms_count; i++) if (cc->cipher_tfm.tfms[i] && !IS_ERR(cc->cipher_tfm.tfms[i])) { crypto_free_skcipher(cc->cipher_tfm.tfms[i]); cc->cipher_tfm.tfms[i] = NULL; }
kfree(cc->cipher_tfm.tfms); cc->cipher_tfm.tfms = NULL;}
static void crypt_free_tfms(struct crypt_config *cc){ if (crypt_integrity_aead(cc)) crypt_free_tfms_aead(cc); else crypt_free_tfms_skcipher(cc);}
static int crypt_alloc_tfms_skcipher(struct crypt_config *cc, char *ciphermode){ unsigned int i; int err;
cc->cipher_tfm.tfms = kzalloc_objs(struct crypto_skcipher *, cc->tfms_count); if (!cc->cipher_tfm.tfms) return -ENOMEM;
for (i = 0; i < cc->tfms_count; i++) { cc->cipher_tfm.tfms[i] = crypto_alloc_skcipher(ciphermode, 0, CRYPTO_ALG_ALLOCATES_MEMORY); if (IS_ERR(cc->cipher_tfm.tfms[i])) { err = PTR_ERR(cc->cipher_tfm.tfms[i]); crypt_free_tfms(cc); return err; } }
/* * dm-crypt performance can vary greatly depending on which crypto * algorithm implementation is used. Help people debug performance * problems by logging the ->cra_driver_name. */ DMDEBUG_LIMIT("%s using implementation \"%s\"", ciphermode, crypto_skcipher_alg(any_tfm(cc))->base.cra_driver_name); return 0;}
static int crypt_alloc_tfms_aead(struct crypt_config *cc, char *ciphermode){ int err;
cc->cipher_tfm.tfms = kmalloc_obj(struct crypto_skcipher *); if (!cc->cipher_tfm.tfms) return -ENOMEM;
cc->cipher_tfm.tfms_aead[0] = crypto_alloc_aead(ciphermode, 0, CRYPTO_ALG_ALLOCATES_MEMORY); if (IS_ERR(cc->cipher_tfm.tfms_aead[0])) { err = PTR_ERR(cc->cipher_tfm.tfms_aead[0]); crypt_free_tfms(cc); return err; }
DMDEBUG_LIMIT("%s using implementation \"%s\"", ciphermode, crypto_aead_alg(any_tfm_aead(cc))->base.cra_driver_name); return 0;}
static int crypt_alloc_tfms(struct crypt_config *cc, char *ciphermode){ if (crypt_integrity_aead(cc)) return crypt_alloc_tfms_aead(cc, ciphermode); else return crypt_alloc_tfms_skcipher(cc, ciphermode);}
static unsigned int crypt_subkey_size(struct crypt_config *cc){ return (cc->key_size - cc->key_extra_size) >> ilog2(cc->tfms_count);}
static unsigned int crypt_authenckey_size(struct crypt_config *cc){ return crypt_subkey_size(cc) + RTA_SPACE(sizeof(struct crypto_authenc_key_param));}
/* * If AEAD is composed like authenc(hmac(sha256),xts(aes)), * the key must be for some reason in special format. * This function converts cc->key to this special format. */static void crypt_copy_authenckey(char *p, const void *key, unsigned int enckeylen, unsigned int authkeylen){ struct crypto_authenc_key_param *param; struct rtattr *rta;
rta = (struct rtattr *)p; param = RTA_DATA(rta); param->enckeylen = cpu_to_be32(enckeylen); rta->rta_len = RTA_LENGTH(sizeof(*param)); rta->rta_type = CRYPTO_AUTHENC_KEYA_PARAM; p += RTA_SPACE(sizeof(*param)); memcpy(p, key + enckeylen, authkeylen); p += authkeylen; memcpy(p, key, enckeylen);}
static int crypt_setkey(struct crypt_config *cc){ unsigned int subkey_size; int err = 0, i, r;
/* Ignore extra keys (which are used for IV etc) */ subkey_size = crypt_subkey_size(cc);
if (crypt_integrity_hmac(cc)) { if (subkey_size < cc->key_mac_size) return -EINVAL;
crypt_copy_authenckey(cc->authenc_key, cc->key, subkey_size - cc->key_mac_size, cc->key_mac_size); }
for (i = 0; i < cc->tfms_count; i++) { if (crypt_integrity_hmac(cc)) r = crypto_aead_setkey(cc->cipher_tfm.tfms_aead[i], cc->authenc_key, crypt_authenckey_size(cc)); else if (crypt_integrity_aead(cc)) r = crypto_aead_setkey(cc->cipher_tfm.tfms_aead[i], cc->key + (i * subkey_size), subkey_size); else r = crypto_skcipher_setkey(cc->cipher_tfm.tfms[i], cc->key + (i * subkey_size), subkey_size); if (r) err = r; }
if (crypt_integrity_hmac(cc)) memzero_explicit(cc->authenc_key, crypt_authenckey_size(cc));
return err;}
#ifdef CONFIG_KEYS
static bool contains_whitespace(const char *str){ while (*str) if (isspace(*str++)) return true; return false;}
static int set_key_user(struct crypt_config *cc, struct key *key){ const struct user_key_payload *ukp;
ukp = user_key_payload_locked(key); if (!ukp) return -EKEYREVOKED;
if (cc->key_size != ukp->datalen) return -EINVAL;
memcpy(cc->key, ukp->data, cc->key_size);
return 0;}
static int set_key_encrypted(struct crypt_config *cc, struct key *key){ const struct encrypted_key_payload *ekp;
ekp = key->payload.data[0]; if (!ekp) return -EKEYREVOKED;
if (cc->key_size != ekp->decrypted_datalen) return -EINVAL;
memcpy(cc->key, ekp->decrypted_data, cc->key_size);
return 0;}
static int set_key_trusted(struct crypt_config *cc, struct key *key){ const struct trusted_key_payload *tkp;
tkp = key->payload.data[0]; if (!tkp) return -EKEYREVOKED;
if (cc->key_size != tkp->key_len) return -EINVAL;
memcpy(cc->key, tkp->key, cc->key_size);
return 0;}
static int crypt_set_keyring_key(struct crypt_config *cc, const char *key_string){ char *new_key_string, *key_desc; int ret; struct key_type *type; struct key *key; int (*set_key)(struct crypt_config *cc, struct key *key);
/* * Reject key_string with whitespace. dm core currently lacks code for * proper whitespace escaping in arguments on DM_TABLE_STATUS path. */ if (contains_whitespace(key_string)) { DMERR("whitespace chars not allowed in key string"); return -EINVAL; }
/* look for next ':' separating key_type from key_description */ key_desc = strchr(key_string, ':'); if (!key_desc || key_desc == key_string || !strlen(key_desc + 1)) return -EINVAL;
if (!strncmp(key_string, "logon:", key_desc - key_string + 1)) { type = &key_type_logon; set_key = set_key_user; } else if (!strncmp(key_string, "user:", key_desc - key_string + 1)) { type = &key_type_user; set_key = set_key_user; } else if (IS_ENABLED(CONFIG_ENCRYPTED_KEYS) && !strncmp(key_string, "encrypted:", key_desc - key_string + 1)) { type = &key_type_encrypted; set_key = set_key_encrypted; } else if (IS_ENABLED(CONFIG_TRUSTED_KEYS) && !strncmp(key_string, "trusted:", key_desc - key_string + 1)) { type = &key_type_trusted; set_key = set_key_trusted; } else { return -EINVAL; }
new_key_string = kstrdup(key_string, GFP_KERNEL); if (!new_key_string) return -ENOMEM;
key = request_key(type, key_desc + 1, NULL); if (IS_ERR(key)) { ret = PTR_ERR(key); goto free_new_key_string; }
down_read(&key->sem); ret = set_key(cc, key); up_read(&key->sem); key_put(key); if (ret < 0) goto free_new_key_string;
/* clear the flag since following operations may invalidate previously valid key */ clear_bit(DM_CRYPT_KEY_VALID, &cc->flags);
ret = crypt_setkey(cc); if (ret) goto free_new_key_string;
set_bit(DM_CRYPT_KEY_VALID, &cc->flags); kfree_sensitive(cc->key_string); cc->key_string = new_key_string; return 0;
free_new_key_string: kfree_sensitive(new_key_string); return ret;}
static int get_key_size(char **key_string){ char *colon, dummy; int ret;
if (*key_string[0] != ':') return strlen(*key_string) >> 1;
/* look for next ':' in key string */ colon = strpbrk(*key_string + 1, ":"); if (!colon) return -EINVAL;
if (sscanf(*key_string + 1, "%u%c", &ret, &dummy) != 2 || dummy != ':') return -EINVAL;
*key_string = colon;
/* remaining key string should be :<logon|user>:<key_desc> */
return ret;}
#else
static int crypt_set_keyring_key(struct crypt_config *cc, const char *key_string){ return -EINVAL;}
static int get_key_size(char **key_string){ return (*key_string[0] == ':') ? -EINVAL : (int)(strlen(*key_string) >> 1);}
#endif /* CONFIG_KEYS */
static int crypt_set_key(struct crypt_config *cc, char *key){ int r = -EINVAL; size_t key_string_len = strlen(key);
/* Hyphen (which gives a key_size of zero) means there is no key. */ if (!cc->key_size && strcmp(key, "-")) goto out;
/* ':' means the key is in kernel keyring, short-circuit normal key processing */ if (key[0] == ':') { r = crypt_set_keyring_key(cc, key + 1); goto out; }
/* clear the flag since following operations may invalidate previously valid key */ clear_bit(DM_CRYPT_KEY_VALID, &cc->flags);
/* wipe references to any kernel keyring key */ kfree_sensitive(cc->key_string); cc->key_string = NULL;
if (cc->key_size && key_string_len != cc->key_size * 2) goto out;
/* Decode key from its hex representation. */ if (cc->key_size && hex2bin(cc->key, key, cc->key_size) < 0) goto out;
r = crypt_setkey(cc); if (!r) set_bit(DM_CRYPT_KEY_VALID, &cc->flags);
out: /* Hex key string not needed after here, so wipe it. */ memzero_explicit(key, key_string_len);
return r;}
static int crypt_wipe_key(struct crypt_config *cc){ int r;
clear_bit(DM_CRYPT_KEY_VALID, &cc->flags); get_random_bytes(&cc->key, cc->key_size);
/* Wipe IV private keys */ if (cc->iv_gen_ops && cc->iv_gen_ops->wipe) cc->iv_gen_ops->wipe(cc);
kfree_sensitive(cc->key_string); cc->key_string = NULL; r = crypt_setkey(cc); memzero_explicit(cc->key, cc->key_size);
return r;}
static void crypt_calculate_pages_per_client(void){ unsigned long pages = (totalram_pages() - totalhigh_pages()) * DM_CRYPT_MEMORY_PERCENT / 100;
if (!dm_crypt_clients_n) return;
pages /= dm_crypt_clients_n; if (pages < DM_CRYPT_MIN_PAGES_PER_CLIENT) pages = DM_CRYPT_MIN_PAGES_PER_CLIENT; dm_crypt_pages_per_client = pages;}
static void *crypt_page_alloc(gfp_t gfp_mask, void *pool_data){ struct crypt_config *cc = pool_data; struct page *page;
/* * Note, percpu_counter_read_positive() may over (and under) estimate * the current usage by at most (batch - 1) * num_online_cpus() pages, * but avoids potential spinlock contention of an exact result. */ if (unlikely(percpu_counter_read_positive(&cc->n_allocated_pages) >= dm_crypt_pages_per_client) && likely(gfp_mask & __GFP_NORETRY)) return NULL;
page = alloc_page(gfp_mask); if (likely(page != NULL)) percpu_counter_add(&cc->n_allocated_pages, 1);
return page;}
static void crypt_page_free(void *page, void *pool_data){ struct crypt_config *cc = pool_data;
__free_page(page); percpu_counter_sub(&cc->n_allocated_pages, 1);}
static void crypt_dtr(struct dm_target *ti){ struct crypt_config *cc = ti->private;
ti->private = NULL;
if (!cc) return;
if (cc->write_thread) kthread_stop(cc->write_thread);
if (cc->io_queue) destroy_workqueue(cc->io_queue); if (cc->crypt_queue) destroy_workqueue(cc->crypt_queue);
if (cc->workqueue_id) ida_free(&workqueue_ida, cc->workqueue_id);
crypt_free_tfms(cc);
bioset_exit(&cc->bs);
mempool_exit(&cc->page_pool); mempool_exit(&cc->req_pool); mempool_exit(&cc->tag_pool);
WARN_ON(percpu_counter_sum(&cc->n_allocated_pages) != 0); percpu_counter_destroy(&cc->n_allocated_pages);
if (cc->iv_gen_ops && cc->iv_gen_ops->dtr) cc->iv_gen_ops->dtr(cc);
if (cc->dev) dm_put_device(ti, cc->dev);
kfree_sensitive(cc->cipher_string); kfree_sensitive(cc->key_string); kfree_sensitive(cc->cipher_auth); kfree_sensitive(cc->authenc_key);
mutex_destroy(&cc->bio_alloc_lock);
/* Must zero key material before freeing */ kfree_sensitive(cc);
spin_lock(&dm_crypt_clients_lock); WARN_ON(!dm_crypt_clients_n); dm_crypt_clients_n--; crypt_calculate_pages_per_client(); spin_unlock(&dm_crypt_clients_lock);
dm_audit_log_dtr(DM_MSG_PREFIX, ti, 1);}
static int crypt_ctr_ivmode(struct dm_target *ti, const char *ivmode){ struct crypt_config *cc = ti->private;
if (crypt_integrity_aead(cc)) cc->iv_size = crypto_aead_ivsize(any_tfm_aead(cc)); else cc->iv_size = crypto_skcipher_ivsize(any_tfm(cc));
if (cc->iv_size) /* at least a 64 bit sector number should fit in our buffer */ cc->iv_size = max(cc->iv_size, (unsigned int)(sizeof(u64) / sizeof(u8))); else if (ivmode) { DMWARN("Selected cipher does not support IVs"); ivmode = NULL; }
/* Choose ivmode, see comments at iv code. */ if (ivmode == NULL) cc->iv_gen_ops = NULL; else if (strcmp(ivmode, "plain") == 0) cc->iv_gen_ops = &crypt_iv_plain_ops; else if (strcmp(ivmode, "plain64") == 0) cc->iv_gen_ops = &crypt_iv_plain64_ops; else if (strcmp(ivmode, "plain64be") == 0) cc->iv_gen_ops = &crypt_iv_plain64be_ops; else if (strcmp(ivmode, "essiv") == 0) cc->iv_gen_ops = &crypt_iv_essiv_ops; else if (strcmp(ivmode, "benbi") == 0) cc->iv_gen_ops = &crypt_iv_benbi_ops; else if (strcmp(ivmode, "null") == 0) cc->iv_gen_ops = &crypt_iv_null_ops; else if (strcmp(ivmode, "eboiv") == 0) cc->iv_gen_ops = &crypt_iv_eboiv_ops; else if (strcmp(ivmode, "elephant") == 0) { cc->iv_gen_ops = &crypt_iv_elephant_ops; cc->key_parts = 2; cc->key_extra_size = cc->key_size / 2; if (cc->key_extra_size > ELEPHANT_MAX_KEY_SIZE) return -EINVAL; set_bit(CRYPT_ENCRYPT_PREPROCESS, &cc->cipher_flags); } else if (strcmp(ivmode, "lmk") == 0) { cc->iv_gen_ops = &crypt_iv_lmk_ops; /* * Version 2 and 3 is recognised according * to length of provided multi-key string. * If present (version 3), last key is used as IV seed. * All keys (including IV seed) are always the same size. */ if (cc->key_size % cc->key_parts) { cc->key_parts++; cc->key_extra_size = cc->key_size / cc->key_parts; } } else if (strcmp(ivmode, "tcw") == 0) { cc->iv_gen_ops = &crypt_iv_tcw_ops; cc->key_parts += 2; /* IV + whitening */ cc->key_extra_size = cc->iv_size + TCW_WHITENING_SIZE; } else if (strcmp(ivmode, "random") == 0) { cc->iv_gen_ops = &crypt_iv_random_ops; /* Need storage space in integrity fields. */ cc->integrity_iv_size = cc->iv_size; } else { ti->error = "Invalid IV mode"; return -EINVAL; }
return 0;}
/* * Workaround to parse HMAC algorithm from AEAD crypto API spec. * The HMAC is needed to calculate tag size (HMAC digest size). * This should be probably done by crypto-api calls (once available...) */static int crypt_ctr_auth_cipher(struct crypt_config *cc, char *cipher_api){ char *start, *end, *mac_alg = NULL; struct crypto_ahash *mac;
if (!strstarts(cipher_api, "authenc(")) return 0;
start = strchr(cipher_api, '('); end = strchr(cipher_api, ','); if (!start || !end || ++start > end) return -EINVAL;
mac_alg = kmemdup_nul(start, end - start, GFP_KERNEL); if (!mac_alg) return -ENOMEM;
mac = crypto_alloc_ahash(mac_alg, 0, CRYPTO_ALG_ALLOCATES_MEMORY); kfree(mac_alg);
if (IS_ERR(mac)) return PTR_ERR(mac);
if (!test_bit(CRYPT_KEY_MAC_SIZE_SET, &cc->cipher_flags)) cc->key_mac_size = crypto_ahash_digestsize(mac); crypto_free_ahash(mac);
cc->authenc_key = kmalloc(crypt_authenckey_size(cc), GFP_KERNEL); if (!cc->authenc_key) return -ENOMEM;
return 0;}
static int crypt_ctr_cipher_new(struct dm_target *ti, char *cipher_in, char *key, char **ivmode, char **ivopts){ struct crypt_config *cc = ti->private; char *tmp, *cipher_api, buf[CRYPTO_MAX_ALG_NAME]; int ret = -EINVAL;
cc->tfms_count = 1;
/* * New format (capi: prefix) * capi:cipher_api_spec-iv:ivopts */ tmp = &cipher_in[strlen("capi:")];
/* Separate IV options if present, it can contain another '-' in hash name */ *ivopts = strrchr(tmp, ':'); if (*ivopts) { **ivopts = '\0'; (*ivopts)++; } /* Parse IV mode */ *ivmode = strrchr(tmp, '-'); if (*ivmode) { **ivmode = '\0'; (*ivmode)++; } /* The rest is crypto API spec */ cipher_api = tmp;
/* Alloc AEAD, can be used only in new format. */ if (crypt_integrity_aead(cc)) { ret = crypt_ctr_auth_cipher(cc, cipher_api); if (ret < 0) { ti->error = "Invalid AEAD cipher spec"; return ret; } }
if (*ivmode && !strcmp(*ivmode, "lmk")) { if (crypt_integrity_aead(cc)) { ti->error = "AEAD transforms not supported for LMK"; return -EINVAL; } cc->tfms_count = 64; }
if (*ivmode && !strcmp(*ivmode, "essiv")) { if (!*ivopts) { ti->error = "Digest algorithm missing for ESSIV mode"; return -EINVAL; } ret = snprintf(buf, CRYPTO_MAX_ALG_NAME, "essiv(%s,%s)", cipher_api, *ivopts); if (ret < 0 || ret >= CRYPTO_MAX_ALG_NAME) { ti->error = "Cannot allocate cipher string"; return -ENOMEM; } cipher_api = buf; }
cc->key_parts = cc->tfms_count;
/* Allocate cipher */ ret = crypt_alloc_tfms(cc, cipher_api); if (ret < 0) { ti->error = "Error allocating crypto tfm"; return ret; }
if (crypt_integrity_aead(cc)) cc->iv_size = crypto_aead_ivsize(any_tfm_aead(cc)); else cc->iv_size = crypto_skcipher_ivsize(any_tfm(cc));
return 0;}
static int crypt_ctr_cipher_old(struct dm_target *ti, char *cipher_in, char *key, char **ivmode, char **ivopts){ struct crypt_config *cc = ti->private; char *tmp, *cipher, *chainmode, *keycount; char *cipher_api = NULL; int ret = -EINVAL; char dummy;
if (strchr(cipher_in, '(') || crypt_integrity_aead(cc)) { ti->error = "Bad cipher specification"; return -EINVAL; }
/* * Legacy dm-crypt cipher specification * cipher[:keycount]-mode-iv:ivopts */ tmp = cipher_in; keycount = strsep(&tmp, "-"); cipher = strsep(&keycount, ":");
if (!keycount) cc->tfms_count = 1; else if (sscanf(keycount, "%u%c", &cc->tfms_count, &dummy) != 1 || !is_power_of_2(cc->tfms_count)) { ti->error = "Bad cipher key count specification"; return -EINVAL; } cc->key_parts = cc->tfms_count;
chainmode = strsep(&tmp, "-"); *ivmode = strsep(&tmp, ":"); *ivopts = tmp;
/* * For compatibility with the original dm-crypt mapping format, if * only the cipher name is supplied, use cbc-plain. */ if (!chainmode || (!strcmp(chainmode, "plain") && !*ivmode)) { chainmode = "cbc"; *ivmode = "plain"; }
if (strcmp(chainmode, "ecb") && !*ivmode) { ti->error = "IV mechanism required"; return -EINVAL; }
cipher_api = kmalloc(CRYPTO_MAX_ALG_NAME, GFP_KERNEL); if (!cipher_api) goto bad_mem;
if (*ivmode && !strcmp(*ivmode, "essiv")) { if (!*ivopts) { ti->error = "Digest algorithm missing for ESSIV mode"; kfree(cipher_api); return -EINVAL; } ret = snprintf(cipher_api, CRYPTO_MAX_ALG_NAME, "essiv(%s(%s),%s)", chainmode, cipher, *ivopts); } else { ret = snprintf(cipher_api, CRYPTO_MAX_ALG_NAME, "%s(%s)", chainmode, cipher); } if (ret < 0 || ret >= CRYPTO_MAX_ALG_NAME) { kfree(cipher_api); goto bad_mem; }
/* Allocate cipher */ ret = crypt_alloc_tfms(cc, cipher_api); if (ret < 0) { ti->error = "Error allocating crypto tfm"; kfree(cipher_api); return ret; } kfree(cipher_api);
return 0;bad_mem: ti->error = "Cannot allocate cipher strings"; return -ENOMEM;}
static int crypt_ctr_cipher(struct dm_target *ti, char *cipher_in, char *key){ struct crypt_config *cc = ti->private; char *ivmode = NULL, *ivopts = NULL; int ret;
cc->cipher_string = kstrdup(cipher_in, GFP_KERNEL); if (!cc->cipher_string) { ti->error = "Cannot allocate cipher strings"; return -ENOMEM; }
if (strstarts(cipher_in, "capi:")) ret = crypt_ctr_cipher_new(ti, cipher_in, key, &ivmode, &ivopts); else ret = crypt_ctr_cipher_old(ti, cipher_in, key, &ivmode, &ivopts); if (ret) return ret;
/* Initialize IV */ ret = crypt_ctr_ivmode(ti, ivmode); if (ret < 0) return ret;
/* Initialize and set key */ ret = crypt_set_key(cc, key); if (ret < 0) { ti->error = "Error decoding and setting key"; return ret; }
/* Allocate IV */ if (cc->iv_gen_ops && cc->iv_gen_ops->ctr) { ret = cc->iv_gen_ops->ctr(cc, ti, ivopts); if (ret < 0) { ti->error = "Error creating IV"; return ret; } }
/* Initialize IV (set keys for ESSIV etc) */ if (cc->iv_gen_ops && cc->iv_gen_ops->init) { ret = cc->iv_gen_ops->init(cc); if (ret < 0) { ti->error = "Error initialising IV"; return ret; } }
/* wipe the kernel key payload copy */ if (cc->key_string) memzero_explicit(cc->key, cc->key_size);
return ret;}
static int crypt_ctr_optional(struct dm_target *ti, unsigned int argc, char **argv){ struct crypt_config *cc = ti->private; struct dm_arg_set as; static const struct dm_arg _args[] = { {0, 9, "Invalid number of feature args"}, }; unsigned int opt_params, val; const char *opt_string, *sval; char dummy; int ret;
/* Optional parameters */ as.argc = argc; as.argv = argv;
ret = dm_read_arg_group(_args, &as, &opt_params, &ti->error); if (ret) return ret;
while (opt_params--) { opt_string = dm_shift_arg(&as); if (!opt_string) { ti->error = "Not enough feature arguments"; return -EINVAL; }
if (!strcasecmp(opt_string, "allow_discards")) ti->num_discard_bios = 1;
else if (!strcasecmp(opt_string, "same_cpu_crypt")) set_bit(DM_CRYPT_SAME_CPU, &cc->flags); else if (!strcasecmp(opt_string, "high_priority")) set_bit(DM_CRYPT_HIGH_PRIORITY, &cc->flags);
else if (!strcasecmp(opt_string, "submit_from_crypt_cpus")) set_bit(DM_CRYPT_NO_OFFLOAD, &cc->flags); else if (!strcasecmp(opt_string, "no_read_workqueue")) set_bit(DM_CRYPT_NO_READ_WORKQUEUE, &cc->flags); else if (!strcasecmp(opt_string, "no_write_workqueue")) set_bit(DM_CRYPT_NO_WRITE_WORKQUEUE, &cc->flags); else if (sscanf(opt_string, "integrity:%u:", &val) == 1) { if (val == 0 || val > MAX_TAG_SIZE) { ti->error = "Invalid integrity arguments"; return -EINVAL; } cc->used_tag_size = val; sval = strchr(opt_string + strlen("integrity:"), ':') + 1; if (!strcasecmp(sval, "aead")) { set_bit(CRYPT_MODE_INTEGRITY_AEAD, &cc->cipher_flags); } else if (strcasecmp(sval, "none")) { ti->error = "Unknown integrity profile"; return -EINVAL; }
cc->cipher_auth = kstrdup(sval, GFP_KERNEL); if (!cc->cipher_auth) return -ENOMEM; } else if (sscanf(opt_string, "integrity_key_size:%u%c", &val, &dummy) == 1) { if (!val) { ti->error = "Invalid integrity_key_size argument"; return -EINVAL; } cc->key_mac_size = val; set_bit(CRYPT_KEY_MAC_SIZE_SET, &cc->cipher_flags); } else if (sscanf(opt_string, "sector_size:%u%c", &cc->sector_size, &dummy) == 1) { if (cc->sector_size < (1 << SECTOR_SHIFT) || cc->sector_size > DM_CRYPT_MAX_SECTOR_SIZE || (cc->sector_size & (cc->sector_size - 1))) { ti->error = "Invalid feature value for sector_size"; return -EINVAL; } if (ti->len & ((cc->sector_size >> SECTOR_SHIFT) - 1)) { ti->error = "Device size is not multiple of sector_size feature"; return -EINVAL; } cc->sector_shift = __ffs(cc->sector_size) - SECTOR_SHIFT; } else if (!strcasecmp(opt_string, "iv_large_sectors")) set_bit(CRYPT_IV_LARGE_SECTORS, &cc->cipher_flags); else { ti->error = "Invalid feature arguments"; return -EINVAL; } }
return 0;}
#ifdef CONFIG_BLK_DEV_ZONEDstatic int crypt_report_zones(struct dm_target *ti, struct dm_report_zones_args *args, unsigned int nr_zones){ struct crypt_config *cc = ti->private;
return dm_report_zones(cc->dev->bdev, cc->start, cc->start + dm_target_offset(ti, args->next_sector), args, nr_zones);}#else#define crypt_report_zones NULL#endif
/* * Construct an encryption mapping: * <cipher> [<key>|:<key_size>:<user|logon>:<key_description>] <iv_offset> <dev_path> <start> */static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv){ struct crypt_config *cc; const char *devname = dm_table_device_name(ti->table); int key_size, wq_id; unsigned int align_mask; unsigned int common_wq_flags; unsigned long long tmpll; int ret; size_t iv_size_padding, additional_req_size; char dummy;
if (argc < 5) { ti->error = "Not enough arguments"; return -EINVAL; }
key_size = get_key_size(&argv[1]); if (key_size < 0) { ti->error = "Cannot parse key size"; return -EINVAL; }
cc = kzalloc_flex(*cc, key, key_size); if (!cc) { ti->error = "Cannot allocate encryption context"; return -ENOMEM; } cc->key_size = key_size; cc->sector_size = (1 << SECTOR_SHIFT); cc->sector_shift = 0;
ti->private = cc;
spin_lock(&dm_crypt_clients_lock); dm_crypt_clients_n++; crypt_calculate_pages_per_client(); spin_unlock(&dm_crypt_clients_lock);
ret = percpu_counter_init(&cc->n_allocated_pages, 0, GFP_KERNEL); if (ret < 0) goto bad;
/* Optional parameters need to be read before cipher constructor */ if (argc > 5) { ret = crypt_ctr_optional(ti, argc - 5, &argv[5]); if (ret) goto bad; }
ret = crypt_ctr_cipher(ti, argv[0], argv[1]); if (ret < 0) goto bad;
if (crypt_integrity_aead(cc)) { cc->dmreq_start = sizeof(struct aead_request); cc->dmreq_start += crypto_aead_reqsize(any_tfm_aead(cc)); align_mask = crypto_aead_alignmask(any_tfm_aead(cc)); } else { cc->dmreq_start = sizeof(struct skcipher_request); cc->dmreq_start += crypto_skcipher_reqsize(any_tfm(cc)); align_mask = crypto_skcipher_alignmask(any_tfm(cc)); } cc->dmreq_start = ALIGN(cc->dmreq_start, __alignof__(struct dm_crypt_request));
if (align_mask < CRYPTO_MINALIGN) { /* Allocate the padding exactly */ iv_size_padding = -(cc->dmreq_start + sizeof(struct dm_crypt_request)) & align_mask; } else { /* * If the cipher requires greater alignment than kmalloc * alignment, we don't know the exact position of the * initialization vector. We must assume worst case. */ iv_size_padding = align_mask; }
/* ...| IV + padding | original IV | original sec. number | bio tag offset | */ additional_req_size = sizeof(struct dm_crypt_request) + iv_size_padding + cc->iv_size + cc->iv_size + sizeof(uint64_t) + sizeof(unsigned int);
ret = mempool_init_kmalloc_pool(&cc->req_pool, MIN_IOS, cc->dmreq_start + additional_req_size); if (ret) { ti->error = "Cannot allocate crypt request mempool"; goto bad; }
cc->per_bio_data_size = ti->per_io_data_size = ALIGN(sizeof(struct dm_crypt_io) + cc->dmreq_start + additional_req_size, ARCH_DMA_MINALIGN);
ret = mempool_init(&cc->page_pool, BIO_MAX_VECS, crypt_page_alloc, crypt_page_free, cc); if (ret) { ti->error = "Cannot allocate page mempool"; goto bad; }
ret = bioset_init(&cc->bs, MIN_IOS, 0, BIOSET_NEED_BVECS); if (ret) { ti->error = "Cannot allocate crypt bioset"; goto bad; }
mutex_init(&cc->bio_alloc_lock);
ret = -EINVAL; if ((sscanf(argv[2], "%llu%c", &tmpll, &dummy) != 1) || (tmpll & ((cc->sector_size >> SECTOR_SHIFT) - 1))) { ti->error = "Invalid iv_offset sector"; goto bad; } cc->iv_offset = tmpll;
ret = dm_get_device(ti, argv[3], dm_table_get_mode(ti->table), &cc->dev); if (ret) { ti->error = "Device lookup failed"; goto bad; }
ret = -EINVAL; if (sscanf(argv[4], "%llu%c", &tmpll, &dummy) != 1 || tmpll != (sector_t)tmpll) { ti->error = "Invalid device sector"; goto bad; } cc->start = tmpll;
if (bdev_is_zoned(cc->dev->bdev)) { /* * For zoned block devices, we need to preserve the issuer write * ordering. To do so, disable write workqueues and force inline * encryption completion. */ set_bit(DM_CRYPT_NO_WRITE_WORKQUEUE, &cc->flags); set_bit(DM_CRYPT_WRITE_INLINE, &cc->flags);
/* * All zone append writes to a zone of a zoned block device will * have the same BIO sector, the start of the zone. When the * cypher IV mode uses sector values, all data targeting a * zone will be encrypted using the first sector numbers of the * zone. This will not result in write errors but will * cause most reads to fail as reads will use the sector values * for the actual data locations, resulting in IV mismatch. * To avoid this problem, ask DM core to emulate zone append * operations with regular writes. */ DMDEBUG("Zone append operations will be emulated"); ti->emulate_zone_append = true; }
if (crypt_integrity_aead(cc) || cc->integrity_iv_size) { ret = crypt_integrity_ctr(cc, ti); if (ret) goto bad;
cc->tag_pool_max_sectors = POOL_ENTRY_SIZE / cc->tuple_size; if (!cc->tag_pool_max_sectors) cc->tag_pool_max_sectors = 1;
ret = mempool_init_kmalloc_pool(&cc->tag_pool, MIN_IOS, cc->tag_pool_max_sectors * cc->tuple_size); if (ret) { ti->error = "Cannot allocate integrity tags mempool"; goto bad; }
cc->tag_pool_max_sectors <<= cc->sector_shift; }
wq_id = ida_alloc_min(&workqueue_ida, 1, GFP_KERNEL); if (wq_id < 0) { ti->error = "Couldn't get workqueue id"; ret = wq_id; goto bad; } cc->workqueue_id = wq_id;
ret = -ENOMEM; common_wq_flags = WQ_MEM_RECLAIM | WQ_SYSFS; if (test_bit(DM_CRYPT_HIGH_PRIORITY, &cc->flags)) common_wq_flags |= WQ_HIGHPRI;
cc->io_queue = alloc_workqueue("kcryptd_io-%s-%d", common_wq_flags | WQ_PERCPU, 1, devname, wq_id); if (!cc->io_queue) { ti->error = "Couldn't create kcryptd io queue"; goto bad; }
if (test_bit(DM_CRYPT_SAME_CPU, &cc->flags)) { cc->crypt_queue = alloc_workqueue("kcryptd-%s-%d", common_wq_flags | WQ_CPU_INTENSIVE | WQ_PERCPU, 1, devname, wq_id); } else { /* * While crypt_queue is certainly CPU intensive, the use of * WQ_CPU_INTENSIVE is meaningless with WQ_UNBOUND. */ cc->crypt_queue = alloc_workqueue("kcryptd-%s-%d", common_wq_flags | WQ_UNBOUND, num_online_cpus(), devname, wq_id); } if (!cc->crypt_queue) { ti->error = "Couldn't create kcryptd queue"; goto bad; }
spin_lock_init(&cc->write_thread_lock); cc->write_tree = RB_ROOT;
cc->write_thread = kthread_run(dmcrypt_write, cc, "dmcrypt_write/%s", devname); if (IS_ERR(cc->write_thread)) { ret = PTR_ERR(cc->write_thread); cc->write_thread = NULL; ti->error = "Couldn't spawn write thread"; goto bad; } if (test_bit(DM_CRYPT_HIGH_PRIORITY, &cc->flags)) set_user_nice(cc->write_thread, MIN_NICE);
ti->num_flush_bios = 1; ti->limit_swap_bios = true; ti->accounts_remapped_io = true;
dm_audit_log_ctr(DM_MSG_PREFIX, ti, 1); return 0;
bad: dm_audit_log_ctr(DM_MSG_PREFIX, ti, 0); crypt_dtr(ti); return ret;}
static int crypt_map(struct dm_target *ti, struct bio *bio){ struct dm_crypt_io *io; struct crypt_config *cc = ti->private; unsigned max_sectors; bool no_split;
/* * If bio is REQ_PREFLUSH or REQ_OP_DISCARD, just bypass crypt queues. * - for REQ_PREFLUSH device-mapper core ensures that no IO is in-flight * - for REQ_OP_DISCARD caller must use flush if IO ordering matters */ if (unlikely(bio->bi_opf & REQ_PREFLUSH || bio_op(bio) == REQ_OP_DISCARD)) { bio_set_dev(bio, cc->dev->bdev); if (bio_sectors(bio)) bio->bi_iter.bi_sector = cc->start + dm_target_offset(ti, bio->bi_iter.bi_sector); return DM_MAPIO_REMAPPED; }
/* * Check if bio is too large, split as needed. * * For zoned devices, splitting write operations creates the * risk of deadlocking queue freeze operations with zone write * plugging BIO work when the reminder of a split BIO is * issued. So always allow the entire BIO to proceed. */ no_split = (ti->emulate_zone_append && op_is_write(bio_op(bio))) || (bio->bi_opf & REQ_ATOMIC); max_sectors = get_max_request_sectors(ti, bio, no_split); if (unlikely(bio_sectors(bio) > max_sectors)) { if (unlikely(no_split)) return DM_MAPIO_KILL; dm_accept_partial_bio(bio, max_sectors); }
/* * Ensure that bio is a multiple of internal sector encryption size * and is aligned to this size as defined in IO hints. */ if (unlikely((bio->bi_iter.bi_sector & ((cc->sector_size >> SECTOR_SHIFT) - 1)) != 0)) return DM_MAPIO_KILL;
if (unlikely(bio->bi_iter.bi_size & (cc->sector_size - 1))) return DM_MAPIO_KILL;
io = dm_per_bio_data(bio, cc->per_bio_data_size); crypt_io_init(io, cc, bio, dm_target_offset(ti, bio->bi_iter.bi_sector));
if (cc->tuple_size) { unsigned int tag_len = cc->tuple_size * (bio_sectors(bio) >> cc->sector_shift);
if (unlikely(tag_len > KMALLOC_MAX_SIZE)) io->integrity_metadata = NULL; else io->integrity_metadata = kmalloc(tag_len, GFP_NOIO | __GFP_NORETRY | __GFP_NOMEMALLOC | __GFP_NOWARN);
if (unlikely(!io->integrity_metadata)) { if (bio_sectors(bio) > cc->tag_pool_max_sectors) dm_accept_partial_bio(bio, cc->tag_pool_max_sectors); io->integrity_metadata = mempool_alloc(&cc->tag_pool, GFP_NOIO); io->integrity_metadata_from_pool = true; } }
if (crypt_integrity_aead(cc)) io->ctx.r.req_aead = (struct aead_request *)(io + 1); else io->ctx.r.req = (struct skcipher_request *)(io + 1);
if (bio_data_dir(io->base_bio) == READ) { if (kcryptd_io_read(io, CRYPT_MAP_READ_GFP)) kcryptd_queue_read(io); } else kcryptd_queue_crypt(io);
return DM_MAPIO_SUBMITTED;}
static char hex2asc(unsigned char c){ return c + '0' + ((unsigned int)(9 - c) >> 4 & 0x27);}
static void crypt_status(struct dm_target *ti, status_type_t type, unsigned int status_flags, char *result, unsigned int maxlen){ struct crypt_config *cc = ti->private; unsigned int i, sz = 0; int num_feature_args = 0;
switch (type) { case STATUSTYPE_INFO: result[0] = '\0'; break;
case STATUSTYPE_TABLE: DMEMIT("%s ", cc->cipher_string);
if (cc->key_size > 0) { if (cc->key_string) DMEMIT(":%u:%s", cc->key_size, cc->key_string); else { for (i = 0; i < cc->key_size; i++) { DMEMIT("%c%c", hex2asc(cc->key[i] >> 4), hex2asc(cc->key[i] & 0xf)); } } } else DMEMIT("-");
DMEMIT(" %llu %s %llu", (unsigned long long)cc->iv_offset, cc->dev->name, (unsigned long long)cc->start);
num_feature_args += !!ti->num_discard_bios; num_feature_args += test_bit(DM_CRYPT_SAME_CPU, &cc->flags); num_feature_args += test_bit(DM_CRYPT_HIGH_PRIORITY, &cc->flags); num_feature_args += test_bit(DM_CRYPT_NO_OFFLOAD, &cc->flags); num_feature_args += test_bit(DM_CRYPT_NO_READ_WORKQUEUE, &cc->flags); num_feature_args += test_bit(DM_CRYPT_NO_WRITE_WORKQUEUE, &cc->flags); num_feature_args += !!cc->used_tag_size; num_feature_args += cc->sector_size != (1 << SECTOR_SHIFT); num_feature_args += test_bit(CRYPT_IV_LARGE_SECTORS, &cc->cipher_flags); num_feature_args += test_bit(CRYPT_KEY_MAC_SIZE_SET, &cc->cipher_flags); if (num_feature_args) { DMEMIT(" %d", num_feature_args); if (ti->num_discard_bios) DMEMIT(" allow_discards"); if (test_bit(DM_CRYPT_SAME_CPU, &cc->flags)) DMEMIT(" same_cpu_crypt"); if (test_bit(DM_CRYPT_HIGH_PRIORITY, &cc->flags)) DMEMIT(" high_priority"); if (test_bit(DM_CRYPT_NO_OFFLOAD, &cc->flags)) DMEMIT(" submit_from_crypt_cpus"); if (test_bit(DM_CRYPT_NO_READ_WORKQUEUE, &cc->flags)) DMEMIT(" no_read_workqueue"); if (test_bit(DM_CRYPT_NO_WRITE_WORKQUEUE, &cc->flags)) DMEMIT(" no_write_workqueue"); if (cc->used_tag_size) DMEMIT(" integrity:%u:%s", cc->used_tag_size, cc->cipher_auth); if (cc->sector_size != (1 << SECTOR_SHIFT)) DMEMIT(" sector_size:%u", cc->sector_size); if (test_bit(CRYPT_IV_LARGE_SECTORS, &cc->cipher_flags)) DMEMIT(" iv_large_sectors"); if (test_bit(CRYPT_KEY_MAC_SIZE_SET, &cc->cipher_flags)) DMEMIT(" integrity_key_size:%u", cc->key_mac_size); } break;
case STATUSTYPE_IMA: DMEMIT_TARGET_NAME_VERSION(ti->type); DMEMIT(",allow_discards=%c", ti->num_discard_bios ? 'y' : 'n'); DMEMIT(",same_cpu_crypt=%c", test_bit(DM_CRYPT_SAME_CPU, &cc->flags) ? 'y' : 'n'); DMEMIT(",high_priority=%c", test_bit(DM_CRYPT_HIGH_PRIORITY, &cc->flags) ? 'y' : 'n'); DMEMIT(",submit_from_crypt_cpus=%c", test_bit(DM_CRYPT_NO_OFFLOAD, &cc->flags) ? 'y' : 'n'); DMEMIT(",no_read_workqueue=%c", test_bit(DM_CRYPT_NO_READ_WORKQUEUE, &cc->flags) ? 'y' : 'n'); DMEMIT(",no_write_workqueue=%c", test_bit(DM_CRYPT_NO_WRITE_WORKQUEUE, &cc->flags) ? 'y' : 'n'); DMEMIT(",iv_large_sectors=%c", test_bit(CRYPT_IV_LARGE_SECTORS, &cc->cipher_flags) ? 'y' : 'n');
if (cc->used_tag_size) DMEMIT(",integrity_tag_size=%u,cipher_auth=%s", cc->used_tag_size, cc->cipher_auth); if (cc->sector_size != (1 << SECTOR_SHIFT)) DMEMIT(",sector_size=%u", cc->sector_size); if (cc->cipher_string) DMEMIT(",cipher_string=%s", cc->cipher_string);
DMEMIT(",key_size=%u", cc->key_size); DMEMIT(",key_parts=%u", cc->key_parts); DMEMIT(",key_extra_size=%u", cc->key_extra_size); DMEMIT(",key_mac_size=%u", cc->key_mac_size); DMEMIT(";"); break; }}
static void crypt_postsuspend(struct dm_target *ti){ struct crypt_config *cc = ti->private;
set_bit(DM_CRYPT_SUSPENDED, &cc->flags);}
static int crypt_preresume(struct dm_target *ti){ struct crypt_config *cc = ti->private;
if (!test_bit(DM_CRYPT_KEY_VALID, &cc->flags)) { DMERR("aborting resume - crypt key is not set."); return -EAGAIN; }
return 0;}
static void crypt_resume(struct dm_target *ti){ struct crypt_config *cc = ti->private;
clear_bit(DM_CRYPT_SUSPENDED, &cc->flags);}
/* Message interface * key set <key> * key wipe */static int crypt_message(struct dm_target *ti, unsigned int argc, char **argv, char *result, unsigned int maxlen){ struct crypt_config *cc = ti->private; int key_size, ret = -EINVAL;
if (argc < 2) goto error;
if (!strcasecmp(argv[0], "key")) { if (!test_bit(DM_CRYPT_SUSPENDED, &cc->flags)) { DMWARN("not suspended during key manipulation."); return -EINVAL; } if (argc == 3 && !strcasecmp(argv[1], "set")) { /* The key size may not be changed. */ key_size = get_key_size(&argv[2]); if (key_size < 0 || cc->key_size != key_size) { memzero_explicit(argv[2], strlen(argv[2])); return -EINVAL; }
ret = crypt_set_key(cc, argv[2]); if (ret) return ret; if (cc->iv_gen_ops && cc->iv_gen_ops->init) ret = cc->iv_gen_ops->init(cc); /* wipe the kernel key payload copy */ if (cc->key_string) memzero_explicit(cc->key, cc->key_size); return ret; } if (argc == 2 && !strcasecmp(argv[1], "wipe")) return crypt_wipe_key(cc); }
error: DMWARN("unrecognised message received."); return -EINVAL;}
static int crypt_iterate_devices(struct dm_target *ti, iterate_devices_callout_fn fn, void *data){ struct crypt_config *cc = ti->private;
return fn(ti, cc->dev, cc->start, ti->len, data);}
static void crypt_io_hints(struct dm_target *ti, struct queue_limits *limits){ struct crypt_config *cc = ti->private;
dm_stack_bs_limits(limits, cc->sector_size); limits->dma_alignment = limits->logical_block_size - 1;
/* * For zoned dm-crypt targets, there will be no internal splitting of * write BIOs to avoid exceeding BIO_MAX_VECS vectors per BIO. But * without respecting this limit, crypt_alloc_buffer() will trigger a * BUG(). Avoid this by forcing DM core to split write BIOs to this * limit. */ if (ti->emulate_zone_append) limits->max_hw_sectors = min(limits->max_hw_sectors, BIO_MAX_VECS << PAGE_SECTORS_SHIFT);
limits->atomic_write_hw_unit_max = min(limits->atomic_write_hw_unit_max, BIO_MAX_VECS << PAGE_SHIFT); limits->atomic_write_hw_max = min(limits->atomic_write_hw_max, BIO_MAX_VECS << PAGE_SHIFT);}
static struct target_type crypt_target = { .name = "crypt", .version = {1, 30, 0}, .module = THIS_MODULE, .ctr = crypt_ctr, .dtr = crypt_dtr, .features = DM_TARGET_ZONED_HM | DM_TARGET_ATOMIC_WRITES, .report_zones = crypt_report_zones, .map = crypt_map, .status = crypt_status, .postsuspend = crypt_postsuspend, .preresume = crypt_preresume, .resume = crypt_resume, .message = crypt_message, .iterate_devices = crypt_iterate_devices, .io_hints = crypt_io_hints,};module_dm(crypt);
MODULE_AUTHOR("Jana Saout <jana@saout.de>");MODULE_DESCRIPTION(DM_NAME " target for transparent encryption / decryption");MODULE_LICENSE("GPL");