Something went wrong. Try again.
Reactos
Something went wrong. Try again.
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658365936603661366236633664366536663667366836693670367136723673367436753676367736783679368036813682368336843685368636873688368936903691369236933694369536963697369836993700370137023703370437053706370737083709371037113712371337143715371637173718371937203721372237233724372537263727372837293730373137323733373437353736373737383739374037413742374337443745374637473748374937503751375237533754375537563757375837593760376137623763376437653766376737683769377037713772377337743775377637773778377937803781378237833784378537863787378837893790379137923793379437953796379737983799380038013802380338043805380638073808380938103811381238133814381538163817381838193820382138223823382438253826382738283829383038313832383338343835383638373838383938403841384238433844384538463847384838493850385138523853385438553856385738583859386038613862386338643865386638673868386938703871387238733874387538763877387838793880388138823883388438853886388738883889389038913892389338943895389638973898389939003901390239033904390539063907390839093910391139123913391439153916391739183919392039213922392339243925392639273928392939303931393239333934393539363937393839393940394139423943394439453946394739483949395039513952395339543955395639573958395939603961396239633964396539663967396839693970397139723973397439753976397739783979398039813982398339843985398639873988398939903991399239933994399539963997399839994000400140024003400440054006400740084009401040114012401340144015401640174018401940204021402240234024402540264027402840294030403140324033403440354036403740384039404040414042404340444045404640474048404940504051405240534054405540564057405840594060406140624063406440654066406740684069407040714072407340744075407640774078407940804081408240834084408540864087408840894090409140924093409440954096409740984099410041014102410341044105410641074108410941104111411241134114411541164117411841194120412141224123412441254126412741284129413041314132413341344135413641374138413941404141414241434144414541464147414841494150415141524153415441554156415741584159416041614162416341644165416641674168416941704171417241734174417541764177417841794180418141824183418441854186418741884189419041914192419341944195419641974198419942004201420242034204420542064207420842094210421142124213421442154216421742184219422042214222422342244225422642274228422942304231423242334234423542364237423842394240424142424243424442454246424742484249425042514252425342544255425642574258425942604261426242634264426542664267426842694270427142724273427442754276427742784279428042814282428342844285428642874288428942904291429242934294429542964297429842994300430143024303430443054306430743084309431043114312431343144315431643174318431943204321432243234324432543264327432843294330433143324333433443354336433743384339434043414342434343444345434643474348434943504351435243534354435543564357435843594360436143624363436443654366436743684369437043714372437343744375437643774378437943804381438243834384438543864387438843894390439143924393439443954396439743984399440044014402440344044405440644074408440944104411441244134414441544164417441844194420442144224423442444254426442744284429443044314432443344344435443644374438443944404441444244434444444544464447444844494450445144524453445444554456445744584459446044614462446344644465446644674468446944704471447244734474447544764477447844794480448144824483448444854486448744884489449044914492449344944495449644974498449945004501450245034504450545064507450845094510451145124513451445154516451745184519452045214522452345244525452645274528452945304531453245334534453545364537453845394540454145424543454445454546454745484549455045514552455345544555455645574558455945604561456245634564456545664567456845694570457145724573457445754576457745784579458045814582458345844585458645874588458945904591459245934594459545964597459845994600460146024603460446054606460746084609461046114612461346144615461646174618461946204621462246234624462546264627462846294630463146324633463446354636463746384639464046414642464346444645464646474648464946504651465246534654465546564657465846594660466146624663466446654666466746684669467046714672467346744675467646774678467946804681468246834684468546864687468846894690469146924693469446954696469746984699470047014702470347044705470647074708470947104711471247134714471547164717471847194720472147224723472447254726472747284729473047314732473347344735473647374738473947404741474247434744474547464747474847494750475147524753475447554756475747584759476047614762476347644765476647674768476947704771477247734774477547764777477847794780478147824783478447854786478747884789479047914792479347944795479647974798479948004801480248034804480548064807480848094810481148124813481448154816481748184819482048214822482348244825482648274828482948304831483248334834483548364837483848394840484148424843484448454846484748484849485048514852485348544855485648574858485948604861486248634864486548664867486848694870487148724873487448754876487748784879488048814882488348844885488648874888488948904891489248934894489548964897489848994900490149024903490449054906490749084909491049114912491349144915491649174918491949204921492249234924492549264927492849294930493149324933493449354936493749384939494049414942494349444945494649474948494949504951495249534954495549564957495849594960496149624963496449654966496749684969497049714972497349744975497649774978497949804981498249834984498549864987498849894990499149924993499449954996499749984999500050015002500350045005500650075008500950105011501250135014501550165017501850195020502150225023502450255026502750285029503050315032503350345035503650375038503950405041504250435044504550465047504850495050505150525053505450555056505750585059506050615062506350645065506650675068/* * Copyright 2005-2008 Juan Lang * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA * * This file implements ASN.1 DER encoding of a limited set of types. * It isn't a full ASN.1 implementation. Microsoft implements BER * encoding of many of the basic types in msasn1.dll, but that interface isn't * implemented, so I implement them here. * * References: * "A Layman's Guide to a Subset of ASN.1, BER, and DER", by Burton Kaliski * (available online, look for a PDF copy as the HTML versions tend to have * translation errors.) * * RFC3280, http://www.faqs.org/rfcs/rfc3280.html * * MSDN, especially "Constants for CryptEncodeObject and CryptDecodeObject" */
#include "config.h"#include "wine/port.h"
#include <assert.h>#include <stdarg.h>#include <stdio.h>#include <stdlib.h>
#define NONAMELESSUNION
#include "windef.h"#include "winbase.h"#include "wincrypt.h"#include "snmp.h"#include "wine/debug.h"#include "wine/exception.h"#include "wine/unicode.h"#include "crypt32_private.h"
WINE_DEFAULT_DEBUG_CHANNEL(cryptasn);WINE_DECLARE_DEBUG_CHANNEL(crypt);
typedef BOOL (WINAPI *CryptEncodeObjectFunc)(DWORD, LPCSTR, const void *, BYTE *, DWORD *);
/* Prototypes for built-in encoders. They follow the Ex style prototypes. * The dwCertEncodingType and lpszStructType are ignored by the built-in * functions, but the parameters are retained to simplify CryptEncodeObjectEx, * since it must call functions in external DLLs that follow these signatures. */BOOL WINAPI CRYPT_AsnEncodeOid(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);static BOOL WINAPI CRYPT_AsnEncodeExtensions(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);static BOOL WINAPI CRYPT_AsnEncodeSequenceOfAny(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);static BOOL WINAPI CRYPT_AsnEncodeBool(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);static BOOL WINAPI CRYPT_AsnEncodePubKeyInfo(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);static BOOL WINAPI CRYPT_AsnEncodeBits(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);static BOOL WINAPI CRYPT_AsnEncodeBitsSwapBytes(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);static BOOL WINAPI CRYPT_AsnEncodeInt(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);static BOOL WINAPI CRYPT_AsnEncodeInteger(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);static BOOL WINAPI CRYPT_AsnEncodeUnsignedInteger(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);static BOOL WINAPI CRYPT_AsnEncodeChoiceOfTime(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);static BOOL WINAPI CRYPT_AsnEncodeEnhancedKeyUsage(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);static BOOL WINAPI CRYPT_AsnEncodePKCSAttributes(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
BOOL CRYPT_EncodeEnsureSpace(DWORD dwFlags, const CRYPT_ENCODE_PARA *pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded, DWORD bytesNeeded){ BOOL ret = TRUE;
if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) { if (pEncodePara && pEncodePara->pfnAlloc) *(BYTE **)pbEncoded = pEncodePara->pfnAlloc(bytesNeeded); else *(BYTE **)pbEncoded = LocalAlloc(0, bytesNeeded); if (!*(BYTE **)pbEncoded) ret = FALSE; else *pcbEncoded = bytesNeeded; } else if (bytesNeeded > *pcbEncoded) { *pcbEncoded = bytesNeeded; SetLastError(ERROR_MORE_DATA); ret = FALSE; } else *pcbEncoded = bytesNeeded; return ret;}
static void CRYPT_FreeSpace(const CRYPT_ENCODE_PARA *pEncodePara, LPVOID pv){ if (pEncodePara && pEncodePara->pfnFree) pEncodePara->pfnFree(pv); else LocalFree(pv);}
BOOL CRYPT_EncodeLen(DWORD len, BYTE *pbEncoded, DWORD *pcbEncoded){ DWORD bytesNeeded, significantBytes = 0;
if (len <= 0x7f) bytesNeeded = 1; else { DWORD temp;
for (temp = len, significantBytes = sizeof(temp); !(temp & 0xff000000); temp <<= 8, significantBytes--) ; bytesNeeded = significantBytes + 1; } if (!pbEncoded) { *pcbEncoded = bytesNeeded; return TRUE; } if (*pcbEncoded < bytesNeeded) { SetLastError(ERROR_MORE_DATA); return FALSE; } if (len <= 0x7f) *pbEncoded = (BYTE)len; else { DWORD i;
*pbEncoded++ = significantBytes | 0x80; for (i = 0; i < significantBytes; i++) { *(pbEncoded + significantBytes - i - 1) = (BYTE)(len & 0xff); len >>= 8; } } *pcbEncoded = bytesNeeded; return TRUE;}
BOOL WINAPI CRYPT_AsnEncodeSequence(DWORD dwCertEncodingType, struct AsnEncodeSequenceItem items[], DWORD cItem, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret; DWORD i, dataLen = 0;
TRACE("%p, %d, %08x, %p, %p, %d\n", items, cItem, dwFlags, pEncodePara, pbEncoded, pbEncoded ? *pcbEncoded : 0); for (i = 0, ret = TRUE; ret && i < cItem; i++) { ret = items[i].encodeFunc(dwCertEncodingType, NULL, items[i].pvStructInfo, dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, NULL, &items[i].size); /* Some functions propagate their errors through the size */ if (!ret) *pcbEncoded = items[i].size; dataLen += items[i].size; } if (ret) { DWORD lenBytes, bytesNeeded;
CRYPT_EncodeLen(dataLen, NULL, &lenBytes); bytesNeeded = 1 + lenBytes + dataLen; if (!pbEncoded) *pcbEncoded = bytesNeeded; else { if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded, pcbEncoded, bytesNeeded))) { BYTE *out;
if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) pbEncoded = *(BYTE **)pbEncoded; out = pbEncoded; *out++ = ASN_SEQUENCE; CRYPT_EncodeLen(dataLen, out, &lenBytes); out += lenBytes; for (i = 0; ret && i < cItem; i++) { ret = items[i].encodeFunc(dwCertEncodingType, NULL, items[i].pvStructInfo, dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, out, &items[i].size); /* Some functions propagate their errors through the size */ if (!ret) *pcbEncoded = items[i].size; out += items[i].size; } if (!ret && (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)) CRYPT_FreeSpace(pEncodePara, pbEncoded); } } } TRACE("returning %d (%08x)\n", ret, GetLastError()); return ret;}
BOOL WINAPI CRYPT_AsnEncodeConstructed(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret; const struct AsnConstructedItem *item = pvStructInfo; DWORD len;
if ((ret = item->encodeFunc(dwCertEncodingType, lpszStructType, item->pvStructInfo, dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, NULL, &len))) { DWORD dataLen, bytesNeeded;
CRYPT_EncodeLen(len, NULL, &dataLen); bytesNeeded = 1 + dataLen + len; if (!pbEncoded) *pcbEncoded = bytesNeeded; else if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded, pcbEncoded, bytesNeeded))) { BYTE *out;
if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) pbEncoded = *(BYTE **)pbEncoded; out = pbEncoded; *out++ = ASN_CONTEXT | ASN_CONSTRUCTOR | item->tag; CRYPT_EncodeLen(len, out, &dataLen); out += dataLen; ret = item->encodeFunc(dwCertEncodingType, lpszStructType, item->pvStructInfo, dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, out, &len); if (!ret) { /* Some functions propagate their errors through the size */ *pcbEncoded = len; if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) CRYPT_FreeSpace(pEncodePara, pbEncoded); } } } else { /* Some functions propagate their errors through the size */ *pcbEncoded = len; } return ret;}
struct AsnEncodeTagSwappedItem{ BYTE tag; const void *pvStructInfo; CryptEncodeObjectExFunc encodeFunc;};
/* Sort of a wacky hack, it encodes something using the struct * AsnEncodeTagSwappedItem's encodeFunc, then replaces the tag byte with the tag * given in the struct AsnEncodeTagSwappedItem. */static BOOL WINAPI CRYPT_AsnEncodeSwapTag(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret; const struct AsnEncodeTagSwappedItem *item = pvStructInfo;
ret = item->encodeFunc(dwCertEncodingType, lpszStructType, item->pvStructInfo, dwFlags, pEncodePara, pbEncoded, pcbEncoded); if (ret && pbEncoded) *pbEncoded = item->tag; return ret;}
static BOOL WINAPI CRYPT_AsnEncodeCertVersion(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ const DWORD *ver = pvStructInfo; BOOL ret;
/* CERT_V1 is not encoded */ if (*ver == CERT_V1) { *pcbEncoded = 0; ret = TRUE; } else { struct AsnConstructedItem item = { 0, ver, CRYPT_AsnEncodeInt };
ret = CRYPT_AsnEncodeConstructed(dwCertEncodingType, X509_INTEGER, &item, dwFlags, pEncodePara, pbEncoded, pcbEncoded); } return ret;}
static BOOL WINAPI CRYPT_CopyEncodedBlob(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ const CRYPT_DER_BLOB *blob = pvStructInfo; BOOL ret;
if (!pbEncoded) { *pcbEncoded = blob->cbData; ret = TRUE; } else { if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded, pcbEncoded, blob->cbData))) { if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) pbEncoded = *(BYTE **)pbEncoded; if (blob->cbData) memcpy(pbEncoded, blob->pbData, blob->cbData); *pcbEncoded = blob->cbData; } } return ret;}
static BOOL WINAPI CRYPT_AsnEncodeValidity(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret; /* This has two filetimes in a row, a NotBefore and a NotAfter */ const FILETIME *timePtr = pvStructInfo; struct AsnEncodeSequenceItem items[] = { { timePtr, CRYPT_AsnEncodeChoiceOfTime, 0 }, { timePtr + 1, CRYPT_AsnEncodeChoiceOfTime, 0 }, };
ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, ARRAY_SIZE(items), dwFlags, pEncodePara, pbEncoded, pcbEncoded); return ret;}
/* Like CRYPT_AsnEncodeAlgorithmId, but encodes parameters as an asn.1 NULL * if they are empty. */static BOOL WINAPI CRYPT_AsnEncodeAlgorithmIdWithNullParams( DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ const CRYPT_ALGORITHM_IDENTIFIER *algo = pvStructInfo; static const BYTE asn1Null[] = { ASN_NULL, 0 }; static const CRYPT_DATA_BLOB nullBlob = { sizeof(asn1Null), (LPBYTE)asn1Null }; BOOL ret; struct AsnEncodeSequenceItem items[2] = { { algo->pszObjId, CRYPT_AsnEncodeOid, 0 }, { NULL, CRYPT_CopyEncodedBlob, 0 }, };
if (algo->Parameters.cbData) items[1].pvStructInfo = &algo->Parameters; else items[1].pvStructInfo = &nullBlob; ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, ARRAY_SIZE(items), dwFlags, pEncodePara, pbEncoded, pcbEncoded); return ret;}
static BOOL WINAPI CRYPT_AsnEncodeAlgorithmId(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ const CRYPT_ALGORITHM_IDENTIFIER *algo = pvStructInfo; BOOL ret; struct AsnEncodeSequenceItem items[] = { { algo->pszObjId, CRYPT_AsnEncodeOid, 0 }, { &algo->Parameters, CRYPT_CopyEncodedBlob, 0 }, };
ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, ARRAY_SIZE(items), dwFlags, pEncodePara, pbEncoded, pcbEncoded); return ret;}
static BOOL WINAPI CRYPT_AsnEncodePubKeyInfo(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret;
__TRY { const CERT_PUBLIC_KEY_INFO *info = pvStructInfo; struct AsnEncodeSequenceItem items[] = { { &info->Algorithm, CRYPT_AsnEncodeAlgorithmIdWithNullParams, 0 }, { &info->PublicKey, CRYPT_AsnEncodeBits, 0 }, };
TRACE("Encoding public key with OID %s\n", debugstr_a(info->Algorithm.pszObjId)); ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, ARRAY_SIZE(items), dwFlags, pEncodePara, pbEncoded, pcbEncoded); } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); ret = FALSE; } __ENDTRY return ret;}
static BOOL WINAPI CRYPT_AsnEncodeCert(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret;
__TRY { const CERT_SIGNED_CONTENT_INFO *info = pvStructInfo; struct AsnEncodeSequenceItem items[] = { { &info->ToBeSigned, CRYPT_CopyEncodedBlob, 0 }, { &info->SignatureAlgorithm, CRYPT_AsnEncodeAlgorithmId, 0 }, { &info->Signature, CRYPT_AsnEncodeBitsSwapBytes, 0 }, };
if (dwFlags & CRYPT_ENCODE_NO_SIGNATURE_BYTE_REVERSAL_FLAG) items[2].encodeFunc = CRYPT_AsnEncodeBits; ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, ARRAY_SIZE(items), dwFlags, pEncodePara, pbEncoded, pcbEncoded); } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); ret = FALSE; } __ENDTRY return ret;}
BOOL WINAPI CRYPT_AsnEncodePubKeyInfoNoNull(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret; const CERT_PUBLIC_KEY_INFO *info = pvStructInfo; struct AsnEncodeSequenceItem items[] = { { &info->Algorithm, CRYPT_AsnEncodeAlgorithmId, 0 }, { &info->PublicKey, CRYPT_AsnEncodeBits, 0 }, };
TRACE("Encoding public key with OID %s\n", debugstr_a(info->Algorithm.pszObjId)); ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, ARRAY_SIZE(items), dwFlags, pEncodePara, pbEncoded, pcbEncoded); return ret;}
/* Like in Windows, this blithely ignores the validity of the passed-in * CERT_INFO, and just encodes it as-is. The resulting encoded data may not * decode properly, see CRYPT_AsnDecodeCertInfo. */static BOOL WINAPI CRYPT_AsnEncodeCertInfo(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret;
__TRY { const CERT_INFO *info = pvStructInfo; struct AsnEncodeSequenceItem items[10] = { { &info->dwVersion, CRYPT_AsnEncodeCertVersion, 0 }, { &info->SerialNumber, CRYPT_AsnEncodeInteger, 0 }, { &info->SignatureAlgorithm, CRYPT_AsnEncodeAlgorithmId, 0 }, { &info->Issuer, CRYPT_CopyEncodedBlob, 0 }, { &info->NotBefore, CRYPT_AsnEncodeValidity, 0 }, { &info->Subject, CRYPT_CopyEncodedBlob, 0 }, { &info->SubjectPublicKeyInfo, CRYPT_AsnEncodePubKeyInfoNoNull, 0 }, { 0 } }; struct AsnConstructedItem constructed = { 0 }; struct AsnEncodeTagSwappedItem swapped[2] = { { 0 } }; DWORD cItem = 7, cSwapped = 0;
if (info->IssuerUniqueId.cbData) { swapped[cSwapped].tag = ASN_CONTEXT | 1; swapped[cSwapped].pvStructInfo = &info->IssuerUniqueId; swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeBits; items[cItem].pvStructInfo = &swapped[cSwapped]; items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag; cSwapped++; cItem++; } if (info->SubjectUniqueId.cbData) { swapped[cSwapped].tag = ASN_CONTEXT | 2; swapped[cSwapped].pvStructInfo = &info->SubjectUniqueId; swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeBits; items[cItem].pvStructInfo = &swapped[cSwapped]; items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag; cSwapped++; cItem++; } if (info->cExtension) { constructed.tag = 3; constructed.pvStructInfo = &info->cExtension; constructed.encodeFunc = CRYPT_AsnEncodeExtensions; items[cItem].pvStructInfo = &constructed; items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed; cItem++; }
ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem, dwFlags, pEncodePara, pbEncoded, pcbEncoded); } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); ret = FALSE; } __ENDTRY return ret;}
static BOOL CRYPT_AsnEncodeCRLEntry(const CRL_ENTRY *entry, BYTE *pbEncoded, DWORD *pcbEncoded){ struct AsnEncodeSequenceItem items[3] = { { &entry->SerialNumber, CRYPT_AsnEncodeInteger, 0 }, { &entry->RevocationDate, CRYPT_AsnEncodeChoiceOfTime, 0 }, { 0 } }; DWORD cItem = 2; BOOL ret;
TRACE("%p, %p, %d\n", entry, pbEncoded, pbEncoded ? *pcbEncoded : 0);
if (entry->cExtension) { items[cItem].pvStructInfo = &entry->cExtension; items[cItem].encodeFunc = CRYPT_AsnEncodeExtensions; cItem++; }
ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, cItem, 0, NULL, pbEncoded, pcbEncoded);
TRACE("returning %d (%08x)\n", ret, GetLastError()); return ret;}
static BOOL WINAPI CRYPT_AsnEncodeCRLEntries(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ DWORD bytesNeeded, dataLen, lenBytes, i; const CRL_INFO *info = pvStructInfo; const CRL_ENTRY *rgCRLEntry = info->rgCRLEntry; BOOL ret = TRUE;
for (i = 0, dataLen = 0; ret && i < info->cCRLEntry; i++) { DWORD size;
ret = CRYPT_AsnEncodeCRLEntry(&rgCRLEntry[i], NULL, &size); if (ret) dataLen += size; } if (ret) { CRYPT_EncodeLen(dataLen, NULL, &lenBytes); bytesNeeded = 1 + lenBytes + dataLen; if (!pbEncoded) *pcbEncoded = bytesNeeded; else { if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded, pcbEncoded, bytesNeeded))) { BYTE *out;
if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) pbEncoded = *(BYTE **)pbEncoded; out = pbEncoded; *out++ = ASN_SEQUENCEOF; CRYPT_EncodeLen(dataLen, out, &lenBytes); out += lenBytes; for (i = 0; i < info->cCRLEntry; i++) { DWORD size = dataLen;
ret = CRYPT_AsnEncodeCRLEntry(&rgCRLEntry[i], out, &size); out += size; dataLen -= size; } if (!ret && (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)) CRYPT_FreeSpace(pEncodePara, pbEncoded); } } } return ret;}
static BOOL WINAPI CRYPT_AsnEncodeCRLVersion(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ const DWORD *ver = pvStructInfo; BOOL ret;
/* CRL_V1 is not encoded */ if (*ver == CRL_V1) { *pcbEncoded = 0; ret = TRUE; } else ret = CRYPT_AsnEncodeInt(dwCertEncodingType, X509_INTEGER, ver, dwFlags, pEncodePara, pbEncoded, pcbEncoded); return ret;}
/* Like in Windows, this blithely ignores the validity of the passed-in * CRL_INFO, and just encodes it as-is. The resulting encoded data may not * decode properly, see CRYPT_AsnDecodeCRLInfo. */static BOOL WINAPI CRYPT_AsnEncodeCRLInfo(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret;
__TRY { const CRL_INFO *info = pvStructInfo; struct AsnEncodeSequenceItem items[7] = { { &info->dwVersion, CRYPT_AsnEncodeCRLVersion, 0 }, { &info->SignatureAlgorithm, CRYPT_AsnEncodeAlgorithmId, 0 }, { &info->Issuer, CRYPT_CopyEncodedBlob, 0 }, { &info->ThisUpdate, CRYPT_AsnEncodeChoiceOfTime, 0 }, { 0 } }; struct AsnConstructedItem constructed[1] = { { 0 } }; DWORD cItem = 4, cConstructed = 0;
if (info->NextUpdate.dwLowDateTime || info->NextUpdate.dwHighDateTime) { items[cItem].pvStructInfo = &info->NextUpdate; items[cItem].encodeFunc = CRYPT_AsnEncodeChoiceOfTime; cItem++; } if (info->cCRLEntry) { items[cItem].pvStructInfo = info; items[cItem].encodeFunc = CRYPT_AsnEncodeCRLEntries; cItem++; } if (info->cExtension) { constructed[cConstructed].tag = 0; constructed[cConstructed].pvStructInfo = &info->cExtension; constructed[cConstructed].encodeFunc = CRYPT_AsnEncodeExtensions; items[cItem].pvStructInfo = &constructed[cConstructed]; items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed; cConstructed++; cItem++; }
ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem, dwFlags, pEncodePara, pbEncoded, pcbEncoded); } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); ret = FALSE; } __ENDTRY return ret;}
static BOOL CRYPT_AsnEncodeExtension(CERT_EXTENSION *ext, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret; struct AsnEncodeSequenceItem items[3] = { { ext->pszObjId, CRYPT_AsnEncodeOid, 0 }, { NULL, NULL, 0 }, { NULL, NULL, 0 }, }; DWORD cItem = 1;
TRACE("%p, %p, %d\n", ext, pbEncoded, pbEncoded ? *pcbEncoded : 0);
if (ext->fCritical) { items[cItem].pvStructInfo = &ext->fCritical; items[cItem].encodeFunc = CRYPT_AsnEncodeBool; cItem++; } items[cItem].pvStructInfo = &ext->Value; items[cItem].encodeFunc = CRYPT_AsnEncodeOctets; cItem++;
ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, cItem, 0, NULL, pbEncoded, pcbEncoded); TRACE("returning %d (%08x)\n", ret, GetLastError()); return ret;}
static BOOL WINAPI CRYPT_AsnEncodeExtensions(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret;
__TRY { DWORD bytesNeeded, dataLen, lenBytes, i; const CERT_EXTENSIONS *exts = pvStructInfo;
ret = TRUE; for (i = 0, dataLen = 0; ret && i < exts->cExtension; i++) { DWORD size;
ret = CRYPT_AsnEncodeExtension(&exts->rgExtension[i], NULL, &size); if (ret) dataLen += size; } if (ret) { CRYPT_EncodeLen(dataLen, NULL, &lenBytes); bytesNeeded = 1 + lenBytes + dataLen; if (!pbEncoded) *pcbEncoded = bytesNeeded; else { if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded, pcbEncoded, bytesNeeded))) { BYTE *out;
if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) pbEncoded = *(BYTE **)pbEncoded; out = pbEncoded; *out++ = ASN_SEQUENCEOF; CRYPT_EncodeLen(dataLen, out, &lenBytes); out += lenBytes; for (i = 0; i < exts->cExtension; i++) { DWORD size = dataLen;
ret = CRYPT_AsnEncodeExtension(&exts->rgExtension[i], out, &size); out += size; dataLen -= size; } if (!ret && (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)) CRYPT_FreeSpace(pEncodePara, pbEncoded); } } } } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); ret = FALSE; } __ENDTRY return ret;}
BOOL WINAPI CRYPT_AsnEncodeOid(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ LPCSTR pszObjId = pvStructInfo; DWORD bytesNeeded = 0, lenBytes; BOOL ret = TRUE; int firstPos = 0; BYTE firstByte = 0;
TRACE("%s\n", debugstr_a(pszObjId));
if (pszObjId) { const char *ptr; int val1, val2;
if (sscanf(pszObjId, "%d.%d%n", &val1, &val2, &firstPos) != 2) { SetLastError(CRYPT_E_ASN1_ERROR); return FALSE; } bytesNeeded++; firstByte = val1 * 40 + val2; ptr = pszObjId + firstPos; if (*ptr == '.') { ptr++; firstPos++; } while (ret && *ptr) { int pos;
/* note I assume each component is at most 32-bits long in base 2 */ if (sscanf(ptr, "%d%n", &val1, &pos) == 1) { if (val1 >= 0x10000000) bytesNeeded += 5; else if (val1 >= 0x200000) bytesNeeded += 4; else if (val1 >= 0x4000) bytesNeeded += 3; else if (val1 >= 0x80) bytesNeeded += 2; else bytesNeeded += 1; ptr += pos; if (*ptr == '.') ptr++; } else { SetLastError(CRYPT_E_ASN1_ERROR); return FALSE; } } CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes); } else lenBytes = 1; bytesNeeded += 1 + lenBytes; if (pbEncoded) { if (*pcbEncoded < bytesNeeded) { SetLastError(ERROR_MORE_DATA); ret = FALSE; } else { *pbEncoded++ = ASN_OBJECTIDENTIFIER; CRYPT_EncodeLen(bytesNeeded - 1 - lenBytes, pbEncoded, &lenBytes); pbEncoded += lenBytes; if (pszObjId) { const char *ptr; int val, pos;
*pbEncoded++ = firstByte; ptr = pszObjId + firstPos; while (ret && *ptr) { sscanf(ptr, "%d%n", &val, &pos); { unsigned char outBytes[5]; int numBytes, i;
if (val >= 0x10000000) numBytes = 5; else if (val >= 0x200000) numBytes = 4; else if (val >= 0x4000) numBytes = 3; else if (val >= 0x80) numBytes = 2; else numBytes = 1; for (i = numBytes; i > 0; i--) { outBytes[i - 1] = val & 0x7f; val >>= 7; } for (i = 0; i < numBytes - 1; i++) *pbEncoded++ = outBytes[i] | 0x80; *pbEncoded++ = outBytes[i]; ptr += pos; if (*ptr == '.') ptr++; } } } } } *pcbEncoded = bytesNeeded; return ret;}
static BOOL CRYPT_AsnEncodeStringCoerce(const CERT_NAME_VALUE *value, BYTE tag, DWORD dwFlags, const CRYPT_ENCODE_PARA *pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret = TRUE; LPCSTR str = (LPCSTR)value->Value.pbData; DWORD bytesNeeded, lenBytes, encodedLen;
encodedLen = value->Value.cbData ? value->Value.cbData : strlen(str); CRYPT_EncodeLen(encodedLen, NULL, &lenBytes); bytesNeeded = 1 + lenBytes + encodedLen; if (!pbEncoded) *pcbEncoded = bytesNeeded; else { if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded, pcbEncoded, bytesNeeded))) { if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) pbEncoded = *(BYTE **)pbEncoded; *pbEncoded++ = tag; CRYPT_EncodeLen(encodedLen, pbEncoded, &lenBytes); pbEncoded += lenBytes; memcpy(pbEncoded, str, encodedLen); } } return ret;}
static BOOL CRYPT_AsnEncodeBMPString(const CERT_NAME_VALUE *value, DWORD dwFlags, const CRYPT_ENCODE_PARA *pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret = TRUE; LPCWSTR str = (LPCWSTR)value->Value.pbData; DWORD bytesNeeded, lenBytes, strLen;
if (value->Value.cbData) strLen = value->Value.cbData / sizeof(WCHAR); else if (value->Value.pbData) strLen = lstrlenW(str); else strLen = 0; CRYPT_EncodeLen(strLen * 2, NULL, &lenBytes); bytesNeeded = 1 + lenBytes + strLen * 2; if (!pbEncoded) *pcbEncoded = bytesNeeded; else { if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded, pcbEncoded, bytesNeeded))) { DWORD i;
if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) pbEncoded = *(BYTE **)pbEncoded; *pbEncoded++ = ASN_BMPSTRING; CRYPT_EncodeLen(strLen * 2, pbEncoded, &lenBytes); pbEncoded += lenBytes; for (i = 0; i < strLen; i++) { *pbEncoded++ = (str[i] & 0xff00) >> 8; *pbEncoded++ = str[i] & 0x00ff; } } } return ret;}
static BOOL CRYPT_AsnEncodeUTF8String(const CERT_NAME_VALUE *value, DWORD dwFlags, const CRYPT_ENCODE_PARA *pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret = TRUE; LPCWSTR str = (LPCWSTR)value->Value.pbData; DWORD bytesNeeded, lenBytes, encodedLen, strLen;
if (value->Value.cbData) strLen = value->Value.cbData / sizeof(WCHAR); else if (str) strLen = strlenW(str); else strLen = 0; encodedLen = WideCharToMultiByte(CP_UTF8, 0, str, strLen, NULL, 0, NULL, NULL); CRYPT_EncodeLen(encodedLen, NULL, &lenBytes); bytesNeeded = 1 + lenBytes + encodedLen; if (!pbEncoded) *pcbEncoded = bytesNeeded; else { if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded, pcbEncoded, bytesNeeded))) { if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) pbEncoded = *(BYTE **)pbEncoded; *pbEncoded++ = ASN_UTF8STRING; CRYPT_EncodeLen(encodedLen, pbEncoded, &lenBytes); pbEncoded += lenBytes; WideCharToMultiByte(CP_UTF8, 0, str, strLen, (LPSTR)pbEncoded, bytesNeeded - lenBytes - 1, NULL, NULL); } } return ret;}
static BOOL WINAPI CRYPT_AsnEncodeNameValue(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret = TRUE;
__TRY { const CERT_NAME_VALUE *value = pvStructInfo;
switch (value->dwValueType) { case CERT_RDN_ANY_TYPE: /* explicitly disallowed */ SetLastError(E_INVALIDARG); ret = FALSE; break; case CERT_RDN_ENCODED_BLOB: ret = CRYPT_CopyEncodedBlob(dwCertEncodingType, NULL, &value->Value, dwFlags, pEncodePara, pbEncoded, pcbEncoded); break; case CERT_RDN_OCTET_STRING: ret = CRYPT_AsnEncodeStringCoerce(value, ASN_OCTETSTRING, dwFlags, pEncodePara, pbEncoded, pcbEncoded); break; case CERT_RDN_NUMERIC_STRING: ret = CRYPT_AsnEncodeStringCoerce(value, ASN_NUMERICSTRING, dwFlags, pEncodePara, pbEncoded, pcbEncoded); break; case CERT_RDN_PRINTABLE_STRING: ret = CRYPT_AsnEncodeStringCoerce(value, ASN_PRINTABLESTRING, dwFlags, pEncodePara, pbEncoded, pcbEncoded); break; case CERT_RDN_TELETEX_STRING: ret = CRYPT_AsnEncodeStringCoerce(value, ASN_T61STRING, dwFlags, pEncodePara, pbEncoded, pcbEncoded); break; case CERT_RDN_VIDEOTEX_STRING: ret = CRYPT_AsnEncodeStringCoerce(value, ASN_VIDEOTEXSTRING, dwFlags, pEncodePara, pbEncoded, pcbEncoded); break; case CERT_RDN_IA5_STRING: ret = CRYPT_AsnEncodeStringCoerce(value, ASN_IA5STRING, dwFlags, pEncodePara, pbEncoded, pcbEncoded); break; case CERT_RDN_GRAPHIC_STRING: ret = CRYPT_AsnEncodeStringCoerce(value, ASN_GRAPHICSTRING, dwFlags, pEncodePara, pbEncoded, pcbEncoded); break; case CERT_RDN_VISIBLE_STRING: ret = CRYPT_AsnEncodeStringCoerce(value, ASN_VISIBLESTRING, dwFlags, pEncodePara, pbEncoded, pcbEncoded); break; case CERT_RDN_GENERAL_STRING: ret = CRYPT_AsnEncodeStringCoerce(value, ASN_GENERALSTRING, dwFlags, pEncodePara, pbEncoded, pcbEncoded); break; case CERT_RDN_UNIVERSAL_STRING: FIXME("CERT_RDN_UNIVERSAL_STRING: unimplemented\n"); SetLastError(CRYPT_E_ASN1_CHOICE); ret = FALSE; break; case CERT_RDN_BMP_STRING: ret = CRYPT_AsnEncodeBMPString(value, dwFlags, pEncodePara, pbEncoded, pcbEncoded); break; case CERT_RDN_UTF8_STRING: ret = CRYPT_AsnEncodeUTF8String(value, dwFlags, pEncodePara, pbEncoded, pcbEncoded); break; default: SetLastError(CRYPT_E_ASN1_CHOICE); ret = FALSE; } } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); ret = FALSE; } __ENDTRY return ret;}
static BOOL CRYPT_AsnEncodeRdnAttr(DWORD dwCertEncodingType, const CERT_RDN_ATTR *attr, CryptEncodeObjectExFunc nameValueEncodeFunc, BYTE *pbEncoded, DWORD *pcbEncoded){ DWORD bytesNeeded = 0, lenBytes, size; BOOL ret;
ret = CRYPT_AsnEncodeOid(dwCertEncodingType, NULL, attr->pszObjId, 0, NULL, NULL, &size); if (ret) { bytesNeeded += size; /* hack: a CERT_RDN_ATTR is identical to a CERT_NAME_VALUE beginning * with dwValueType, so "cast" it to get its encoded size */ ret = nameValueEncodeFunc(dwCertEncodingType, NULL, &attr->dwValueType, 0, NULL, NULL, &size); if (ret) { bytesNeeded += size; CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes); bytesNeeded += 1 + lenBytes; if (pbEncoded) { if (*pcbEncoded < bytesNeeded) { SetLastError(ERROR_MORE_DATA); ret = FALSE; } else { *pbEncoded++ = ASN_SEQUENCE; CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, pbEncoded, &lenBytes); pbEncoded += lenBytes; size = bytesNeeded - 1 - lenBytes; ret = CRYPT_AsnEncodeOid(dwCertEncodingType, NULL, attr->pszObjId, 0, NULL, pbEncoded, &size); if (ret) { pbEncoded += size; size = bytesNeeded - 1 - lenBytes - size; ret = nameValueEncodeFunc(dwCertEncodingType, NULL, &attr->dwValueType, 0, NULL, pbEncoded, &size); if (!ret) *pcbEncoded = size; } } } if (ret) *pcbEncoded = bytesNeeded; } else { /* Have to propagate index of failing character */ *pcbEncoded = size; } } return ret;}
static int BLOBComp(const void *l, const void *r){ const CRYPT_DER_BLOB *a = l, *b = r; int ret;
if (!(ret = memcmp(a->pbData, b->pbData, min(a->cbData, b->cbData)))) ret = a->cbData - b->cbData; return ret;}
/* This encodes a SET OF, which in DER must be lexicographically sorted. */static BOOL WINAPI CRYPT_DEREncodeSet(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ const CRYPT_BLOB_ARRAY *set = pvStructInfo; DWORD bytesNeeded = 0, lenBytes, i; BOOL ret;
for (i = 0; i < set->cBlob; i++) bytesNeeded += set->rgBlob[i].cbData; CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes); bytesNeeded += 1 + lenBytes; if (!pbEncoded) { *pcbEncoded = bytesNeeded; ret = TRUE; } else if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded, pcbEncoded, bytesNeeded))) { if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) pbEncoded = *(BYTE **)pbEncoded; qsort(set->rgBlob, set->cBlob, sizeof(CRYPT_DER_BLOB), BLOBComp); *pbEncoded++ = ASN_CONSTRUCTOR | ASN_SETOF; CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, pbEncoded, &lenBytes); pbEncoded += lenBytes; for (i = 0; i < set->cBlob; i++) { memcpy(pbEncoded, set->rgBlob[i].pbData, set->rgBlob[i].cbData); pbEncoded += set->rgBlob[i].cbData; } } return ret;}
struct DERSetDescriptor{ DWORD cItems; const void *items; size_t itemSize; size_t itemOffset; CryptEncodeObjectExFunc encode;};
static BOOL WINAPI CRYPT_DEREncodeItemsAsSet(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ const struct DERSetDescriptor *desc = pvStructInfo; CRYPT_BLOB_ARRAY setOf = { 0, NULL }; BOOL ret = TRUE; DWORD i;
if (desc->cItems) { setOf.rgBlob = CryptMemAlloc(desc->cItems * sizeof(CRYPT_DER_BLOB)); if (!setOf.rgBlob) ret = FALSE; else { setOf.cBlob = desc->cItems; memset(setOf.rgBlob, 0, setOf.cBlob * sizeof(CRYPT_DER_BLOB)); } } for (i = 0; ret && i < setOf.cBlob; i++) { ret = desc->encode(dwCertEncodingType, lpszStructType, (const BYTE *)desc->items + i * desc->itemSize + desc->itemOffset, 0, NULL, NULL, &setOf.rgBlob[i].cbData); if (ret) { setOf.rgBlob[i].pbData = CryptMemAlloc(setOf.rgBlob[i].cbData); if (!setOf.rgBlob[i].pbData) ret = FALSE; else ret = desc->encode(dwCertEncodingType, lpszStructType, (const BYTE *)desc->items + i * desc->itemSize + desc->itemOffset, 0, NULL, setOf.rgBlob[i].pbData, &setOf.rgBlob[i].cbData); } /* Some functions propagate their errors through the size */ if (!ret) *pcbEncoded = setOf.rgBlob[i].cbData; } if (ret) { DWORD bytesNeeded = 0, lenBytes;
for (i = 0; i < setOf.cBlob; i++) bytesNeeded += setOf.rgBlob[i].cbData; CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes); bytesNeeded += 1 + lenBytes; if (!pbEncoded) *pcbEncoded = bytesNeeded; else if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded, pcbEncoded, bytesNeeded))) { if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) pbEncoded = *(BYTE **)pbEncoded; qsort(setOf.rgBlob, setOf.cBlob, sizeof(CRYPT_DER_BLOB), BLOBComp); *pbEncoded++ = ASN_CONSTRUCTOR | ASN_SETOF; CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, pbEncoded, &lenBytes); pbEncoded += lenBytes; for (i = 0; i < setOf.cBlob; i++) { memcpy(pbEncoded, setOf.rgBlob[i].pbData, setOf.rgBlob[i].cbData); pbEncoded += setOf.rgBlob[i].cbData; } } } for (i = 0; i < setOf.cBlob; i++) CryptMemFree(setOf.rgBlob[i].pbData); CryptMemFree(setOf.rgBlob); return ret;}
static BOOL CRYPT_AsnEncodeRdn(DWORD dwCertEncodingType, const CERT_RDN *rdn, CryptEncodeObjectExFunc nameValueEncodeFunc, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret; CRYPT_BLOB_ARRAY setOf = { 0, NULL };
__TRY { DWORD i;
ret = TRUE; if (rdn->cRDNAttr) { setOf.rgBlob = CryptMemAlloc(rdn->cRDNAttr * sizeof(CRYPT_DER_BLOB)); if (!setOf.rgBlob) ret = FALSE; else { setOf.cBlob = rdn->cRDNAttr; memset(setOf.rgBlob, 0, setOf.cBlob * sizeof(CRYPT_DER_BLOB)); } } for (i = 0; ret && i < rdn->cRDNAttr; i++) { setOf.rgBlob[i].cbData = 0; ret = CRYPT_AsnEncodeRdnAttr(dwCertEncodingType, &rdn->rgRDNAttr[i], nameValueEncodeFunc, NULL, &setOf.rgBlob[i].cbData); if (ret) { setOf.rgBlob[i].pbData = CryptMemAlloc(setOf.rgBlob[i].cbData); if (!setOf.rgBlob[i].pbData) ret = FALSE; else ret = CRYPT_AsnEncodeRdnAttr(dwCertEncodingType, &rdn->rgRDNAttr[i], nameValueEncodeFunc, setOf.rgBlob[i].pbData, &setOf.rgBlob[i].cbData); } if (!ret) { /* Have to propagate index of failing character */ *pcbEncoded = setOf.rgBlob[i].cbData; } } if (ret) ret = CRYPT_DEREncodeSet(X509_ASN_ENCODING, NULL, &setOf, 0, NULL, pbEncoded, pcbEncoded); for (i = 0; i < setOf.cBlob; i++) CryptMemFree(setOf.rgBlob[i].pbData); } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); ret = FALSE; } __ENDTRY CryptMemFree(setOf.rgBlob); return ret;}
static BOOL WINAPI CRYPT_AsnEncodeUnicodeNameValue(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded);
static BOOL WINAPI CRYPT_AsnEncodeOrCopyUnicodeNameValue( DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ const CERT_NAME_VALUE *value = pvStructInfo; BOOL ret;
if (value->dwValueType == CERT_RDN_ENCODED_BLOB) ret = CRYPT_CopyEncodedBlob(dwCertEncodingType, NULL, &value->Value, dwFlags, pEncodePara, pbEncoded, pcbEncoded); else ret = CRYPT_AsnEncodeUnicodeNameValue(dwCertEncodingType, NULL, value, dwFlags, pEncodePara, pbEncoded, pcbEncoded); return ret;}
static BOOL WINAPI CRYPT_AsnEncodeUnicodeName(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret = TRUE;
__TRY { const CERT_NAME_INFO *info = pvStructInfo; DWORD bytesNeeded = 0, lenBytes, size, i;
TRACE("encoding name with %d RDNs\n", info->cRDN); ret = TRUE; for (i = 0; ret && i < info->cRDN; i++) { ret = CRYPT_AsnEncodeRdn(dwCertEncodingType, &info->rgRDN[i], CRYPT_AsnEncodeOrCopyUnicodeNameValue, NULL, &size); if (ret) bytesNeeded += size; else *pcbEncoded = size; } CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes); bytesNeeded += 1 + lenBytes; if (ret) { if (!pbEncoded) *pcbEncoded = bytesNeeded; else { if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded, pcbEncoded, bytesNeeded))) { BYTE *out;
if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) pbEncoded = *(BYTE **)pbEncoded; out = pbEncoded; *out++ = ASN_SEQUENCEOF; CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, out, &lenBytes); out += lenBytes; for (i = 0; ret && i < info->cRDN; i++) { size = bytesNeeded; ret = CRYPT_AsnEncodeRdn(dwCertEncodingType, &info->rgRDN[i], CRYPT_AsnEncodeOrCopyUnicodeNameValue, out, &size); if (ret) { out += size; bytesNeeded -= size; } else *pcbEncoded = size; } if (!ret && (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)) CRYPT_FreeSpace(pEncodePara, pbEncoded); } } } } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); ret = FALSE; } __ENDTRY return ret;}
static BOOL WINAPI CRYPT_AsnEncodeCTLVersion(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ const DWORD *ver = pvStructInfo; BOOL ret;
/* CTL_V1 is not encoded */ if (*ver == CTL_V1) { *pcbEncoded = 0; ret = TRUE; } else ret = CRYPT_AsnEncodeInt(dwCertEncodingType, X509_INTEGER, ver, dwFlags, pEncodePara, pbEncoded, pcbEncoded); return ret;}
/* Like CRYPT_AsnEncodeAlgorithmId, but encodes parameters as an asn.1 NULL * if they are empty and the OID is not empty (otherwise omits them.) */static BOOL WINAPI CRYPT_AsnEncodeCTLSubjectAlgorithm( DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ const CRYPT_ALGORITHM_IDENTIFIER *algo = pvStructInfo; BOOL ret; struct AsnEncodeSequenceItem items[2] = { { algo->pszObjId, CRYPT_AsnEncodeOid, 0 }, }; DWORD cItem = 1;
if (algo->pszObjId) { static const BYTE asn1Null[] = { ASN_NULL, 0 }; static const CRYPT_DATA_BLOB nullBlob = { sizeof(asn1Null), (LPBYTE)asn1Null };
if (algo->Parameters.cbData) items[cItem].pvStructInfo = &algo->Parameters; else items[cItem].pvStructInfo = &nullBlob; items[cItem].encodeFunc = CRYPT_CopyEncodedBlob; cItem++; } ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem, dwFlags, pEncodePara, pbEncoded, pcbEncoded); return ret;}
static BOOL CRYPT_AsnEncodeCTLEntry(const CTL_ENTRY *entry, BYTE *pbEncoded, DWORD *pcbEncoded){ struct AsnEncodeSequenceItem items[2] = { { &entry->SubjectIdentifier, CRYPT_AsnEncodeOctets, 0 }, { &entry->cAttribute, CRYPT_AsnEncodePKCSAttributes, 0 }, }; BOOL ret;
ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, ARRAY_SIZE(items), 0, NULL, pbEncoded, pcbEncoded); return ret;}
struct CTLEntries{ DWORD cEntry; CTL_ENTRY *rgEntry;};
static BOOL WINAPI CRYPT_AsnEncodeCTLEntries(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret; DWORD bytesNeeded, dataLen, lenBytes, i; const struct CTLEntries *entries = pvStructInfo;
ret = TRUE; for (i = 0, dataLen = 0; ret && i < entries->cEntry; i++) { DWORD size;
ret = CRYPT_AsnEncodeCTLEntry(&entries->rgEntry[i], NULL, &size); if (ret) dataLen += size; } if (ret) { CRYPT_EncodeLen(dataLen, NULL, &lenBytes); bytesNeeded = 1 + lenBytes + dataLen; if (!pbEncoded) *pcbEncoded = bytesNeeded; else { if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded, pcbEncoded, bytesNeeded))) { BYTE *out;
if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) pbEncoded = *(BYTE **)pbEncoded; out = pbEncoded; *out++ = ASN_SEQUENCEOF; CRYPT_EncodeLen(dataLen, out, &lenBytes); out += lenBytes; for (i = 0; ret && i < entries->cEntry; i++) { DWORD size = dataLen;
ret = CRYPT_AsnEncodeCTLEntry(&entries->rgEntry[i], out, &size); out += size; dataLen -= size; } if (!ret && (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)) CRYPT_FreeSpace(pEncodePara, pbEncoded); } } } return ret;}
static BOOL WINAPI CRYPT_AsnEncodeCTL(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret = FALSE;
__TRY { const CTL_INFO *info = pvStructInfo; struct AsnEncodeSequenceItem items[9] = { { &info->dwVersion, CRYPT_AsnEncodeCTLVersion, 0 }, { &info->SubjectUsage, CRYPT_AsnEncodeEnhancedKeyUsage, 0 }, }; struct AsnConstructedItem constructed = { 0 }; DWORD cItem = 2;
if (info->ListIdentifier.cbData) { items[cItem].pvStructInfo = &info->ListIdentifier; items[cItem].encodeFunc = CRYPT_AsnEncodeOctets; cItem++; } if (info->SequenceNumber.cbData) { items[cItem].pvStructInfo = &info->SequenceNumber; items[cItem].encodeFunc = CRYPT_AsnEncodeInteger; cItem++; } items[cItem].pvStructInfo = &info->ThisUpdate; items[cItem].encodeFunc = CRYPT_AsnEncodeChoiceOfTime; cItem++; if (info->NextUpdate.dwLowDateTime || info->NextUpdate.dwHighDateTime) { items[cItem].pvStructInfo = &info->NextUpdate; items[cItem].encodeFunc = CRYPT_AsnEncodeChoiceOfTime; cItem++; } items[cItem].pvStructInfo = &info->SubjectAlgorithm; items[cItem].encodeFunc = CRYPT_AsnEncodeCTLSubjectAlgorithm; cItem++; if (info->cCTLEntry) { items[cItem].pvStructInfo = &info->cCTLEntry; items[cItem].encodeFunc = CRYPT_AsnEncodeCTLEntries; cItem++; } if (info->cExtension) { constructed.tag = 0; constructed.pvStructInfo = &info->cExtension; constructed.encodeFunc = CRYPT_AsnEncodeExtensions; items[cItem].pvStructInfo = &constructed; items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed; cItem++; } ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem, dwFlags, pEncodePara, pbEncoded, pcbEncoded); } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); } __ENDTRY return ret;}
static BOOL CRYPT_AsnEncodeSMIMECapability(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret = FALSE;
__TRY { const CRYPT_SMIME_CAPABILITY *capability = pvStructInfo;
if (!capability->pszObjId) SetLastError(E_INVALIDARG); else { struct AsnEncodeSequenceItem items[] = { { capability->pszObjId, CRYPT_AsnEncodeOid, 0 }, { &capability->Parameters, CRYPT_CopyEncodedBlob, 0 }, };
ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, ARRAY_SIZE(items), dwFlags, pEncodePara, pbEncoded, pcbEncoded); } } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); } __ENDTRY return ret;}
static BOOL WINAPI CRYPT_AsnEncodeSMIMECapabilities(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret = FALSE;
__TRY { DWORD bytesNeeded, dataLen, lenBytes, i; const CRYPT_SMIME_CAPABILITIES *capabilities = pvStructInfo;
ret = TRUE; for (i = 0, dataLen = 0; ret && i < capabilities->cCapability; i++) { DWORD size;
ret = CRYPT_AsnEncodeSMIMECapability(dwCertEncodingType, NULL, &capabilities->rgCapability[i], 0, NULL, NULL, &size); if (ret) dataLen += size; } if (ret) { CRYPT_EncodeLen(dataLen, NULL, &lenBytes); bytesNeeded = 1 + lenBytes + dataLen; if (!pbEncoded) *pcbEncoded = bytesNeeded; else { if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded, pcbEncoded, bytesNeeded))) { BYTE *out;
if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) pbEncoded = *(BYTE **)pbEncoded; out = pbEncoded; *out++ = ASN_SEQUENCEOF; CRYPT_EncodeLen(dataLen, out, &lenBytes); out += lenBytes; for (i = 0; i < capabilities->cCapability; i++) { DWORD size = dataLen;
ret = CRYPT_AsnEncodeSMIMECapability(dwCertEncodingType, NULL, &capabilities->rgCapability[i], 0, NULL, out, &size); out += size; dataLen -= size; } if (!ret && (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)) CRYPT_FreeSpace(pEncodePara, pbEncoded); } } } } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); } __ENDTRY return ret;}
static BOOL WINAPI CRYPT_AsnEncodeNoticeNumbers(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ const CERT_POLICY_QUALIFIER_NOTICE_REFERENCE *noticeRef = pvStructInfo; DWORD bytesNeeded, dataLen, lenBytes, i; BOOL ret = TRUE;
for (i = 0, dataLen = 0; ret && i < noticeRef->cNoticeNumbers; i++) { DWORD size;
ret = CRYPT_AsnEncodeInt(dwCertEncodingType, X509_INTEGER, ¬iceRef->rgNoticeNumbers[i], 0, NULL, NULL, &size); if (ret) dataLen += size; } if (ret) { CRYPT_EncodeLen(dataLen, NULL, &lenBytes); bytesNeeded = 1 + lenBytes + dataLen; if (!pbEncoded) *pcbEncoded = bytesNeeded; else { if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded, pcbEncoded, bytesNeeded))) { BYTE *out;
if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) pbEncoded = *(BYTE **)pbEncoded; out = pbEncoded; *out++ = ASN_SEQUENCE; CRYPT_EncodeLen(dataLen, out, &lenBytes); out += lenBytes; for (i = 0; i < noticeRef->cNoticeNumbers; i++) { DWORD size = dataLen;
ret = CRYPT_AsnEncodeInt(dwCertEncodingType, X509_INTEGER, ¬iceRef->rgNoticeNumbers[i], 0, NULL, out, &size); out += size; dataLen -= size; } if (!ret && (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)) CRYPT_FreeSpace(pEncodePara, pbEncoded); } } } return ret;}
static BOOL WINAPI CRYPT_AsnEncodeNoticeReference(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ const CERT_POLICY_QUALIFIER_NOTICE_REFERENCE *noticeRef = pvStructInfo; BOOL ret; CERT_NAME_VALUE orgValue = { CERT_RDN_IA5_STRING, { 0, (LPBYTE)noticeRef->pszOrganization } }; struct AsnEncodeSequenceItem items[] = { { &orgValue, CRYPT_AsnEncodeNameValue, 0 }, { noticeRef, CRYPT_AsnEncodeNoticeNumbers, 0 }, };
ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, ARRAY_SIZE(items), dwFlags, pEncodePara, pbEncoded, pcbEncoded); return ret;}
static BOOL WINAPI CRYPT_AsnEncodePolicyQualifierUserNotice( DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret = FALSE;
__TRY { const CERT_POLICY_QUALIFIER_USER_NOTICE *notice = pvStructInfo; struct AsnEncodeSequenceItem items[2]; CERT_NAME_VALUE displayTextValue; DWORD cItem = 0;
if (notice->pNoticeReference) { items[cItem].encodeFunc = CRYPT_AsnEncodeNoticeReference; items[cItem].pvStructInfo = notice->pNoticeReference; cItem++; } if (notice->pszDisplayText) { displayTextValue.dwValueType = CERT_RDN_BMP_STRING; displayTextValue.Value.cbData = 0; displayTextValue.Value.pbData = (LPBYTE)notice->pszDisplayText; items[cItem].encodeFunc = CRYPT_AsnEncodeNameValue; items[cItem].pvStructInfo = &displayTextValue; cItem++; } ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem, dwFlags, pEncodePara, pbEncoded, pcbEncoded); } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); } __ENDTRY return ret;}
static BOOL WINAPI CRYPT_AsnEncodePKCSAttribute(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret = FALSE;
__TRY { const CRYPT_ATTRIBUTE *attr = pvStructInfo;
if (!attr->pszObjId) SetLastError(E_INVALIDARG); else { struct AsnEncodeSequenceItem items[2] = { { attr->pszObjId, CRYPT_AsnEncodeOid, 0 }, { &attr->cValue, CRYPT_DEREncodeSet, 0 }, };
ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, ARRAY_SIZE(items), dwFlags, pEncodePara, pbEncoded, pcbEncoded); } } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); } __ENDTRY return ret;}
static BOOL WINAPI CRYPT_AsnEncodePKCSAttributes(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret = FALSE;
__TRY { const CRYPT_ATTRIBUTES *attributes = pvStructInfo; struct DERSetDescriptor desc = { attributes->cAttr, attributes->rgAttr, sizeof(CRYPT_ATTRIBUTE), 0, CRYPT_AsnEncodePKCSAttribute };
ret = CRYPT_DEREncodeItemsAsSet(X509_ASN_ENCODING, lpszStructType, &desc, dwFlags, pEncodePara, pbEncoded, pcbEncoded); } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); } __ENDTRY return ret;}
/* Like CRYPT_AsnEncodePKCSContentInfo, but allows the OID to be NULL */static BOOL WINAPI CRYPT_AsnEncodePKCSContentInfoInternal( DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ const CRYPT_CONTENT_INFO *info = pvStructInfo; struct AsnEncodeSequenceItem items[2] = { { info->pszObjId, CRYPT_AsnEncodeOid, 0 }, { NULL, NULL, 0 }, }; struct AsnConstructedItem constructed = { 0 }; DWORD cItem = 1;
if (info->Content.cbData) { constructed.tag = 0; constructed.pvStructInfo = &info->Content; constructed.encodeFunc = CRYPT_CopyEncodedBlob; items[cItem].pvStructInfo = &constructed; items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed; cItem++; } return CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem, dwFlags, pEncodePara, pbEncoded, pcbEncoded);}
BOOL CRYPT_AsnEncodePKCSDigestedData(const CRYPT_DIGESTED_DATA *digestedData, void *pvData, DWORD *pcbData){ struct AsnEncodeSequenceItem items[] = { { &digestedData->version, CRYPT_AsnEncodeInt, 0 }, { &digestedData->DigestAlgorithm, CRYPT_AsnEncodeAlgorithmIdWithNullParams, 0 }, { &digestedData->ContentInfo, CRYPT_AsnEncodePKCSContentInfoInternal, 0 }, { &digestedData->hash, CRYPT_AsnEncodeOctets, 0 }, };
return CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, ARRAY_SIZE(items), 0, NULL, pvData, pcbData);}
static BOOL WINAPI CRYPT_AsnEncodePKCSContentInfo(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret = FALSE;
__TRY { const CRYPT_CONTENT_INFO *info = pvStructInfo;
if (!info->pszObjId) SetLastError(E_INVALIDARG); else ret = CRYPT_AsnEncodePKCSContentInfoInternal(dwCertEncodingType, lpszStructType, pvStructInfo, dwFlags, pEncodePara, pbEncoded, pcbEncoded); } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); } __ENDTRY return ret;}
static BOOL CRYPT_AsnEncodeUnicodeStringCoerce(const CERT_NAME_VALUE *value, BYTE tag, DWORD dwFlags, const CRYPT_ENCODE_PARA *pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret = TRUE; LPCWSTR str = (LPCWSTR)value->Value.pbData; DWORD bytesNeeded, lenBytes, encodedLen;
if (value->Value.cbData) encodedLen = value->Value.cbData / sizeof(WCHAR); else if (str) encodedLen = strlenW(str); else encodedLen = 0; CRYPT_EncodeLen(encodedLen, NULL, &lenBytes); bytesNeeded = 1 + lenBytes + encodedLen; if (!pbEncoded) *pcbEncoded = bytesNeeded; else { if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded, pcbEncoded, bytesNeeded))) { DWORD i;
if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) pbEncoded = *(BYTE **)pbEncoded; *pbEncoded++ = tag; CRYPT_EncodeLen(encodedLen, pbEncoded, &lenBytes); pbEncoded += lenBytes; for (i = 0; i < encodedLen; i++) *pbEncoded++ = (BYTE)str[i]; } } return ret;}
static BOOL CRYPT_AsnEncodeNumericString(const CERT_NAME_VALUE *value, DWORD dwFlags, const CRYPT_ENCODE_PARA *pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret = TRUE; LPCWSTR str = (LPCWSTR)value->Value.pbData; DWORD bytesNeeded, lenBytes, encodedLen;
if (value->Value.cbData) encodedLen = value->Value.cbData / sizeof(WCHAR); else if (str) encodedLen = strlenW(str); else encodedLen = 0; CRYPT_EncodeLen(encodedLen, NULL, &lenBytes); bytesNeeded = 1 + lenBytes + encodedLen; if (!pbEncoded) *pcbEncoded = bytesNeeded; else { if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded, pcbEncoded, bytesNeeded))) { DWORD i; BYTE *ptr;
if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) ptr = *(BYTE **)pbEncoded; else ptr = pbEncoded; *ptr++ = ASN_NUMERICSTRING; CRYPT_EncodeLen(encodedLen, ptr, &lenBytes); ptr += lenBytes; for (i = 0; ret && i < encodedLen; i++) { if (isdigitW(str[i])) *ptr++ = (BYTE)str[i]; else { *pcbEncoded = i; SetLastError(CRYPT_E_INVALID_NUMERIC_STRING); ret = FALSE; } } if (!ret && (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)) CRYPT_FreeSpace(pEncodePara, *(BYTE **)pbEncoded); } } return ret;}
static inline BOOL isprintableW(WCHAR wc){ return isalnumW(wc) || isspaceW(wc) || wc == '\'' || wc == '(' || wc == ')' || wc == '+' || wc == ',' || wc == '-' || wc == '.' || wc == '/' || wc == ':' || wc == '=' || wc == '?';}
static BOOL CRYPT_AsnEncodePrintableString(const CERT_NAME_VALUE *value, DWORD dwFlags, const CRYPT_ENCODE_PARA *pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret = TRUE; LPCWSTR str = (LPCWSTR)value->Value.pbData; DWORD bytesNeeded, lenBytes, encodedLen;
if (value->Value.cbData) encodedLen = value->Value.cbData / sizeof(WCHAR); else if (str) encodedLen = strlenW(str); else encodedLen = 0; CRYPT_EncodeLen(encodedLen, NULL, &lenBytes); bytesNeeded = 1 + lenBytes + encodedLen; if (!pbEncoded) *pcbEncoded = bytesNeeded; else { if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded, pcbEncoded, bytesNeeded))) { DWORD i; BYTE *ptr;
if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) ptr = *(BYTE **)pbEncoded; else ptr = pbEncoded; *ptr++ = ASN_PRINTABLESTRING; CRYPT_EncodeLen(encodedLen, ptr, &lenBytes); ptr += lenBytes; for (i = 0; ret && i < encodedLen; i++) { if (isprintableW(str[i])) *ptr++ = (BYTE)str[i]; else { *pcbEncoded = i; SetLastError(CRYPT_E_INVALID_PRINTABLE_STRING); ret = FALSE; } } if (!ret && (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)) CRYPT_FreeSpace(pEncodePara, *(BYTE **)pbEncoded); } } return ret;}
static BOOL CRYPT_AsnEncodeIA5String(const CERT_NAME_VALUE *value, DWORD dwFlags, const CRYPT_ENCODE_PARA *pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret = TRUE; LPCWSTR str = (LPCWSTR)value->Value.pbData; DWORD bytesNeeded, lenBytes, encodedLen;
if (value->Value.cbData) encodedLen = value->Value.cbData / sizeof(WCHAR); else if (str) encodedLen = strlenW(str); else encodedLen = 0; CRYPT_EncodeLen(encodedLen, NULL, &lenBytes); bytesNeeded = 1 + lenBytes + encodedLen; if (!pbEncoded) *pcbEncoded = bytesNeeded; else { if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded, pcbEncoded, bytesNeeded))) { DWORD i; BYTE *ptr;
if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) ptr = *(BYTE **)pbEncoded; else ptr = pbEncoded; *ptr++ = ASN_IA5STRING; CRYPT_EncodeLen(encodedLen, ptr, &lenBytes); ptr += lenBytes; for (i = 0; ret && i < encodedLen; i++) { if (str[i] <= 0x7f) *ptr++ = (BYTE)str[i]; else { *pcbEncoded = i; SetLastError(CRYPT_E_INVALID_IA5_STRING); ret = FALSE; } } if (!ret && (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)) CRYPT_FreeSpace(pEncodePara, *(BYTE **)pbEncoded); } } return ret;}
static BOOL CRYPT_AsnEncodeUniversalString(const CERT_NAME_VALUE *value, DWORD dwFlags, const CRYPT_ENCODE_PARA *pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret = TRUE; LPCWSTR str = (LPCWSTR)value->Value.pbData; DWORD bytesNeeded, lenBytes, strLen;
/* FIXME: doesn't handle composite characters */ if (value->Value.cbData) strLen = value->Value.cbData / sizeof(WCHAR); else if (str) strLen = strlenW(str); else strLen = 0; CRYPT_EncodeLen(strLen * 4, NULL, &lenBytes); bytesNeeded = 1 + lenBytes + strLen * 4; if (!pbEncoded) *pcbEncoded = bytesNeeded; else { if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded, pcbEncoded, bytesNeeded))) { DWORD i;
if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) pbEncoded = *(BYTE **)pbEncoded; *pbEncoded++ = ASN_UNIVERSALSTRING; CRYPT_EncodeLen(strLen * 4, pbEncoded, &lenBytes); pbEncoded += lenBytes; for (i = 0; i < strLen; i++) { *pbEncoded++ = 0; *pbEncoded++ = 0; *pbEncoded++ = (BYTE)((str[i] & 0xff00) >> 8); *pbEncoded++ = (BYTE)(str[i] & 0x00ff); } } } return ret;}
static BOOL WINAPI CRYPT_AsnEncodeUnicodeNameValue(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret = FALSE;
__TRY { const CERT_NAME_VALUE *value = pvStructInfo;
switch (value->dwValueType) { case CERT_RDN_ANY_TYPE: case CERT_RDN_ENCODED_BLOB: case CERT_RDN_OCTET_STRING: SetLastError(CRYPT_E_NOT_CHAR_STRING); break; case CERT_RDN_NUMERIC_STRING: ret = CRYPT_AsnEncodeNumericString(value, dwFlags, pEncodePara, pbEncoded, pcbEncoded); break; case CERT_RDN_PRINTABLE_STRING: ret = CRYPT_AsnEncodePrintableString(value, dwFlags, pEncodePara, pbEncoded, pcbEncoded); break; case CERT_RDN_TELETEX_STRING: ret = CRYPT_AsnEncodeUnicodeStringCoerce(value, ASN_T61STRING, dwFlags, pEncodePara, pbEncoded, pcbEncoded); break; case CERT_RDN_VIDEOTEX_STRING: ret = CRYPT_AsnEncodeUnicodeStringCoerce(value, ASN_VIDEOTEXSTRING, dwFlags, pEncodePara, pbEncoded, pcbEncoded); break; case CERT_RDN_IA5_STRING: ret = CRYPT_AsnEncodeIA5String(value, dwFlags, pEncodePara, pbEncoded, pcbEncoded); break; case CERT_RDN_GRAPHIC_STRING: ret = CRYPT_AsnEncodeUnicodeStringCoerce(value, ASN_GRAPHICSTRING, dwFlags, pEncodePara, pbEncoded, pcbEncoded); break; case CERT_RDN_VISIBLE_STRING: ret = CRYPT_AsnEncodeUnicodeStringCoerce(value, ASN_VISIBLESTRING, dwFlags, pEncodePara, pbEncoded, pcbEncoded); break; case CERT_RDN_GENERAL_STRING: ret = CRYPT_AsnEncodeUnicodeStringCoerce(value, ASN_GENERALSTRING, dwFlags, pEncodePara, pbEncoded, pcbEncoded); break; case CERT_RDN_UNIVERSAL_STRING: ret = CRYPT_AsnEncodeUniversalString(value, dwFlags, pEncodePara, pbEncoded, pcbEncoded); break; case CERT_RDN_BMP_STRING: ret = CRYPT_AsnEncodeBMPString(value, dwFlags, pEncodePara, pbEncoded, pcbEncoded); break; case CERT_RDN_UTF8_STRING: ret = CRYPT_AsnEncodeUTF8String(value, dwFlags, pEncodePara, pbEncoded, pcbEncoded); break; default: SetLastError(CRYPT_E_ASN1_CHOICE); } } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); } __ENDTRY return ret;}
static BOOL WINAPI CRYPT_AsnEncodeName(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret;
__TRY { const CERT_NAME_INFO *info = pvStructInfo; DWORD bytesNeeded = 0, lenBytes, size, i;
TRACE("encoding name with %d RDNs\n", info->cRDN); ret = TRUE; for (i = 0; ret && i < info->cRDN; i++) { ret = CRYPT_AsnEncodeRdn(dwCertEncodingType, &info->rgRDN[i], CRYPT_AsnEncodeNameValue, NULL, &size); if (ret) bytesNeeded += size; } CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes); bytesNeeded += 1 + lenBytes; if (ret) { if (!pbEncoded) *pcbEncoded = bytesNeeded; else { if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded, pcbEncoded, bytesNeeded))) { BYTE *out;
if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) pbEncoded = *(BYTE **)pbEncoded; out = pbEncoded; *out++ = ASN_SEQUENCEOF; CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, out, &lenBytes); out += lenBytes; for (i = 0; ret && i < info->cRDN; i++) { size = bytesNeeded; ret = CRYPT_AsnEncodeRdn(dwCertEncodingType, &info->rgRDN[i], CRYPT_AsnEncodeNameValue, out, &size); if (ret) { out += size; bytesNeeded -= size; } } if (!ret && (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)) CRYPT_FreeSpace(pEncodePara, pbEncoded); } } } } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); ret = FALSE; } __ENDTRY return ret;}
static BOOL WINAPI CRYPT_AsnEncodeBool(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL val = *(const BOOL *)pvStructInfo, ret;
TRACE("%d\n", val);
if (!pbEncoded) { *pcbEncoded = 3; ret = TRUE; } else if (*pcbEncoded < 3) { *pcbEncoded = 3; SetLastError(ERROR_MORE_DATA); ret = FALSE; } else { *pcbEncoded = 3; *pbEncoded++ = ASN_BOOL; *pbEncoded++ = 1; *pbEncoded++ = val ? 0xff : 0; ret = TRUE; } TRACE("returning %d (%08x)\n", ret, GetLastError()); return ret;}
static BOOL WINAPI CRYPT_AsnEncodeAltNameEntry(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ const CERT_ALT_NAME_ENTRY *entry = pvStructInfo; BOOL ret; DWORD dataLen; BYTE tag;
ret = TRUE; switch (entry->dwAltNameChoice) { case CERT_ALT_NAME_RFC822_NAME: case CERT_ALT_NAME_DNS_NAME: case CERT_ALT_NAME_URL: tag = ASN_CONTEXT | (entry->dwAltNameChoice - 1); if (entry->u.pwszURL) { DWORD i;
/* Not + 1: don't encode the NULL-terminator */ dataLen = lstrlenW(entry->u.pwszURL); for (i = 0; ret && i < dataLen; i++) { if (entry->u.pwszURL[i] > 0x7f) { SetLastError(CRYPT_E_INVALID_IA5_STRING); ret = FALSE; *pcbEncoded = i; } } } else dataLen = 0; break; case CERT_ALT_NAME_DIRECTORY_NAME: tag = ASN_CONTEXT | ASN_CONSTRUCTOR | (entry->dwAltNameChoice - 1); dataLen = entry->u.DirectoryName.cbData; break; case CERT_ALT_NAME_IP_ADDRESS: tag = ASN_CONTEXT | (entry->dwAltNameChoice - 1); dataLen = entry->u.IPAddress.cbData; break; case CERT_ALT_NAME_REGISTERED_ID: { struct AsnEncodeTagSwappedItem swapped = { ASN_CONTEXT | (entry->dwAltNameChoice - 1), entry->u.pszRegisteredID, CRYPT_AsnEncodeOid };
return CRYPT_AsnEncodeSwapTag(0, NULL, &swapped, 0, NULL, pbEncoded, pcbEncoded); } case CERT_ALT_NAME_OTHER_NAME: FIXME("name type %d unimplemented\n", entry->dwAltNameChoice); return FALSE; default: SetLastError(E_INVALIDARG); return FALSE; } if (ret) { DWORD bytesNeeded, lenBytes;
CRYPT_EncodeLen(dataLen, NULL, &lenBytes); bytesNeeded = 1 + dataLen + lenBytes; if (!pbEncoded) *pcbEncoded = bytesNeeded; else if (*pcbEncoded < bytesNeeded) { SetLastError(ERROR_MORE_DATA); *pcbEncoded = bytesNeeded; ret = FALSE; } else { *pbEncoded++ = tag; CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes); pbEncoded += lenBytes; switch (entry->dwAltNameChoice) { case CERT_ALT_NAME_RFC822_NAME: case CERT_ALT_NAME_DNS_NAME: case CERT_ALT_NAME_URL: { DWORD i;
for (i = 0; i < dataLen; i++) *pbEncoded++ = (BYTE)entry->u.pwszURL[i]; break; } case CERT_ALT_NAME_DIRECTORY_NAME: memcpy(pbEncoded, entry->u.DirectoryName.pbData, dataLen); break; case CERT_ALT_NAME_IP_ADDRESS: memcpy(pbEncoded, entry->u.IPAddress.pbData, dataLen); break; } if (ret) *pcbEncoded = bytesNeeded; } } TRACE("returning %d (%08x)\n", ret, GetLastError()); return ret;}
static BOOL WINAPI CRYPT_AsnEncodeAuthorityKeyId(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret;
__TRY { const CERT_AUTHORITY_KEY_ID_INFO *info = pvStructInfo; struct AsnEncodeSequenceItem items[3] = { { 0 } }; struct AsnEncodeTagSwappedItem swapped[3] = { { 0 } }; struct AsnConstructedItem constructed = { 0 }; DWORD cItem = 0, cSwapped = 0;
if (info->KeyId.cbData) { swapped[cSwapped].tag = ASN_CONTEXT | 0; swapped[cSwapped].pvStructInfo = &info->KeyId; swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeOctets; items[cItem].pvStructInfo = &swapped[cSwapped]; items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag; cSwapped++; cItem++; } if (info->CertIssuer.cbData) { constructed.tag = 1; constructed.pvStructInfo = &info->CertIssuer; constructed.encodeFunc = CRYPT_CopyEncodedBlob; items[cItem].pvStructInfo = &constructed; items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed; cItem++; } if (info->CertSerialNumber.cbData) { swapped[cSwapped].tag = ASN_CONTEXT | 2; swapped[cSwapped].pvStructInfo = &info->CertSerialNumber; swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeInteger; items[cItem].pvStructInfo = &swapped[cSwapped]; items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag; cSwapped++; cItem++; } ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, cItem, dwFlags, pEncodePara, pbEncoded, pcbEncoded); } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); ret = FALSE; } __ENDTRY return ret;}
static BOOL WINAPI CRYPT_AsnEncodeAltName(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret;
__TRY { const CERT_ALT_NAME_INFO *info = pvStructInfo; DWORD bytesNeeded, dataLen, lenBytes, i;
ret = TRUE; /* FIXME: should check that cAltEntry is not bigger than 0xff, since we * can't encode an erroneous entry index if it's bigger than this. */ for (i = 0, dataLen = 0; ret && i < info->cAltEntry; i++) { DWORD len;
ret = CRYPT_AsnEncodeAltNameEntry(dwCertEncodingType, NULL, &info->rgAltEntry[i], 0, NULL, NULL, &len); if (ret) dataLen += len; else if (GetLastError() == CRYPT_E_INVALID_IA5_STRING) { /* CRYPT_AsnEncodeAltNameEntry encoded the index of * the bad character, now set the index of the bad * entry */ *pcbEncoded = (BYTE)i << CERT_ALT_NAME_ENTRY_ERR_INDEX_SHIFT | len; } } if (ret) { CRYPT_EncodeLen(dataLen, NULL, &lenBytes); bytesNeeded = 1 + lenBytes + dataLen; if (!pbEncoded) { *pcbEncoded = bytesNeeded; ret = TRUE; } else { if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded, pcbEncoded, bytesNeeded))) { BYTE *out;
if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) pbEncoded = *(BYTE **)pbEncoded; out = pbEncoded; *out++ = ASN_SEQUENCEOF; CRYPT_EncodeLen(dataLen, out, &lenBytes); out += lenBytes; for (i = 0; ret && i < info->cAltEntry; i++) { DWORD len = dataLen;
ret = CRYPT_AsnEncodeAltNameEntry(dwCertEncodingType, NULL, &info->rgAltEntry[i], 0, NULL, out, &len); if (ret) { out += len; dataLen -= len; } } if (!ret && (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)) CRYPT_FreeSpace(pEncodePara, pbEncoded); } } } } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); ret = FALSE; } __ENDTRY return ret;}
static BOOL WINAPI CRYPT_AsnEncodeAuthorityKeyId2(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret;
__TRY { const CERT_AUTHORITY_KEY_ID2_INFO *info = pvStructInfo; struct AsnEncodeSequenceItem items[3] = { { 0 } }; struct AsnEncodeTagSwappedItem swapped[3] = { { 0 } }; DWORD cItem = 0, cSwapped = 0;
if (info->KeyId.cbData) { swapped[cSwapped].tag = ASN_CONTEXT | 0; swapped[cSwapped].pvStructInfo = &info->KeyId; swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeOctets; items[cItem].pvStructInfo = &swapped[cSwapped]; items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag; cSwapped++; cItem++; } if (info->AuthorityCertIssuer.cAltEntry) { swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 1; swapped[cSwapped].pvStructInfo = &info->AuthorityCertIssuer; swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeAltName; items[cItem].pvStructInfo = &swapped[cSwapped]; items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag; cSwapped++; cItem++; } if (info->AuthorityCertSerialNumber.cbData) { swapped[cSwapped].tag = ASN_CONTEXT | 2; swapped[cSwapped].pvStructInfo = &info->AuthorityCertSerialNumber; swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeInteger; items[cItem].pvStructInfo = &swapped[cSwapped]; items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag; cSwapped++; cItem++; } ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, cItem, dwFlags, pEncodePara, pbEncoded, pcbEncoded); } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); ret = FALSE; } __ENDTRY return ret;}
static BOOL CRYPT_AsnEncodeAccessDescription( const CERT_ACCESS_DESCRIPTION *descr, BYTE *pbEncoded, DWORD *pcbEncoded){ struct AsnEncodeSequenceItem items[] = { { descr->pszAccessMethod, CRYPT_AsnEncodeOid, 0 }, { &descr->AccessLocation, CRYPT_AsnEncodeAltNameEntry, 0 }, };
if (!descr->pszAccessMethod) { SetLastError(E_INVALIDARG); return FALSE; } return CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, ARRAY_SIZE(items), 0, NULL, pbEncoded, pcbEncoded);}
static BOOL WINAPI CRYPT_AsnEncodeAuthorityInfoAccess(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret;
__TRY { DWORD bytesNeeded, dataLen, lenBytes, i; const CERT_AUTHORITY_INFO_ACCESS *info = pvStructInfo;
ret = TRUE; for (i = 0, dataLen = 0; ret && i < info->cAccDescr; i++) { DWORD size;
ret = CRYPT_AsnEncodeAccessDescription(&info->rgAccDescr[i], NULL, &size); if (ret) dataLen += size; } if (ret) { CRYPT_EncodeLen(dataLen, NULL, &lenBytes); bytesNeeded = 1 + lenBytes + dataLen; if (!pbEncoded) *pcbEncoded = bytesNeeded; else { if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded, pcbEncoded, bytesNeeded))) { BYTE *out;
if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) pbEncoded = *(BYTE **)pbEncoded; out = pbEncoded; *out++ = ASN_SEQUENCEOF; CRYPT_EncodeLen(dataLen, out, &lenBytes); out += lenBytes; for (i = 0; i < info->cAccDescr; i++) { DWORD size = dataLen;
ret = CRYPT_AsnEncodeAccessDescription( &info->rgAccDescr[i], out, &size); out += size; dataLen -= size; } if (!ret && (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)) CRYPT_FreeSpace(pEncodePara, pbEncoded); } } } } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); ret = FALSE; } __ENDTRY return ret;}
static BOOL WINAPI CRYPT_AsnEncodeBasicConstraints(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret;
__TRY { const CERT_BASIC_CONSTRAINTS_INFO *info = pvStructInfo; struct AsnEncodeSequenceItem items[3] = { { &info->SubjectType, CRYPT_AsnEncodeBits, 0 }, { 0 } }; DWORD cItem = 1;
if (info->fPathLenConstraint) { items[cItem].pvStructInfo = &info->dwPathLenConstraint; items[cItem].encodeFunc = CRYPT_AsnEncodeInt; cItem++; } if (info->cSubtreesConstraint) { items[cItem].pvStructInfo = &info->cSubtreesConstraint; items[cItem].encodeFunc = CRYPT_AsnEncodeSequenceOfAny; cItem++; } ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem, dwFlags, pEncodePara, pbEncoded, pcbEncoded); } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); ret = FALSE; } __ENDTRY return ret;}
static BOOL WINAPI CRYPT_AsnEncodeBasicConstraints2(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret;
__TRY { const CERT_BASIC_CONSTRAINTS2_INFO *info = pvStructInfo; struct AsnEncodeSequenceItem items[2] = { { 0 } }; DWORD cItem = 0;
if (info->fCA) { items[cItem].pvStructInfo = &info->fCA; items[cItem].encodeFunc = CRYPT_AsnEncodeBool; cItem++; } if (info->fPathLenConstraint) { items[cItem].pvStructInfo = &info->dwPathLenConstraint; items[cItem].encodeFunc = CRYPT_AsnEncodeInt; cItem++; } ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem, dwFlags, pEncodePara, pbEncoded, pcbEncoded); } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); ret = FALSE; } __ENDTRY return ret;}
static BOOL WINAPI CRYPT_AsnEncodeCertPolicyQualifiers(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ const CERT_POLICY_INFO *info = pvStructInfo; BOOL ret;
if (!info->cPolicyQualifier) { *pcbEncoded = 0; ret = TRUE; } else { struct AsnEncodeSequenceItem items[2] = { { NULL, CRYPT_AsnEncodeOid, 0 }, { NULL, CRYPT_CopyEncodedBlob, 0 }, }; DWORD bytesNeeded = 0, lenBytes, size, i;
ret = TRUE; for (i = 0; ret && i < info->cPolicyQualifier; i++) { items[0].pvStructInfo = info->rgPolicyQualifier[i].pszPolicyQualifierId; items[1].pvStructInfo = &info->rgPolicyQualifier[i].Qualifier; ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, ARRAY_SIZE(items), dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, NULL, &size); if (ret) bytesNeeded += size; } CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes); bytesNeeded += 1 + lenBytes; if (ret) { if (!pbEncoded) *pcbEncoded = bytesNeeded; else { if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded, pcbEncoded, bytesNeeded))) { BYTE *out;
if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) pbEncoded = *(BYTE **)pbEncoded; out = pbEncoded; *out++ = ASN_SEQUENCEOF; CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, out, &lenBytes); out += lenBytes; for (i = 0; ret && i < info->cPolicyQualifier; i++) { items[0].pvStructInfo = info->rgPolicyQualifier[i].pszPolicyQualifierId; items[1].pvStructInfo = &info->rgPolicyQualifier[i].Qualifier; size = bytesNeeded; ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, ARRAY_SIZE(items), dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, out, &size); if (ret) { out += size; bytesNeeded -= size; } } if (!ret && (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)) CRYPT_FreeSpace(pEncodePara, pbEncoded); } } } } return ret;}
static BOOL CRYPT_AsnEncodeCertPolicy(DWORD dwCertEncodingType, const CERT_POLICY_INFO *info, DWORD dwFlags, BYTE *pbEncoded, DWORD *pcbEncoded){ struct AsnEncodeSequenceItem items[2] = { { info->pszPolicyIdentifier, CRYPT_AsnEncodeOid, 0 }, { info, CRYPT_AsnEncodeCertPolicyQualifiers, 0 }, }; BOOL ret;
if (!info->pszPolicyIdentifier) { SetLastError(E_INVALIDARG); return FALSE; } ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, ARRAY_SIZE(items), dwFlags, NULL, pbEncoded, pcbEncoded); return ret;}
static BOOL WINAPI CRYPT_AsnEncodeCertPolicies(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret = FALSE;
__TRY { const CERT_POLICIES_INFO *info = pvStructInfo; DWORD bytesNeeded = 0, lenBytes, size, i;
ret = TRUE; for (i = 0; ret && i < info->cPolicyInfo; i++) { ret = CRYPT_AsnEncodeCertPolicy(dwCertEncodingType, &info->rgPolicyInfo[i], dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, &size); if (ret) bytesNeeded += size; } CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes); bytesNeeded += 1 + lenBytes; if (ret) { if (!pbEncoded) *pcbEncoded = bytesNeeded; else { if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded, pcbEncoded, bytesNeeded))) { BYTE *out;
if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) pbEncoded = *(BYTE **)pbEncoded; out = pbEncoded; *out++ = ASN_SEQUENCEOF; CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, out, &lenBytes); out += lenBytes; for (i = 0; ret && i < info->cPolicyInfo; i++) { size = bytesNeeded; ret = CRYPT_AsnEncodeCertPolicy(dwCertEncodingType, &info->rgPolicyInfo[i], dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, out, &size); if (ret) { out += size; bytesNeeded -= size; } } if (!ret && (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)) CRYPT_FreeSpace(pEncodePara, pbEncoded); } } } } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); } __ENDTRY return ret;}
static BOOL CRYPT_AsnEncodeCertPolicyMapping(DWORD dwCertEncodingType, const CERT_POLICY_MAPPING *mapping, DWORD dwFlags, BYTE *pbEncoded, DWORD *pcbEncoded){ struct AsnEncodeSequenceItem items[] = { { mapping->pszIssuerDomainPolicy, CRYPT_AsnEncodeOid, 0 }, { mapping->pszSubjectDomainPolicy, CRYPT_AsnEncodeOid, 0 }, };
if (!mapping->pszIssuerDomainPolicy || !mapping->pszSubjectDomainPolicy) { SetLastError(E_INVALIDARG); return FALSE; } return CRYPT_AsnEncodeSequence(dwCertEncodingType, items, ARRAY_SIZE(items), dwFlags, NULL, pbEncoded, pcbEncoded);}
static BOOL WINAPI CRYPT_AsnEncodeCertPolicyMappings(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret = FALSE;
__TRY { const CERT_POLICY_MAPPINGS_INFO *info = pvStructInfo; DWORD bytesNeeded = 0, lenBytes, size, i;
ret = TRUE; for (i = 0; ret && i < info->cPolicyMapping; i++) { ret = CRYPT_AsnEncodeCertPolicyMapping(dwCertEncodingType, &info->rgPolicyMapping[i], dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, &size); if (ret) bytesNeeded += size; } CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes); bytesNeeded += 1 + lenBytes; if (ret) { if (!pbEncoded) *pcbEncoded = bytesNeeded; else { if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded, pcbEncoded, bytesNeeded))) { BYTE *out;
if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) pbEncoded = *(BYTE **)pbEncoded; out = pbEncoded; *out++ = ASN_SEQUENCEOF; CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, out, &lenBytes); out += lenBytes; for (i = 0; ret && i < info->cPolicyMapping; i++) { size = bytesNeeded; ret = CRYPT_AsnEncodeCertPolicyMapping( dwCertEncodingType, &info->rgPolicyMapping[i], dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, out, &size); if (ret) { out += size; bytesNeeded -= size; } } if (!ret && (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)) CRYPT_FreeSpace(pEncodePara, pbEncoded); } } } } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); } __ENDTRY return ret;}
static BOOL WINAPI CRYPT_AsnEncodeCertPolicyConstraints( DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret = FALSE;
__TRY { const CERT_POLICY_CONSTRAINTS_INFO *info = pvStructInfo; struct AsnEncodeSequenceItem items[2]; struct AsnEncodeTagSwappedItem swapped[2]; DWORD cItem = 0, cSwapped = 0;
if (info->fRequireExplicitPolicy) { swapped[cSwapped].tag = ASN_CONTEXT | 0; swapped[cSwapped].pvStructInfo = &info->dwRequireExplicitPolicySkipCerts; swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeInt; items[cItem].pvStructInfo = &swapped[cSwapped]; items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag; cSwapped++; cItem++; } if (info->fInhibitPolicyMapping) { swapped[cSwapped].tag = ASN_CONTEXT | 1; swapped[cSwapped].pvStructInfo = &info->dwInhibitPolicyMappingSkipCerts; swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeInt; items[cItem].pvStructInfo = &swapped[cSwapped]; items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag; cSwapped++; cItem++; } ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem, dwFlags, NULL, pbEncoded, pcbEncoded); } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); } __ENDTRY return ret;}
static BOOL WINAPI CRYPT_AsnEncodeRsaPubKey(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret;
__TRY { const BLOBHEADER *hdr = pvStructInfo;
if (hdr->bType != PUBLICKEYBLOB) { SetLastError(E_INVALIDARG); ret = FALSE; } else { const RSAPUBKEY *rsaPubKey = (const RSAPUBKEY *) ((const BYTE *)pvStructInfo + sizeof(BLOBHEADER)); CRYPT_INTEGER_BLOB blob = { rsaPubKey->bitlen / 8, (BYTE *)pvStructInfo + sizeof(BLOBHEADER) + sizeof(RSAPUBKEY) }; struct AsnEncodeSequenceItem items[] = { { &blob, CRYPT_AsnEncodeUnsignedInteger, 0 }, { &rsaPubKey->pubexp, CRYPT_AsnEncodeInt, 0 }, };
ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, ARRAY_SIZE(items), dwFlags, pEncodePara, pbEncoded, pcbEncoded); } } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); ret = FALSE; } __ENDTRY return ret;}
BOOL WINAPI CRYPT_AsnEncodeOctets(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret;
__TRY { const CRYPT_DATA_BLOB *blob = pvStructInfo; DWORD bytesNeeded, lenBytes;
TRACE("(%d, %p), %08x, %p, %p, %d\n", blob->cbData, blob->pbData, dwFlags, pEncodePara, pbEncoded, pbEncoded ? *pcbEncoded : 0);
CRYPT_EncodeLen(blob->cbData, NULL, &lenBytes); bytesNeeded = 1 + lenBytes + blob->cbData; if (!pbEncoded) { *pcbEncoded = bytesNeeded; ret = TRUE; } else { if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded, pcbEncoded, bytesNeeded))) { if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) pbEncoded = *(BYTE **)pbEncoded; *pbEncoded++ = ASN_OCTETSTRING; CRYPT_EncodeLen(blob->cbData, pbEncoded, &lenBytes); pbEncoded += lenBytes; if (blob->cbData) memcpy(pbEncoded, blob->pbData, blob->cbData); } } } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); ret = FALSE; } __ENDTRY TRACE("returning %d (%08x)\n", ret, GetLastError()); return ret;}
static BOOL WINAPI CRYPT_AsnEncodeBits(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret;
__TRY { const CRYPT_BIT_BLOB *blob = pvStructInfo; DWORD bytesNeeded, lenBytes, dataBytes; BYTE unusedBits;
/* yep, MS allows cUnusedBits to be >= 8 */ if (!blob->cUnusedBits) { dataBytes = blob->cbData; unusedBits = 0; } else if (blob->cbData * 8 > blob->cUnusedBits) { dataBytes = (blob->cbData * 8 - blob->cUnusedBits) / 8 + 1; unusedBits = blob->cUnusedBits >= 8 ? blob->cUnusedBits / 8 : blob->cUnusedBits; } else { dataBytes = 0; unusedBits = 0; } CRYPT_EncodeLen(dataBytes + 1, NULL, &lenBytes); bytesNeeded = 1 + lenBytes + dataBytes + 1; if (!pbEncoded) { *pcbEncoded = bytesNeeded; ret = TRUE; } else { if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded, pcbEncoded, bytesNeeded))) { if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) pbEncoded = *(BYTE **)pbEncoded; *pbEncoded++ = ASN_BITSTRING; CRYPT_EncodeLen(dataBytes + 1, pbEncoded, &lenBytes); pbEncoded += lenBytes; *pbEncoded++ = unusedBits; if (dataBytes) { BYTE mask = 0xff << unusedBits;
if (dataBytes > 1) { memcpy(pbEncoded, blob->pbData, dataBytes - 1); pbEncoded += dataBytes - 1; } *pbEncoded = *(blob->pbData + dataBytes - 1) & mask; } } } } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); ret = FALSE; } __ENDTRY return ret;}
static BOOL WINAPI CRYPT_AsnEncodeBitsSwapBytes(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret;
__TRY { const CRYPT_BIT_BLOB *blob = pvStructInfo; CRYPT_BIT_BLOB newBlob = { blob->cbData, NULL, blob->cUnusedBits };
ret = TRUE; if (newBlob.cbData) { newBlob.pbData = CryptMemAlloc(newBlob.cbData); if (newBlob.pbData) { DWORD i;
for (i = 0; i < newBlob.cbData; i++) newBlob.pbData[newBlob.cbData - i - 1] = blob->pbData[i]; } else ret = FALSE; } if (ret) ret = CRYPT_AsnEncodeBits(dwCertEncodingType, lpszStructType, &newBlob, dwFlags, pEncodePara, pbEncoded, pcbEncoded); CryptMemFree(newBlob.pbData); } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); ret = FALSE; } __ENDTRY return ret;}
static BOOL WINAPI CRYPT_AsnEncodeInt(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ CRYPT_INTEGER_BLOB blob = { sizeof(INT), (BYTE *)pvStructInfo };
return CRYPT_AsnEncodeInteger(dwCertEncodingType, X509_MULTI_BYTE_INTEGER, &blob, dwFlags, pEncodePara, pbEncoded, pcbEncoded);}
static BOOL WINAPI CRYPT_AsnEncodeInteger(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret;
__TRY { DWORD significantBytes, lenBytes, bytesNeeded; BYTE padByte = 0; BOOL pad = FALSE; const CRYPT_INTEGER_BLOB *blob = pvStructInfo;
significantBytes = blob->cbData; if (significantBytes) { if (blob->pbData[significantBytes - 1] & 0x80) { /* negative, lop off leading (little-endian) 0xffs */ for (; significantBytes > 0 && blob->pbData[significantBytes - 1] == 0xff; significantBytes--) ; if (blob->pbData[significantBytes - 1] < 0x80) { padByte = 0xff; pad = TRUE; } } else { /* positive, lop off leading (little-endian) zeroes */ for (; significantBytes > 0 && !blob->pbData[significantBytes - 1]; significantBytes--) ; if (significantBytes == 0) significantBytes = 1; if (blob->pbData[significantBytes - 1] > 0x7f) { padByte = 0; pad = TRUE; } } } if (pad) CRYPT_EncodeLen(significantBytes + 1, NULL, &lenBytes); else CRYPT_EncodeLen(significantBytes, NULL, &lenBytes); bytesNeeded = 1 + lenBytes + significantBytes; if (pad) bytesNeeded++; if (!pbEncoded) { *pcbEncoded = bytesNeeded; ret = TRUE; } else { if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded, pcbEncoded, bytesNeeded))) { if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) pbEncoded = *(BYTE **)pbEncoded; *pbEncoded++ = ASN_INTEGER; if (pad) { CRYPT_EncodeLen(significantBytes + 1, pbEncoded, &lenBytes); pbEncoded += lenBytes; *pbEncoded++ = padByte; } else { CRYPT_EncodeLen(significantBytes, pbEncoded, &lenBytes); pbEncoded += lenBytes; } for (; significantBytes > 0; significantBytes--) *(pbEncoded++) = blob->pbData[significantBytes - 1]; } } } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); ret = FALSE; } __ENDTRY return ret;}
static BOOL WINAPI CRYPT_AsnEncodeUnsignedInteger(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret;
__TRY { DWORD significantBytes, lenBytes, bytesNeeded; BOOL pad = FALSE; const CRYPT_INTEGER_BLOB *blob = pvStructInfo;
significantBytes = blob->cbData; if (significantBytes) { /* positive, lop off leading (little-endian) zeroes */ for (; significantBytes > 0 && !blob->pbData[significantBytes - 1]; significantBytes--) ; if (significantBytes == 0) significantBytes = 1; if (blob->pbData[significantBytes - 1] > 0x7f) pad = TRUE; } if (pad) CRYPT_EncodeLen(significantBytes + 1, NULL, &lenBytes); else CRYPT_EncodeLen(significantBytes, NULL, &lenBytes); bytesNeeded = 1 + lenBytes + significantBytes; if (pad) bytesNeeded++; if (!pbEncoded) { *pcbEncoded = bytesNeeded; ret = TRUE; } else { if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded, pcbEncoded, bytesNeeded))) { if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) pbEncoded = *(BYTE **)pbEncoded; *pbEncoded++ = ASN_INTEGER; if (pad) { CRYPT_EncodeLen(significantBytes + 1, pbEncoded, &lenBytes); pbEncoded += lenBytes; *pbEncoded++ = 0; } else { CRYPT_EncodeLen(significantBytes, pbEncoded, &lenBytes); pbEncoded += lenBytes; } for (; significantBytes > 0; significantBytes--) *(pbEncoded++) = blob->pbData[significantBytes - 1]; } } } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); ret = FALSE; } __ENDTRY return ret;}
static BOOL WINAPI CRYPT_AsnEncodeEnumerated(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ CRYPT_INTEGER_BLOB blob; BOOL ret;
/* Encode as an unsigned integer, then change the tag to enumerated */ blob.cbData = sizeof(DWORD); blob.pbData = (BYTE *)pvStructInfo; ret = CRYPT_AsnEncodeUnsignedInteger(dwCertEncodingType, X509_MULTI_BYTE_UINT, &blob, dwFlags, pEncodePara, pbEncoded, pcbEncoded); if (ret && pbEncoded) { if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) pbEncoded = *(BYTE **)pbEncoded; pbEncoded[0] = ASN_ENUMERATED; } return ret;}
static BOOL WINAPI CRYPT_AsnEncodeUtcTime(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret;
__TRY { SYSTEMTIME sysTime; /* sorry, magic number: enough for tag, len, YYMMDDHHMMSSZ. I use a * temporary buffer because the output buffer is not NULL-terminated. */ static const DWORD bytesNeeded = 15; char buf[40];
if (!pbEncoded) { *pcbEncoded = bytesNeeded; ret = TRUE; } else { /* Sanity check the year, this is a two-digit year format */ ret = FileTimeToSystemTime(pvStructInfo, &sysTime); if (ret && (sysTime.wYear < 1950 || sysTime.wYear > 2050)) { SetLastError(CRYPT_E_BAD_ENCODE); ret = FALSE; } if (ret) { if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded, pcbEncoded, bytesNeeded))) { if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) pbEncoded = *(BYTE **)pbEncoded; buf[0] = ASN_UTCTIME; buf[1] = bytesNeeded - 2; snprintf(buf + 2, sizeof(buf) - 2, "%02d%02d%02d%02d%02d%02dZ", sysTime.wYear >= 2000 ? sysTime.wYear - 2000 : sysTime.wYear - 1900, sysTime.wMonth, sysTime.wDay, sysTime.wHour, sysTime.wMinute, sysTime.wSecond); memcpy(pbEncoded, buf, bytesNeeded); } } } } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); ret = FALSE; } __ENDTRY return ret;}
static BOOL CRYPT_AsnEncodeGeneralizedTime(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret;
__TRY { SYSTEMTIME sysTime; /* sorry, magic number: enough for tag, len, YYYYMMDDHHMMSSZ. I use a * temporary buffer because the output buffer is not NULL-terminated. */ static const DWORD bytesNeeded = 17; char buf[40];
if (!pbEncoded) { *pcbEncoded = bytesNeeded; ret = TRUE; } else { ret = FileTimeToSystemTime(pvStructInfo, &sysTime); if (ret) ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded, pcbEncoded, bytesNeeded); if (ret) { if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) pbEncoded = *(BYTE **)pbEncoded; buf[0] = ASN_GENERALTIME; buf[1] = bytesNeeded - 2; snprintf(buf + 2, sizeof(buf) - 2, "%04d%02d%02d%02d%02d%02dZ", sysTime.wYear, sysTime.wMonth, sysTime.wDay, sysTime.wHour, sysTime.wMinute, sysTime.wSecond); memcpy(pbEncoded, buf, bytesNeeded); } } } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); ret = FALSE; } __ENDTRY return ret;}
static BOOL WINAPI CRYPT_AsnEncodeChoiceOfTime(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret;
__TRY { SYSTEMTIME sysTime;
/* Check the year, if it's in the UTCTime range call that encode func */ if (!FileTimeToSystemTime(pvStructInfo, &sysTime)) return FALSE; if (sysTime.wYear >= 1950 && sysTime.wYear <= 2050) ret = CRYPT_AsnEncodeUtcTime(dwCertEncodingType, lpszStructType, pvStructInfo, dwFlags, pEncodePara, pbEncoded, pcbEncoded); else ret = CRYPT_AsnEncodeGeneralizedTime(dwCertEncodingType, lpszStructType, pvStructInfo, dwFlags, pEncodePara, pbEncoded, pcbEncoded); } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); ret = FALSE; } __ENDTRY return ret;}
static BOOL WINAPI CRYPT_AsnEncodeSequenceOfAny(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret;
__TRY { DWORD bytesNeeded, dataLen, lenBytes, i; const CRYPT_SEQUENCE_OF_ANY *seq = pvStructInfo;
for (i = 0, dataLen = 0; i < seq->cValue; i++) dataLen += seq->rgValue[i].cbData; CRYPT_EncodeLen(dataLen, NULL, &lenBytes); bytesNeeded = 1 + lenBytes + dataLen; if (!pbEncoded) { *pcbEncoded = bytesNeeded; ret = TRUE; } else { if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded, pcbEncoded, bytesNeeded))) { if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) pbEncoded = *(BYTE **)pbEncoded; *pbEncoded++ = ASN_SEQUENCEOF; CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes); pbEncoded += lenBytes; for (i = 0; i < seq->cValue; i++) { memcpy(pbEncoded, seq->rgValue[i].pbData, seq->rgValue[i].cbData); pbEncoded += seq->rgValue[i].cbData; } } } } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); ret = FALSE; } __ENDTRY return ret;}
static BOOL CRYPT_AsnEncodeDistPoint(const CRL_DIST_POINT *distPoint, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret = TRUE; struct AsnEncodeSequenceItem items[3] = { { 0 } }; struct AsnConstructedItem constructed = { 0 }; struct AsnEncodeTagSwappedItem swapped[3] = { { 0 } }; DWORD cItem = 0, cSwapped = 0;
switch (distPoint->DistPointName.dwDistPointNameChoice) { case CRL_DIST_POINT_NO_NAME: /* do nothing */ break; case CRL_DIST_POINT_FULL_NAME: swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 0; swapped[cSwapped].pvStructInfo = &distPoint->DistPointName.u.FullName; swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeAltName; constructed.tag = 0; constructed.pvStructInfo = &swapped[cSwapped]; constructed.encodeFunc = CRYPT_AsnEncodeSwapTag; items[cItem].pvStructInfo = &constructed; items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed; cSwapped++; cItem++; break; case CRL_DIST_POINT_ISSUER_RDN_NAME: FIXME("unimplemented for CRL_DIST_POINT_ISSUER_RDN_NAME\n"); ret = FALSE; break; default: ret = FALSE; } if (ret && distPoint->ReasonFlags.cbData) { swapped[cSwapped].tag = ASN_CONTEXT | 1; swapped[cSwapped].pvStructInfo = &distPoint->ReasonFlags; swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeBits; items[cItem].pvStructInfo = &swapped[cSwapped]; items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag; cSwapped++; cItem++; } if (ret && distPoint->CRLIssuer.cAltEntry) { swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 2; swapped[cSwapped].pvStructInfo = &distPoint->CRLIssuer; swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeAltName; items[cItem].pvStructInfo = &swapped[cSwapped]; items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag; cSwapped++; cItem++; } if (ret) ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, cItem, 0, NULL, pbEncoded, pcbEncoded); return ret;}
static BOOL WINAPI CRYPT_AsnEncodeCRLDistPoints(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret;
__TRY { const CRL_DIST_POINTS_INFO *info = pvStructInfo;
if (!info->cDistPoint) { SetLastError(E_INVALIDARG); ret = FALSE; } else { DWORD bytesNeeded, dataLen, lenBytes, i;
ret = TRUE; for (i = 0, dataLen = 0; ret && i < info->cDistPoint; i++) { DWORD len;
ret = CRYPT_AsnEncodeDistPoint(&info->rgDistPoint[i], NULL, &len); if (ret) dataLen += len; else if (GetLastError() == CRYPT_E_INVALID_IA5_STRING) { /* Have to propagate index of failing character */ *pcbEncoded = len; } } if (ret) { CRYPT_EncodeLen(dataLen, NULL, &lenBytes); bytesNeeded = 1 + lenBytes + dataLen; if (!pbEncoded) { *pcbEncoded = bytesNeeded; ret = TRUE; } else { if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded, pcbEncoded, bytesNeeded))) { BYTE *out;
if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) pbEncoded = *(BYTE **)pbEncoded; out = pbEncoded; *out++ = ASN_SEQUENCEOF; CRYPT_EncodeLen(dataLen, out, &lenBytes); out += lenBytes; for (i = 0; ret && i < info->cDistPoint; i++) { DWORD len = dataLen;
ret = CRYPT_AsnEncodeDistPoint( &info->rgDistPoint[i], out, &len); if (ret) { out += len; dataLen -= len; } } if (!ret && (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)) CRYPT_FreeSpace(pEncodePara, pbEncoded); } } } } } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); ret = FALSE; } __ENDTRY return ret;}
static BOOL WINAPI CRYPT_AsnEncodeEnhancedKeyUsage(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret;
__TRY { const CERT_ENHKEY_USAGE *usage = pvStructInfo; DWORD bytesNeeded = 0, lenBytes, size, i;
ret = TRUE; for (i = 0; ret && i < usage->cUsageIdentifier; i++) { ret = CRYPT_AsnEncodeOid(dwCertEncodingType, NULL, usage->rgpszUsageIdentifier[i], dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, NULL, &size); if (ret) bytesNeeded += size; } CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes); bytesNeeded += 1 + lenBytes; if (ret) { if (!pbEncoded) *pcbEncoded = bytesNeeded; else { if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded, pcbEncoded, bytesNeeded))) { BYTE *out;
if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) pbEncoded = *(BYTE **)pbEncoded; out = pbEncoded; *out++ = ASN_SEQUENCEOF; CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, out, &lenBytes); out += lenBytes; for (i = 0; ret && i < usage->cUsageIdentifier; i++) { size = bytesNeeded; ret = CRYPT_AsnEncodeOid(dwCertEncodingType, NULL, usage->rgpszUsageIdentifier[i], dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, out, &size); if (ret) { out += size; bytesNeeded -= size; } } if (!ret && (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)) CRYPT_FreeSpace(pEncodePara, pbEncoded); } } } } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); ret = FALSE; } __ENDTRY return ret;}
static BOOL WINAPI CRYPT_AsnEncodeIssuingDistPoint(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret;
__TRY { const CRL_ISSUING_DIST_POINT *point = pvStructInfo; struct AsnEncodeSequenceItem items[6] = { { 0 } }; struct AsnConstructedItem constructed = { 0 }; struct AsnEncodeTagSwappedItem swapped[5] = { { 0 } }; DWORD cItem = 0, cSwapped = 0;
ret = TRUE; switch (point->DistPointName.dwDistPointNameChoice) { case CRL_DIST_POINT_NO_NAME: /* do nothing */ break; case CRL_DIST_POINT_FULL_NAME: swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 0; swapped[cSwapped].pvStructInfo = &point->DistPointName.u.FullName; swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeAltName; constructed.tag = 0; constructed.pvStructInfo = &swapped[cSwapped]; constructed.encodeFunc = CRYPT_AsnEncodeSwapTag; items[cItem].pvStructInfo = &constructed; items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed; cSwapped++; cItem++; break; default: SetLastError(E_INVALIDARG); ret = FALSE; } if (ret && point->fOnlyContainsUserCerts) { swapped[cSwapped].tag = ASN_CONTEXT | 1; swapped[cSwapped].pvStructInfo = &point->fOnlyContainsUserCerts; swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeBool; items[cItem].pvStructInfo = &swapped[cSwapped]; items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag; cSwapped++; cItem++; } if (ret && point->fOnlyContainsCACerts) { swapped[cSwapped].tag = ASN_CONTEXT | 2; swapped[cSwapped].pvStructInfo = &point->fOnlyContainsCACerts; swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeBool; items[cItem].pvStructInfo = &swapped[cSwapped]; items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag; cSwapped++; cItem++; } if (ret && point->OnlySomeReasonFlags.cbData) { swapped[cSwapped].tag = ASN_CONTEXT | 3; swapped[cSwapped].pvStructInfo = &point->OnlySomeReasonFlags; swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeBits; items[cItem].pvStructInfo = &swapped[cSwapped]; items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag; cSwapped++; cItem++; } if (ret && point->fIndirectCRL) { swapped[cSwapped].tag = ASN_CONTEXT | 4; swapped[cSwapped].pvStructInfo = &point->fIndirectCRL; swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeBool; items[cItem].pvStructInfo = &swapped[cSwapped]; items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag; cSwapped++; cItem++; } if (ret) ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem, dwFlags, pEncodePara, pbEncoded, pcbEncoded); } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); ret = FALSE; } __ENDTRY return ret;}
static BOOL CRYPT_AsnEncodeGeneralSubtree(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret; const CERT_GENERAL_SUBTREE *subtree = pvStructInfo; struct AsnEncodeSequenceItem items[3] = { { &subtree->Base, CRYPT_AsnEncodeAltNameEntry, 0 }, { 0 } }; struct AsnEncodeTagSwappedItem swapped[2] = { { 0 } }; DWORD cItem = 1, cSwapped = 0;
if (subtree->dwMinimum) { swapped[cSwapped].tag = ASN_CONTEXT | 0; swapped[cSwapped].pvStructInfo = &subtree->dwMinimum; swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeInt; items[cItem].pvStructInfo = &swapped[cSwapped]; items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag; cSwapped++; cItem++; } if (subtree->fMaximum) { swapped[cSwapped].tag = ASN_CONTEXT | 1; swapped[cSwapped].pvStructInfo = &subtree->dwMaximum; swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeInt; items[cItem].pvStructInfo = &swapped[cSwapped]; items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag; cSwapped++; cItem++; } ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem, dwFlags, pEncodePara, pbEncoded, pcbEncoded); return ret;}
static BOOL WINAPI CRYPT_AsnEncodeNameConstraints(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret = FALSE; CRYPT_BLOB_ARRAY permitted = { 0, NULL }, excluded = { 0, NULL };
TRACE("%p\n", pvStructInfo);
__TRY { const CERT_NAME_CONSTRAINTS_INFO *constraints = pvStructInfo; struct AsnEncodeSequenceItem items[2] = { { 0 } }; struct AsnEncodeTagSwappedItem swapped[2] = { { 0 } }; DWORD i, cItem = 0, cSwapped = 0;
ret = TRUE; if (constraints->cPermittedSubtree) { permitted.rgBlob = CryptMemAlloc( constraints->cPermittedSubtree * sizeof(CRYPT_DER_BLOB)); if (permitted.rgBlob) { permitted.cBlob = constraints->cPermittedSubtree; memset(permitted.rgBlob, 0, permitted.cBlob * sizeof(CRYPT_DER_BLOB)); for (i = 0; ret && i < permitted.cBlob; i++) ret = CRYPT_AsnEncodeGeneralSubtree(dwCertEncodingType, NULL, &constraints->rgPermittedSubtree[i], CRYPT_ENCODE_ALLOC_FLAG, NULL, (BYTE *)&permitted.rgBlob[i].pbData, &permitted.rgBlob[i].cbData); if (ret) { swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 0; swapped[cSwapped].pvStructInfo = &permitted; swapped[cSwapped].encodeFunc = CRYPT_DEREncodeSet; items[cItem].pvStructInfo = &swapped[cSwapped]; items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag; cSwapped++; cItem++; } } else ret = FALSE; } if (constraints->cExcludedSubtree) { excluded.rgBlob = CryptMemAlloc( constraints->cExcludedSubtree * sizeof(CRYPT_DER_BLOB)); if (excluded.rgBlob) { excluded.cBlob = constraints->cExcludedSubtree; memset(excluded.rgBlob, 0, excluded.cBlob * sizeof(CRYPT_DER_BLOB)); for (i = 0; ret && i < excluded.cBlob; i++) ret = CRYPT_AsnEncodeGeneralSubtree(dwCertEncodingType, NULL, &constraints->rgExcludedSubtree[i], CRYPT_ENCODE_ALLOC_FLAG, NULL, (BYTE *)&excluded.rgBlob[i].pbData, &excluded.rgBlob[i].cbData); if (ret) { swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 1; swapped[cSwapped].pvStructInfo = &excluded; swapped[cSwapped].encodeFunc = CRYPT_DEREncodeSet; items[cItem].pvStructInfo = &swapped[cSwapped]; items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag; cSwapped++; cItem++; } } else ret = FALSE; } if (ret) ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem, dwFlags, pEncodePara, pbEncoded, pcbEncoded); for (i = 0; i < permitted.cBlob; i++) LocalFree(permitted.rgBlob[i].pbData); for (i = 0; i < excluded.cBlob; i++) LocalFree(excluded.rgBlob[i].pbData); } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); } __ENDTRY CryptMemFree(permitted.rgBlob); CryptMemFree(excluded.rgBlob); TRACE("returning %d\n", ret); return ret;}
static BOOL WINAPI CRYPT_AsnEncodeIssuerSerialNumber( DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret; const CERT_ISSUER_SERIAL_NUMBER *issuerSerial = pvStructInfo; struct AsnEncodeSequenceItem items[] = { { &issuerSerial->Issuer, CRYPT_CopyEncodedBlob, 0 }, { &issuerSerial->SerialNumber, CRYPT_AsnEncodeInteger, 0 }, };
ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, ARRAY_SIZE(items), dwFlags, pEncodePara, pbEncoded, pcbEncoded); return ret;}
static BOOL WINAPI CRYPT_AsnEncodePKCSSignerInfo(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret = FALSE;
if (!(dwCertEncodingType & PKCS_7_ASN_ENCODING)) { SetLastError(E_INVALIDARG); return FALSE; }
__TRY { const CMSG_SIGNER_INFO *info = pvStructInfo;
if (!info->Issuer.cbData) SetLastError(E_INVALIDARG); else { struct AsnEncodeSequenceItem items[7] = { { &info->dwVersion, CRYPT_AsnEncodeInt, 0 }, { &info->Issuer, CRYPT_AsnEncodeIssuerSerialNumber, 0 }, { &info->HashAlgorithm, CRYPT_AsnEncodeAlgorithmIdWithNullParams, 0 }, }; struct AsnEncodeTagSwappedItem swapped[2] = { { 0 } }; DWORD cItem = 3, cSwapped = 0;
if (info->AuthAttrs.cAttr) { swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 0; swapped[cSwapped].pvStructInfo = &info->AuthAttrs; swapped[cSwapped].encodeFunc = CRYPT_AsnEncodePKCSAttributes; items[cItem].pvStructInfo = &swapped[cSwapped]; items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag; cSwapped++; cItem++; } items[cItem].pvStructInfo = &info->HashEncryptionAlgorithm; items[cItem].encodeFunc = CRYPT_AsnEncodeAlgorithmIdWithNullParams; cItem++; items[cItem].pvStructInfo = &info->EncryptedHash; items[cItem].encodeFunc = CRYPT_AsnEncodeOctets; cItem++; if (info->UnauthAttrs.cAttr) { swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 1; swapped[cSwapped].pvStructInfo = &info->UnauthAttrs; swapped[cSwapped].encodeFunc = CRYPT_AsnEncodePKCSAttributes; items[cItem].pvStructInfo = &swapped[cSwapped]; items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag; cSwapped++; cItem++; } ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem, dwFlags, pEncodePara, pbEncoded, pcbEncoded); } } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); } __ENDTRY return ret;}
static BOOL WINAPI CRYPT_AsnEncodeCMSSignerInfo(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret = FALSE;
if (!(dwCertEncodingType & PKCS_7_ASN_ENCODING)) { SetLastError(E_INVALIDARG); return FALSE; }
__TRY { const CMSG_CMS_SIGNER_INFO *info = pvStructInfo;
if (info->SignerId.dwIdChoice != CERT_ID_ISSUER_SERIAL_NUMBER && info->SignerId.dwIdChoice != CERT_ID_KEY_IDENTIFIER) SetLastError(E_INVALIDARG); else if (info->SignerId.dwIdChoice == CERT_ID_ISSUER_SERIAL_NUMBER && !info->SignerId.u.IssuerSerialNumber.Issuer.cbData) SetLastError(E_INVALIDARG); else { struct AsnEncodeSequenceItem items[7] = { { &info->dwVersion, CRYPT_AsnEncodeInt, 0 }, }; struct AsnEncodeTagSwappedItem swapped[3] = { { 0 } }; DWORD cItem = 1, cSwapped = 0;
if (info->SignerId.dwIdChoice == CERT_ID_ISSUER_SERIAL_NUMBER) { items[cItem].pvStructInfo = &info->SignerId.u.IssuerSerialNumber.Issuer; items[cItem].encodeFunc = CRYPT_AsnEncodeIssuerSerialNumber; cItem++; } else { swapped[cSwapped].tag = ASN_CONTEXT | 0; swapped[cSwapped].pvStructInfo = &info->SignerId.u.KeyId; swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeOctets; items[cItem].pvStructInfo = &swapped[cSwapped]; items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag; cSwapped++; cItem++; } items[cItem].pvStructInfo = &info->HashAlgorithm; items[cItem].encodeFunc = CRYPT_AsnEncodeAlgorithmIdWithNullParams; cItem++; if (info->AuthAttrs.cAttr) { swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 0; swapped[cSwapped].pvStructInfo = &info->AuthAttrs; swapped[cSwapped].encodeFunc = CRYPT_AsnEncodePKCSAttributes; items[cItem].pvStructInfo = &swapped[cSwapped]; items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag; cSwapped++; cItem++; } items[cItem].pvStructInfo = &info->HashEncryptionAlgorithm; items[cItem].encodeFunc = CRYPT_AsnEncodeAlgorithmIdWithNullParams; cItem++; items[cItem].pvStructInfo = &info->EncryptedHash; items[cItem].encodeFunc = CRYPT_AsnEncodeOctets; cItem++; if (info->UnauthAttrs.cAttr) { swapped[cSwapped].tag = ASN_CONTEXT | ASN_CONSTRUCTOR | 1; swapped[cSwapped].pvStructInfo = &info->UnauthAttrs; swapped[cSwapped].encodeFunc = CRYPT_AsnEncodePKCSAttributes; items[cItem].pvStructInfo = &swapped[cSwapped]; items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag; cSwapped++; cItem++; } ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem, dwFlags, pEncodePara, pbEncoded, pcbEncoded); } } __EXCEPT_PAGE_FAULT { SetLastError(STATUS_ACCESS_VIOLATION); } __ENDTRY return ret;}
BOOL CRYPT_AsnEncodeCMSSignedInfo(CRYPT_SIGNED_INFO *signedInfo, void *pvData, DWORD *pcbData){ struct AsnEncodeSequenceItem items[7] = { { &signedInfo->version, CRYPT_AsnEncodeInt, 0 }, }; struct DERSetDescriptor digestAlgorithmsSet = { 0 }, certSet = { 0 }; struct DERSetDescriptor crlSet = { 0 }, signerSet = { 0 }; struct AsnEncodeTagSwappedItem swapped[2] = { { 0 } }; DWORD cItem = 1, cSwapped = 0; BOOL ret = TRUE;
if (signedInfo->cSignerInfo) { digestAlgorithmsSet.cItems = signedInfo->cSignerInfo; digestAlgorithmsSet.items = signedInfo->rgSignerInfo; digestAlgorithmsSet.itemSize = sizeof(CMSG_CMS_SIGNER_INFO); digestAlgorithmsSet.itemOffset = offsetof(CMSG_CMS_SIGNER_INFO, HashAlgorithm); digestAlgorithmsSet.encode = CRYPT_AsnEncodeAlgorithmIdWithNullParams; items[cItem].pvStructInfo = &digestAlgorithmsSet; items[cItem].encodeFunc = CRYPT_DEREncodeItemsAsSet; cItem++; } items[cItem].pvStructInfo = &signedInfo->content; items[cItem].encodeFunc = CRYPT_AsnEncodePKCSContentInfoInternal; cItem++; if (signedInfo->cCertEncoded) { certSet.cItems = signedInfo->cCertEncoded; certSet.items = signedInfo->rgCertEncoded; certSet.itemSize = sizeof(CERT_BLOB); certSet.itemOffset = 0; certSet.encode = CRYPT_CopyEncodedBlob; swapped[cSwapped].tag = ASN_CONSTRUCTOR | ASN_CONTEXT | 0; swapped[cSwapped].pvStructInfo = &certSet; swapped[cSwapped].encodeFunc = CRYPT_DEREncodeItemsAsSet; items[cItem].pvStructInfo = &swapped[cSwapped]; items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag; cSwapped++; cItem++; } if (signedInfo->cCrlEncoded) { crlSet.cItems = signedInfo->cCrlEncoded; crlSet.items = signedInfo->rgCrlEncoded; crlSet.itemSize = sizeof(CRL_BLOB); crlSet.itemOffset = 0; crlSet.encode = CRYPT_CopyEncodedBlob; swapped[cSwapped].tag = ASN_CONSTRUCTOR | ASN_CONTEXT | 1; swapped[cSwapped].pvStructInfo = &crlSet; swapped[cSwapped].encodeFunc = CRYPT_DEREncodeItemsAsSet; items[cItem].pvStructInfo = &swapped[cSwapped]; items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag; cSwapped++; cItem++; } if (ret && signedInfo->cSignerInfo) { signerSet.cItems = signedInfo->cSignerInfo; signerSet.items = signedInfo->rgSignerInfo; signerSet.itemSize = sizeof(CMSG_CMS_SIGNER_INFO); signerSet.itemOffset = 0; signerSet.encode = CRYPT_AsnEncodeCMSSignerInfo; items[cItem].pvStructInfo = &signerSet; items[cItem].encodeFunc = CRYPT_DEREncodeItemsAsSet; cItem++; } if (ret) ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, items, cItem, 0, NULL, pvData, pcbData);
return ret;}
static BOOL WINAPI CRYPT_AsnEncodeRecipientInfo(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ const CMSG_KEY_TRANS_RECIPIENT_INFO *info = pvStructInfo; struct AsnEncodeSequenceItem items[] = { { &info->dwVersion, CRYPT_AsnEncodeInt, 0 }, { &info->RecipientId.u.IssuerSerialNumber, CRYPT_AsnEncodeIssuerSerialNumber, 0 }, { &info->KeyEncryptionAlgorithm, CRYPT_AsnEncodeAlgorithmIdWithNullParams, 0 }, { &info->EncryptedKey, CRYPT_AsnEncodeOctets, 0 }, };
return CRYPT_AsnEncodeSequence(dwCertEncodingType, items, ARRAY_SIZE(items), dwFlags, pEncodePara, pbEncoded, pcbEncoded);}
static BOOL WINAPI CRYPT_AsnEncodeEncryptedContentInfo(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded){ const CRYPT_ENCRYPTED_CONTENT_INFO *info = pvStructInfo; struct AsnEncodeTagSwappedItem swapped = { ASN_CONTEXT | 0, &info->encryptedContent, CRYPT_AsnEncodeOctets }; struct AsnEncodeSequenceItem items[] = { { info->contentType, CRYPT_AsnEncodeOid, 0 }, { &info->contentEncryptionAlgorithm, CRYPT_AsnEncodeAlgorithmIdWithNullParams, 0 }, { &swapped, CRYPT_AsnEncodeSwapTag, 0 }, };
return CRYPT_AsnEncodeSequence(dwCertEncodingType, items, ARRAY_SIZE(items), dwFlags, pEncodePara, pbEncoded, pcbEncoded);}
BOOL CRYPT_AsnEncodePKCSEnvelopedData(const CRYPT_ENVELOPED_DATA *envelopedData, void *pvData, DWORD *pcbData){ struct DERSetDescriptor recipientInfosSet = { envelopedData->cRecipientInfo, envelopedData->rgRecipientInfo, sizeof(CMSG_KEY_TRANS_RECIPIENT_INFO), 0, CRYPT_AsnEncodeRecipientInfo }; struct AsnEncodeSequenceItem items[] = { { &envelopedData->version, CRYPT_AsnEncodeInt, 0 }, { &recipientInfosSet, CRYPT_DEREncodeItemsAsSet, 0 }, { &envelopedData->encryptedContentInfo, CRYPT_AsnEncodeEncryptedContentInfo, 0 }, };
return CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, ARRAY_SIZE(items), 0, NULL, pvData, pcbData);}
static CryptEncodeObjectExFunc CRYPT_GetBuiltinEncoder(DWORD dwCertEncodingType, LPCSTR lpszStructType){ CryptEncodeObjectExFunc encodeFunc = NULL;
if ((dwCertEncodingType & CERT_ENCODING_TYPE_MASK) != X509_ASN_ENCODING && (dwCertEncodingType & CMSG_ENCODING_TYPE_MASK) != PKCS_7_ASN_ENCODING) { SetLastError(ERROR_FILE_NOT_FOUND); return NULL; }
if (IS_INTOID(lpszStructType)) { switch (LOWORD(lpszStructType)) { case LOWORD(X509_CERT): encodeFunc = CRYPT_AsnEncodeCert; break; case LOWORD(X509_CERT_TO_BE_SIGNED): encodeFunc = CRYPT_AsnEncodeCertInfo; break; case LOWORD(X509_CERT_CRL_TO_BE_SIGNED): encodeFunc = CRYPT_AsnEncodeCRLInfo; break; case LOWORD(X509_EXTENSIONS): encodeFunc = CRYPT_AsnEncodeExtensions; break; case LOWORD(X509_NAME_VALUE): encodeFunc = CRYPT_AsnEncodeNameValue; break; case LOWORD(X509_NAME): encodeFunc = CRYPT_AsnEncodeName; break; case LOWORD(X509_PUBLIC_KEY_INFO): encodeFunc = CRYPT_AsnEncodePubKeyInfo; break; case LOWORD(X509_AUTHORITY_KEY_ID): encodeFunc = CRYPT_AsnEncodeAuthorityKeyId; break; case LOWORD(X509_ALTERNATE_NAME): encodeFunc = CRYPT_AsnEncodeAltName; break; case LOWORD(X509_BASIC_CONSTRAINTS): encodeFunc = CRYPT_AsnEncodeBasicConstraints; break; case LOWORD(X509_BASIC_CONSTRAINTS2): encodeFunc = CRYPT_AsnEncodeBasicConstraints2; break; case LOWORD(X509_CERT_POLICIES): encodeFunc = CRYPT_AsnEncodeCertPolicies; break; case LOWORD(RSA_CSP_PUBLICKEYBLOB): encodeFunc = CRYPT_AsnEncodeRsaPubKey; break; case LOWORD(X509_UNICODE_NAME): encodeFunc = CRYPT_AsnEncodeUnicodeName; break; case LOWORD(PKCS_CONTENT_INFO): encodeFunc = CRYPT_AsnEncodePKCSContentInfo; break; case LOWORD(PKCS_ATTRIBUTE): encodeFunc = CRYPT_AsnEncodePKCSAttribute; break; case LOWORD(X509_UNICODE_NAME_VALUE): encodeFunc = CRYPT_AsnEncodeUnicodeNameValue; break; case LOWORD(X509_OCTET_STRING): encodeFunc = CRYPT_AsnEncodeOctets; break; case LOWORD(X509_BITS): case LOWORD(X509_KEY_USAGE): encodeFunc = CRYPT_AsnEncodeBits; break; case LOWORD(X509_INTEGER): encodeFunc = CRYPT_AsnEncodeInt; break; case LOWORD(X509_MULTI_BYTE_INTEGER): encodeFunc = CRYPT_AsnEncodeInteger; break; case LOWORD(X509_MULTI_BYTE_UINT): encodeFunc = CRYPT_AsnEncodeUnsignedInteger; break; case LOWORD(X509_ENUMERATED): encodeFunc = CRYPT_AsnEncodeEnumerated; break; case LOWORD(X509_CHOICE_OF_TIME): encodeFunc = CRYPT_AsnEncodeChoiceOfTime; break; case LOWORD(X509_AUTHORITY_KEY_ID2): encodeFunc = CRYPT_AsnEncodeAuthorityKeyId2; break; case LOWORD(X509_AUTHORITY_INFO_ACCESS): encodeFunc = CRYPT_AsnEncodeAuthorityInfoAccess; break; case LOWORD(X509_SEQUENCE_OF_ANY): encodeFunc = CRYPT_AsnEncodeSequenceOfAny; break; case LOWORD(PKCS_UTC_TIME): encodeFunc = CRYPT_AsnEncodeUtcTime; break; case LOWORD(X509_CRL_DIST_POINTS): encodeFunc = CRYPT_AsnEncodeCRLDistPoints; break; case LOWORD(X509_ENHANCED_KEY_USAGE): encodeFunc = CRYPT_AsnEncodeEnhancedKeyUsage; break; case LOWORD(PKCS_CTL): encodeFunc = CRYPT_AsnEncodeCTL; break; case LOWORD(PKCS_SMIME_CAPABILITIES): encodeFunc = CRYPT_AsnEncodeSMIMECapabilities; break; case LOWORD(X509_PKIX_POLICY_QUALIFIER_USERNOTICE): encodeFunc = CRYPT_AsnEncodePolicyQualifierUserNotice; break; case LOWORD(PKCS_ATTRIBUTES): encodeFunc = CRYPT_AsnEncodePKCSAttributes; break; case LOWORD(X509_ISSUING_DIST_POINT): encodeFunc = CRYPT_AsnEncodeIssuingDistPoint; break; case LOWORD(X509_NAME_CONSTRAINTS): encodeFunc = CRYPT_AsnEncodeNameConstraints; break; case LOWORD(X509_POLICY_MAPPINGS): encodeFunc = CRYPT_AsnEncodeCertPolicyMappings; break; case LOWORD(X509_POLICY_CONSTRAINTS): encodeFunc = CRYPT_AsnEncodeCertPolicyConstraints; break; case LOWORD(PKCS7_SIGNER_INFO): encodeFunc = CRYPT_AsnEncodePKCSSignerInfo; break; case LOWORD(CMS_SIGNER_INFO): encodeFunc = CRYPT_AsnEncodeCMSSignerInfo; break; } } else if (!strcmp(lpszStructType, szOID_CERT_EXTENSIONS)) encodeFunc = CRYPT_AsnEncodeExtensions; else if (!strcmp(lpszStructType, szOID_RSA_signingTime)) encodeFunc = CRYPT_AsnEncodeUtcTime; else if (!strcmp(lpszStructType, szOID_RSA_SMIMECapabilities)) encodeFunc = CRYPT_AsnEncodeUtcTime; else if (!strcmp(lpszStructType, szOID_AUTHORITY_KEY_IDENTIFIER)) encodeFunc = CRYPT_AsnEncodeAuthorityKeyId; else if (!strcmp(lpszStructType, szOID_LEGACY_POLICY_MAPPINGS)) encodeFunc = CRYPT_AsnEncodeCertPolicyMappings; else if (!strcmp(lpszStructType, szOID_AUTHORITY_KEY_IDENTIFIER2)) encodeFunc = CRYPT_AsnEncodeAuthorityKeyId2; else if (!strcmp(lpszStructType, szOID_CRL_REASON_CODE)) encodeFunc = CRYPT_AsnEncodeEnumerated; else if (!strcmp(lpszStructType, szOID_KEY_USAGE)) encodeFunc = CRYPT_AsnEncodeBits; else if (!strcmp(lpszStructType, szOID_SUBJECT_KEY_IDENTIFIER)) encodeFunc = CRYPT_AsnEncodeOctets; else if (!strcmp(lpszStructType, szOID_BASIC_CONSTRAINTS)) encodeFunc = CRYPT_AsnEncodeBasicConstraints; else if (!strcmp(lpszStructType, szOID_BASIC_CONSTRAINTS2)) encodeFunc = CRYPT_AsnEncodeBasicConstraints2; else if (!strcmp(lpszStructType, szOID_ISSUER_ALT_NAME)) encodeFunc = CRYPT_AsnEncodeAltName; else if (!strcmp(lpszStructType, szOID_ISSUER_ALT_NAME2)) encodeFunc = CRYPT_AsnEncodeAltName; else if (!strcmp(lpszStructType, szOID_NEXT_UPDATE_LOCATION)) encodeFunc = CRYPT_AsnEncodeAltName; else if (!strcmp(lpszStructType, szOID_SUBJECT_ALT_NAME)) encodeFunc = CRYPT_AsnEncodeAltName; else if (!strcmp(lpszStructType, szOID_SUBJECT_ALT_NAME2)) encodeFunc = CRYPT_AsnEncodeAltName; else if (!strcmp(lpszStructType, szOID_CRL_DIST_POINTS)) encodeFunc = CRYPT_AsnEncodeCRLDistPoints; else if (!strcmp(lpszStructType, szOID_CERT_POLICIES)) encodeFunc = CRYPT_AsnEncodeCertPolicies; else if (!strcmp(lpszStructType, szOID_POLICY_MAPPINGS)) encodeFunc = CRYPT_AsnEncodeCertPolicyMappings; else if (!strcmp(lpszStructType, szOID_POLICY_CONSTRAINTS)) encodeFunc = CRYPT_AsnEncodeCertPolicyConstraints; else if (!strcmp(lpszStructType, szOID_ENHANCED_KEY_USAGE)) encodeFunc = CRYPT_AsnEncodeEnhancedKeyUsage; else if (!strcmp(lpszStructType, szOID_ISSUING_DIST_POINT)) encodeFunc = CRYPT_AsnEncodeIssuingDistPoint; else if (!strcmp(lpszStructType, szOID_NAME_CONSTRAINTS)) encodeFunc = CRYPT_AsnEncodeNameConstraints; else if (!strcmp(lpszStructType, szOID_AUTHORITY_INFO_ACCESS)) encodeFunc = CRYPT_AsnEncodeAuthorityInfoAccess; else if (!strcmp(lpszStructType, szOID_PKIX_POLICY_QUALIFIER_USERNOTICE)) encodeFunc = CRYPT_AsnEncodePolicyQualifierUserNotice; else if (!strcmp(lpszStructType, szOID_CTL)) encodeFunc = CRYPT_AsnEncodeCTL; return encodeFunc;}
static CryptEncodeObjectFunc CRYPT_LoadEncoderFunc(DWORD dwCertEncodingType, LPCSTR lpszStructType, HCRYPTOIDFUNCADDR *hFunc){ static HCRYPTOIDFUNCSET set = NULL; CryptEncodeObjectFunc encodeFunc = NULL;
if (!set) set = CryptInitOIDFunctionSet(CRYPT_OID_ENCODE_OBJECT_FUNC, 0); CryptGetOIDFunctionAddress(set, dwCertEncodingType, lpszStructType, 0, (void **)&encodeFunc, hFunc); return encodeFunc;}
static CryptEncodeObjectExFunc CRYPT_LoadEncoderExFunc(DWORD dwCertEncodingType, LPCSTR lpszStructType, HCRYPTOIDFUNCADDR *hFunc){ static HCRYPTOIDFUNCSET set = NULL; CryptEncodeObjectExFunc encodeFunc = NULL;
if (!set) set = CryptInitOIDFunctionSet(CRYPT_OID_ENCODE_OBJECT_EX_FUNC, 0); CryptGetOIDFunctionAddress(set, dwCertEncodingType, lpszStructType, 0, (void **)&encodeFunc, hFunc); return encodeFunc;}
BOOL WINAPI CryptEncodeObject(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded){ BOOL ret = FALSE; HCRYPTOIDFUNCADDR hFunc = NULL; CryptEncodeObjectFunc pCryptEncodeObject = NULL; CryptEncodeObjectExFunc pCryptEncodeObjectEx = NULL;
TRACE_(crypt)("(0x%08x, %s, %p, %p, %p)\n", dwCertEncodingType, debugstr_a(lpszStructType), pvStructInfo, pbEncoded, pcbEncoded);
if (!pbEncoded && !pcbEncoded) { SetLastError(ERROR_INVALID_PARAMETER); return FALSE; }
if (!(pCryptEncodeObjectEx = CRYPT_GetBuiltinEncoder(dwCertEncodingType, lpszStructType))) { TRACE_(crypt)("OID %s not found or unimplemented, looking for DLL\n", debugstr_a(lpszStructType)); pCryptEncodeObject = CRYPT_LoadEncoderFunc(dwCertEncodingType, lpszStructType, &hFunc); if (!pCryptEncodeObject) pCryptEncodeObjectEx = CRYPT_LoadEncoderExFunc(dwCertEncodingType, lpszStructType, &hFunc); } if (pCryptEncodeObject) ret = pCryptEncodeObject(dwCertEncodingType, lpszStructType, pvStructInfo, pbEncoded, pcbEncoded); else if (pCryptEncodeObjectEx) ret = pCryptEncodeObjectEx(dwCertEncodingType, lpszStructType, pvStructInfo, 0, NULL, pbEncoded, pcbEncoded); if (hFunc) CryptFreeOIDFunctionAddress(hFunc, 0); TRACE_(crypt)("returning %d\n", ret); return ret;}
BOOL WINAPI CryptEncodeObjectEx(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, void *pvEncoded, DWORD *pcbEncoded){ BOOL ret = FALSE; HCRYPTOIDFUNCADDR hFunc = NULL; CryptEncodeObjectExFunc encodeFunc = NULL;
TRACE_(crypt)("(0x%08x, %s, %p, 0x%08x, %p, %p, %p)\n", dwCertEncodingType, debugstr_a(lpszStructType), pvStructInfo, dwFlags, pEncodePara, pvEncoded, pcbEncoded);
if (!pvEncoded && !pcbEncoded) { SetLastError(ERROR_INVALID_PARAMETER); return FALSE; }
SetLastError(NOERROR); if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) { if (!pvEncoded) { SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } *(BYTE **)pvEncoded = NULL; } encodeFunc = CRYPT_GetBuiltinEncoder(dwCertEncodingType, lpszStructType); if (!encodeFunc) { TRACE_(crypt)("OID %s not found or unimplemented, looking for DLL\n", debugstr_a(lpszStructType)); encodeFunc = CRYPT_LoadEncoderExFunc(dwCertEncodingType, lpszStructType, &hFunc); } if (encodeFunc) ret = encodeFunc(dwCertEncodingType, lpszStructType, pvStructInfo, dwFlags, pEncodePara, pvEncoded, pcbEncoded); else { CryptEncodeObjectFunc pCryptEncodeObject = CRYPT_LoadEncoderFunc(dwCertEncodingType, lpszStructType, &hFunc);
if (pCryptEncodeObject) { if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG) { ret = pCryptEncodeObject(dwCertEncodingType, lpszStructType, pvStructInfo, NULL, pcbEncoded); if (ret && (ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pvEncoded, pcbEncoded, *pcbEncoded))) ret = pCryptEncodeObject(dwCertEncodingType, lpszStructType, pvStructInfo, *(BYTE **)pvEncoded, pcbEncoded); } else ret = pCryptEncodeObject(dwCertEncodingType, lpszStructType, pvStructInfo, pvEncoded, pcbEncoded); } } if (hFunc) CryptFreeOIDFunctionAddress(hFunc, 0); TRACE_(crypt)("returning %d\n", ret); return ret;}
BOOL WINAPI PFXExportCertStore(HCERTSTORE hStore, CRYPT_DATA_BLOB *pPFX, LPCWSTR szPassword, DWORD dwFlags){ return PFXExportCertStoreEx(hStore, pPFX, szPassword, NULL, dwFlags);}
BOOL WINAPI PFXExportCertStoreEx(HCERTSTORE hStore, CRYPT_DATA_BLOB *pPFX, LPCWSTR szPassword, void *pvReserved, DWORD dwFlags){ FIXME_(crypt)("(%p, %p, %p, %p, %08x): stub\n", hStore, pPFX, szPassword, pvReserved, dwFlags); return FALSE;}
BOOL WINAPI CryptExportPublicKeyInfo(HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptProv, DWORD dwKeySpec, DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo){ return CryptExportPublicKeyInfoEx(hCryptProv, dwKeySpec, dwCertEncodingType, NULL, 0, NULL, pInfo, pcbInfo);}
typedef BOOL (WINAPI *EncodePublicKeyAndParametersFunc)(DWORD dwCertEncodingType, LPSTR pszPublicKeyObjId, BYTE *pbPubKey, DWORD cbPubKey, DWORD dwFlags, void *pvAuxInfo, BYTE **ppPublicKey, DWORD *pcbPublicKey, BYTE **ppbParams, DWORD *pcbParams);
static BOOL WINAPI CRYPT_ExportPublicKeyInfoEx(HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptProv, DWORD dwKeySpec, DWORD dwCertEncodingType, LPSTR pszPublicKeyObjId, DWORD dwFlags, void *pvAuxInfo, PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo){ BOOL ret; HCRYPTKEY key; static CHAR rsa_oid[] = szOID_RSA_RSA;
TRACE_(crypt)("(%08lx, %d, %08x, %s, %08x, %p, %p, %d)\n", hCryptProv, dwKeySpec, dwCertEncodingType, debugstr_a(pszPublicKeyObjId), dwFlags, pvAuxInfo, pInfo, pInfo ? *pcbInfo : 0);
if ((ret = CryptGetUserKey(hCryptProv, dwKeySpec, &key))) { DWORD keySize = 0;
ret = CryptExportKey(key, 0, PUBLICKEYBLOB, 0, NULL, &keySize); if (ret) { PUBLICKEYSTRUC *pubKey = CryptMemAlloc(keySize);
if (pubKey) { ret = CryptExportKey(key, 0, PUBLICKEYBLOB, 0, (BYTE *)pubKey, &keySize); if (ret) { DWORD encodedLen;
if (!pszPublicKeyObjId) { static HCRYPTOIDFUNCSET set; EncodePublicKeyAndParametersFunc encodeFunc = NULL; HCRYPTOIDFUNCADDR hFunc = NULL;
pszPublicKeyObjId = (LPSTR)CertAlgIdToOID(pubKey->aiKeyAlg); TRACE("public key algid %#x (%s)\n", pubKey->aiKeyAlg, debugstr_a(pszPublicKeyObjId));
if (!set) /* FIXME: there is no a public macro */ set = CryptInitOIDFunctionSet("CryptDllEncodePublicKeyAndParameters", 0);
CryptGetOIDFunctionAddress(set, dwCertEncodingType, pszPublicKeyObjId, 0, (void **)&encodeFunc, &hFunc); if (encodeFunc) { BYTE *key_data = NULL; DWORD key_size = 0; BYTE *params = NULL; DWORD params_size = 0;
ret = encodeFunc(dwCertEncodingType, pszPublicKeyObjId, (BYTE *)pubKey, keySize, dwFlags, pvAuxInfo, &key_data, &key_size, ¶ms, ¶ms_size); if (ret) { DWORD oid_size = strlen(pszPublicKeyObjId) + 1; DWORD size_needed = sizeof(*pInfo) + oid_size + key_size + params_size;
if (!pInfo) *pcbInfo = size_needed; else if (*pcbInfo < size_needed) { *pcbInfo = size_needed; SetLastError(ERROR_MORE_DATA); ret = FALSE; } else { *pcbInfo = size_needed; pInfo->Algorithm.pszObjId = (char *)(pInfo + 1); lstrcpyA(pInfo->Algorithm.pszObjId, pszPublicKeyObjId); if (params) { pInfo->Algorithm.Parameters.cbData = params_size; pInfo->Algorithm.Parameters.pbData = (BYTE *)pInfo->Algorithm.pszObjId + oid_size; memcpy(pInfo->Algorithm.Parameters.pbData, params, params_size); } else { pInfo->Algorithm.Parameters.cbData = 0; pInfo->Algorithm.Parameters.pbData = NULL; } pInfo->PublicKey.pbData = (BYTE *)pInfo->Algorithm.pszObjId + oid_size + params_size; pInfo->PublicKey.cbData = key_size; memcpy(pInfo->PublicKey.pbData, key_data, key_size); pInfo->PublicKey.cUnusedBits = 0; }
CryptMemFree(key_data); CryptMemFree(params); }
CryptMemFree(pubKey); CryptFreeOIDFunctionAddress(hFunc, 0); return ret; }
/* fallback to RSA */ pszPublicKeyObjId = rsa_oid; }
encodedLen = 0; ret = CryptEncodeObject(dwCertEncodingType, RSA_CSP_PUBLICKEYBLOB, pubKey, NULL, &encodedLen); if (ret) { DWORD sizeNeeded = sizeof(CERT_PUBLIC_KEY_INFO) + strlen(pszPublicKeyObjId) + 1 + encodedLen;
if (!pInfo) *pcbInfo = sizeNeeded; else if (*pcbInfo < sizeNeeded) { SetLastError(ERROR_MORE_DATA); *pcbInfo = sizeNeeded; ret = FALSE; } else { *pcbInfo = sizeNeeded; pInfo->Algorithm.pszObjId = (char *)pInfo + sizeof(CERT_PUBLIC_KEY_INFO); lstrcpyA(pInfo->Algorithm.pszObjId, pszPublicKeyObjId); pInfo->Algorithm.Parameters.cbData = 0; pInfo->Algorithm.Parameters.pbData = NULL; pInfo->PublicKey.pbData = (BYTE *)pInfo->Algorithm.pszObjId + lstrlenA(pInfo->Algorithm.pszObjId) + 1; pInfo->PublicKey.cbData = encodedLen; pInfo->PublicKey.cUnusedBits = 0; ret = CryptEncodeObject(dwCertEncodingType, RSA_CSP_PUBLICKEYBLOB, pubKey, pInfo->PublicKey.pbData, &pInfo->PublicKey.cbData); } } } CryptMemFree(pubKey); } else ret = FALSE; } CryptDestroyKey(key); } return ret;}
typedef BOOL (WINAPI *ExportPublicKeyInfoExFunc)(HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptProv, DWORD dwKeySpec, DWORD dwCertEncodingType, LPSTR pszPublicKeyObjId, DWORD dwFlags, void *pvAuxInfo, PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo);
BOOL WINAPI CryptExportPublicKeyInfoEx(HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptProv, DWORD dwKeySpec, DWORD dwCertEncodingType, LPSTR pszPublicKeyObjId, DWORD dwFlags, void *pvAuxInfo, PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo){ static HCRYPTOIDFUNCSET set = NULL; BOOL ret; ExportPublicKeyInfoExFunc exportFunc = NULL; HCRYPTOIDFUNCADDR hFunc = NULL;
TRACE_(crypt)("(%08lx, %d, %08x, %s, %08x, %p, %p, %d)\n", hCryptProv, dwKeySpec, dwCertEncodingType, debugstr_a(pszPublicKeyObjId), dwFlags, pvAuxInfo, pInfo, pInfo ? *pcbInfo : 0);
if (!hCryptProv) { SetLastError(ERROR_INVALID_PARAMETER); return FALSE; }
if (pszPublicKeyObjId) { if (!set) set = CryptInitOIDFunctionSet(CRYPT_OID_EXPORT_PUBLIC_KEY_INFO_FUNC, 0); CryptGetOIDFunctionAddress(set, dwCertEncodingType, pszPublicKeyObjId, 0, (void **)&exportFunc, &hFunc); } if (!exportFunc) exportFunc = CRYPT_ExportPublicKeyInfoEx; ret = exportFunc(hCryptProv, dwKeySpec, dwCertEncodingType, pszPublicKeyObjId, dwFlags, pvAuxInfo, pInfo, pcbInfo); if (hFunc) CryptFreeOIDFunctionAddress(hFunc, 0); return ret;}
BOOL WINAPI CryptImportPublicKeyInfo(HCRYPTPROV hCryptProv, DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, HCRYPTKEY *phKey){ return CryptImportPublicKeyInfoEx(hCryptProv, dwCertEncodingType, pInfo, 0, 0, NULL, phKey);}
typedef BOOL (WINAPI *ConvertPublicKeyInfoFunc)(DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, ALG_ID aiKeyAlg, DWORD dwFlags, BYTE **ppbData, DWORD *dwDataLen);
static BOOL WINAPI CRYPT_ImportPublicKeyInfoEx(HCRYPTPROV hCryptProv, DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, ALG_ID aiKeyAlg, DWORD dwFlags, void *pvAuxInfo, HCRYPTKEY *phKey){ static HCRYPTOIDFUNCSET set = NULL; ConvertPublicKeyInfoFunc convertFunc = NULL; HCRYPTOIDFUNCADDR hFunc = NULL; BOOL ret; DWORD pubKeySize; LPBYTE pubKey;
TRACE_(crypt)("(%08lx, %08x, %p, %08x, %08x, %p, %p)\n", hCryptProv, dwCertEncodingType, pInfo, aiKeyAlg, dwFlags, pvAuxInfo, phKey);
if (!set) set = CryptInitOIDFunctionSet(CRYPT_OID_CONVERT_PUBLIC_KEY_INFO_FUNC, 0); CryptGetOIDFunctionAddress(set, dwCertEncodingType, pInfo->Algorithm.pszObjId, 0, (void **)&convertFunc, &hFunc); if (convertFunc) { pubKey = NULL; pubKeySize = 0; ret = convertFunc(dwCertEncodingType, pInfo, aiKeyAlg, dwFlags, &pubKey, &pubKeySize); if (ret) { ret = CryptImportKey(hCryptProv, pubKey, pubKeySize, 0, 0, phKey); CryptMemFree(pubKey); }
CryptFreeOIDFunctionAddress(hFunc, 0); return ret; }
ret = CryptDecodeObject(dwCertEncodingType, RSA_CSP_PUBLICKEYBLOB, pInfo->PublicKey.pbData, pInfo->PublicKey.cbData, 0, NULL, &pubKeySize); if (ret) { pubKey = CryptMemAlloc(pubKeySize);
if (pubKey) { ret = CryptDecodeObject(dwCertEncodingType, RSA_CSP_PUBLICKEYBLOB, pInfo->PublicKey.pbData, pInfo->PublicKey.cbData, 0, pubKey, &pubKeySize); if (ret) { if(aiKeyAlg) ((BLOBHEADER*)pubKey)->aiKeyAlg = aiKeyAlg; ret = CryptImportKey(hCryptProv, pubKey, pubKeySize, 0, 0, phKey); } CryptMemFree(pubKey); } else ret = FALSE; } return ret;}
typedef BOOL (WINAPI *ImportPublicKeyInfoExFunc)(HCRYPTPROV hCryptProv, DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, ALG_ID aiKeyAlg, DWORD dwFlags, void *pvAuxInfo, HCRYPTKEY *phKey);
BOOL WINAPI CryptImportPublicKeyInfoEx(HCRYPTPROV hCryptProv, DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, ALG_ID aiKeyAlg, DWORD dwFlags, void *pvAuxInfo, HCRYPTKEY *phKey){ static HCRYPTOIDFUNCSET set = NULL; BOOL ret; ImportPublicKeyInfoExFunc importFunc = NULL; HCRYPTOIDFUNCADDR hFunc = NULL;
TRACE_(crypt)("(%08lx, %08x, %p, %08x, %08x, %p, %p)\n", hCryptProv, dwCertEncodingType, pInfo, aiKeyAlg, dwFlags, pvAuxInfo, phKey);
if (!set) set = CryptInitOIDFunctionSet(CRYPT_OID_IMPORT_PUBLIC_KEY_INFO_FUNC, 0); CryptGetOIDFunctionAddress(set, dwCertEncodingType, pInfo->Algorithm.pszObjId, 0, (void **)&importFunc, &hFunc); if (!importFunc) importFunc = CRYPT_ImportPublicKeyInfoEx; ret = importFunc(hCryptProv, dwCertEncodingType, pInfo, aiKeyAlg, dwFlags, pvAuxInfo, phKey); if (hFunc) CryptFreeOIDFunctionAddress(hFunc, 0); return ret;}