ssl_client_socket_unittest.cc 224 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658365936603661366236633664366536663667366836693670367136723673367436753676367736783679368036813682368336843685368636873688368936903691369236933694369536963697369836993700370137023703370437053706370737083709371037113712371337143715371637173718371937203721372237233724372537263727372837293730373137323733373437353736373737383739374037413742374337443745374637473748374937503751375237533754375537563757375837593760376137623763376437653766376737683769377037713772377337743775377637773778377937803781378237833784378537863787378837893790379137923793379437953796379737983799380038013802380338043805380638073808380938103811381238133814381538163817381838193820382138223823382438253826382738283829383038313832383338343835383638373838383938403841384238433844384538463847384838493850385138523853385438553856385738583859386038613862386338643865386638673868386938703871387238733874387538763877387838793880388138823883388438853886388738883889389038913892389338943895389638973898389939003901390239033904390539063907390839093910391139123913391439153916391739183919392039213922392339243925392639273928392939303931393239333934393539363937393839393940394139423943394439453946394739483949395039513952395339543955395639573958395939603961396239633964396539663967396839693970397139723973397439753976397739783979398039813982398339843985398639873988398939903991399239933994399539963997399839994000400140024003400440054006400740084009401040114012401340144015401640174018401940204021402240234024402540264027402840294030403140324033403440354036403740384039404040414042404340444045404640474048404940504051405240534054405540564057405840594060406140624063406440654066406740684069407040714072407340744075407640774078407940804081408240834084408540864087408840894090409140924093409440954096409740984099410041014102410341044105410641074108410941104111411241134114411541164117411841194120412141224123412441254126412741284129413041314132413341344135413641374138413941404141414241434144414541464147414841494150415141524153415441554156415741584159416041614162416341644165416641674168416941704171417241734174417541764177417841794180418141824183418441854186418741884189419041914192419341944195419641974198419942004201420242034204420542064207420842094210421142124213421442154216421742184219422042214222422342244225422642274228422942304231423242334234423542364237423842394240424142424243424442454246424742484249425042514252425342544255425642574258425942604261426242634264426542664267426842694270427142724273427442754276427742784279428042814282428342844285428642874288428942904291429242934294429542964297429842994300430143024303430443054306430743084309431043114312431343144315431643174318431943204321432243234324432543264327432843294330433143324333433443354336433743384339434043414342434343444345434643474348434943504351435243534354435543564357435843594360436143624363436443654366436743684369437043714372437343744375437643774378437943804381438243834384438543864387438843894390439143924393439443954396439743984399440044014402440344044405440644074408440944104411441244134414441544164417441844194420442144224423442444254426442744284429443044314432443344344435443644374438443944404441444244434444444544464447444844494450445144524453445444554456445744584459446044614462446344644465446644674468446944704471447244734474447544764477447844794480448144824483448444854486448744884489449044914492449344944495449644974498449945004501450245034504450545064507450845094510451145124513451445154516451745184519452045214522452345244525452645274528452945304531453245334534453545364537453845394540454145424543454445454546454745484549455045514552455345544555455645574558455945604561456245634564456545664567456845694570457145724573457445754576457745784579458045814582458345844585458645874588458945904591459245934594459545964597459845994600460146024603460446054606460746084609461046114612461346144615461646174618461946204621462246234624462546264627462846294630463146324633463446354636463746384639464046414642464346444645464646474648464946504651465246534654465546564657465846594660466146624663466446654666466746684669467046714672467346744675467646774678467946804681468246834684468546864687468846894690469146924693469446954696469746984699470047014702470347044705470647074708470947104711471247134714471547164717471847194720472147224723472447254726472747284729473047314732473347344735473647374738473947404741474247434744474547464747474847494750475147524753475447554756475747584759476047614762476347644765476647674768476947704771477247734774477547764777477847794780478147824783478447854786478747884789479047914792479347944795479647974798479948004801480248034804480548064807480848094810481148124813481448154816481748184819482048214822482348244825482648274828482948304831483248334834483548364837483848394840484148424843484448454846484748484849485048514852485348544855485648574858485948604861486248634864486548664867486848694870487148724873487448754876487748784879488048814882488348844885488648874888488948904891489248934894489548964897489848994900490149024903490449054906490749084909491049114912491349144915491649174918491949204921492249234924492549264927492849294930493149324933493449354936493749384939494049414942494349444945494649474948494949504951495249534954495549564957495849594960496149624963496449654966496749684969497049714972497349744975497649774978497949804981498249834984498549864987498849894990499149924993499449954996499749984999500050015002500350045005500650075008500950105011501250135014501550165017501850195020502150225023502450255026502750285029503050315032503350345035503650375038503950405041504250435044504550465047504850495050505150525053505450555056505750585059506050615062506350645065506650675068506950705071507250735074507550765077507850795080508150825083508450855086508750885089509050915092509350945095509650975098509951005101510251035104510551065107510851095110511151125113511451155116511751185119512051215122512351245125512651275128512951305131513251335134513551365137513851395140514151425143514451455146514751485149515051515152515351545155515651575158515951605161516251635164516551665167516851695170517151725173517451755176517751785179518051815182518351845185518651875188518951905191519251935194519551965197519851995200520152025203520452055206520752085209521052115212521352145215521652175218521952205221522252235224522552265227522852295230523152325233523452355236523752385239524052415242524352445245524652475248524952505251525252535254525552565257525852595260526152625263526452655266526752685269527052715272527352745275527652775278527952805281528252835284528552865287528852895290529152925293529452955296529752985299530053015302530353045305530653075308530953105311531253135314531553165317531853195320532153225323532453255326532753285329533053315332533353345335533653375338533953405341534253435344534553465347534853495350535153525353535453555356535753585359536053615362536353645365536653675368536953705371537253735374537553765377537853795380538153825383538453855386538753885389539053915392539353945395539653975398539954005401540254035404540554065407540854095410541154125413541454155416541754185419542054215422542354245425542654275428542954305431543254335434543554365437543854395440544154425443544454455446544754485449545054515452545354545455545654575458545954605461546254635464546554665467546854695470547154725473547454755476547754785479548054815482548354845485548654875488548954905491549254935494549554965497549854995500550155025503550455055506550755085509551055115512551355145515551655175518551955205521552255235524552555265527552855295530553155325533553455355536553755385539554055415542554355445545554655475548554955505551555255535554555555565557555855595560556155625563556455655566556755685569557055715572557355745575557655775578557955805581558255835584558555865587558855895590559155925593559455955596559755985599560056015602560356045605560656075608560956105611561256135614561556165617561856195620562156225623562456255626562756285629563056315632563356345635563656375638563956405641564256435644564556465647564856495650565156525653565456555656565756585659566056615662566356645665566656675668566956705671567256735674567556765677567856795680568156825683568456855686568756885689569056915692569356945695569656975698569957005701570257035704570557065707570857095710571157125713571457155716571757185719572057215722572357245725572657275728572957305731573257335734573557365737573857395740574157425743574457455746574757485749575057515752575357545755575657575758575957605761576257635764576557665767576857695770577157725773577457755776577757785779578057815782578357845785578657875788578957905791579257935794579557965797579857995800580158025803580458055806580758085809581058115812581358145815581658175818581958205821582258235824
  1. // Copyright (c) 2012 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "net/socket/ssl_client_socket.h"
  5. #include <errno.h>
  6. #include <string.h>
  7. #include <algorithm>
  8. #include <memory>
  9. #include <tuple>
  10. #include <utility>
  11. #include "base/bind.h"
  12. #include "base/callback_helpers.h"
  13. #include "base/files/file_util.h"
  14. #include "base/location.h"
  15. #include "base/memory/raw_ptr.h"
  16. #include "base/memory/ref_counted.h"
  17. #include "base/run_loop.h"
  18. #include "base/strings/string_number_conversions.h"
  19. #include "base/strings/string_piece.h"
  20. #include "base/strings/stringprintf.h"
  21. #include "base/synchronization/lock.h"
  22. #include "base/task/single_thread_task_runner.h"
  23. #include "base/test/bind.h"
  24. #include "base/test/metrics/histogram_tester.h"
  25. #include "base/test/scoped_feature_list.h"
  26. #include "base/threading/thread_task_runner_handle.h"
  27. #include "base/time/time.h"
  28. #include "base/values.h"
  29. #include "build/build_config.h"
  30. #include "crypto/rsa_private_key.h"
  31. #include "net/base/address_list.h"
  32. #include "net/base/completion_once_callback.h"
  33. #include "net/base/features.h"
  34. #include "net/base/io_buffer.h"
  35. #include "net/base/ip_address.h"
  36. #include "net/base/ip_endpoint.h"
  37. #include "net/base/net_errors.h"
  38. #include "net/base/network_isolation_key.h"
  39. #include "net/base/schemeful_site.h"
  40. #include "net/base/test_completion_callback.h"
  41. #include "net/cert/asn1_util.h"
  42. #include "net/cert/cert_and_ct_verifier.h"
  43. #include "net/cert/ct_policy_enforcer.h"
  44. #include "net/cert/ct_policy_status.h"
  45. #include "net/cert/ct_verifier.h"
  46. #include "net/cert/do_nothing_ct_verifier.h"
  47. #include "net/cert/mock_cert_verifier.h"
  48. #include "net/cert/mock_client_cert_verifier.h"
  49. #include "net/cert/sct_auditing_delegate.h"
  50. #include "net/cert/signed_certificate_timestamp_and_status.h"
  51. #include "net/cert/test_root_certs.h"
  52. #include "net/cert/x509_util.h"
  53. #include "net/der/input.h"
  54. #include "net/der/parser.h"
  55. #include "net/der/tag.h"
  56. #include "net/dns/host_resolver.h"
  57. #include "net/http/transport_security_state.h"
  58. #include "net/http/transport_security_state_test_util.h"
  59. #include "net/log/net_log_event_type.h"
  60. #include "net/log/net_log_source.h"
  61. #include "net/log/test_net_log.h"
  62. #include "net/log/test_net_log_util.h"
  63. #include "net/socket/client_socket_factory.h"
  64. #include "net/socket/client_socket_handle.h"
  65. #include "net/socket/read_buffering_stream_socket.h"
  66. #include "net/socket/socket_test_util.h"
  67. #include "net/socket/ssl_server_socket.h"
  68. #include "net/socket/stream_socket.h"
  69. #include "net/socket/tcp_client_socket.h"
  70. #include "net/socket/tcp_server_socket.h"
  71. #include "net/ssl/ssl_cert_request_info.h"
  72. #include "net/ssl/ssl_client_session_cache.h"
  73. #include "net/ssl/ssl_config.h"
  74. #include "net/ssl/ssl_config_service.h"
  75. #include "net/ssl/ssl_connection_status_flags.h"
  76. #include "net/ssl/ssl_handshake_details.h"
  77. #include "net/ssl/ssl_info.h"
  78. #include "net/ssl/ssl_server_config.h"
  79. #include "net/ssl/test_ssl_config_service.h"
  80. #include "net/ssl/test_ssl_private_key.h"
  81. #include "net/test/cert_test_util.h"
  82. #include "net/test/embedded_test_server/embedded_test_server.h"
  83. #include "net/test/embedded_test_server/http_request.h"
  84. #include "net/test/embedded_test_server/http_response.h"
  85. #include "net/test/gtest_util.h"
  86. #include "net/test/key_util.h"
  87. #include "net/test/ssl_test_util.h"
  88. #include "net/test/test_data_directory.h"
  89. #include "net/test/test_with_task_environment.h"
  90. #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
  91. #include "testing/gmock/include/gmock/gmock.h"
  92. #include "testing/gtest/include/gtest/gtest.h"
  93. #include "testing/platform_test.h"
  94. #include "third_party/abseil-cpp/absl/types/optional.h"
  95. #include "third_party/boringssl/src/include/openssl/bio.h"
  96. #include "third_party/boringssl/src/include/openssl/evp.h"
  97. #include "third_party/boringssl/src/include/openssl/hpke.h"
  98. #include "third_party/boringssl/src/include/openssl/pem.h"
  99. #include "third_party/boringssl/src/include/openssl/ssl.h"
  100. #include "url/gurl.h"
  101. using net::test::IsError;
  102. using net::test::IsOk;
  103. using testing::_;
  104. using testing::Bool;
  105. using testing::Combine;
  106. using testing::Return;
  107. using testing::Values;
  108. using testing::ValuesIn;
  109. namespace net {
  110. class NetLogWithSource;
  111. namespace {
  112. // When passed to |MakeHashValueVector|, this will generate a key pin that is
  113. // sha256/AA...=, and hence will cause pin validation success with the TestSPKI
  114. // pin from transport_security_state_static.pins. ("A" is the 0th element of the
  115. // base-64 alphabet.)
  116. const uint8_t kGoodHashValueVectorInput = 0;
  117. // When passed to |MakeHashValueVector|, this will generate a key pin that is
  118. // not sha256/AA...=, and hence will cause pin validation failure with the
  119. // TestSPKI pin.
  120. const uint8_t kBadHashValueVectorInput = 3;
  121. // TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
  122. constexpr uint16_t kModernTLS12Cipher = 0xc02f;
  123. // TLS_RSA_WITH_AES_128_GCM_SHA256
  124. constexpr uint16_t kRSACipher = 0x009c;
  125. // TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA
  126. constexpr uint16_t kCBCCipher = 0xc013;
  127. // TLS_RSA_WITH_3DES_EDE_CBC_SHA
  128. constexpr uint16_t k3DESCipher = 0x000a;
  129. // Simulates synchronously receiving an error during Read() or Write()
  130. class SynchronousErrorStreamSocket : public WrappedStreamSocket {
  131. public:
  132. explicit SynchronousErrorStreamSocket(std::unique_ptr<StreamSocket> transport)
  133. : WrappedStreamSocket(std::move(transport)) {}
  134. SynchronousErrorStreamSocket(const SynchronousErrorStreamSocket&) = delete;
  135. SynchronousErrorStreamSocket& operator=(const SynchronousErrorStreamSocket&) =
  136. delete;
  137. ~SynchronousErrorStreamSocket() override = default;
  138. // Socket implementation:
  139. int Read(IOBuffer* buf,
  140. int buf_len,
  141. CompletionOnceCallback callback) override;
  142. int ReadIfReady(IOBuffer* buf,
  143. int buf_len,
  144. CompletionOnceCallback callback) override;
  145. int Write(IOBuffer* buf,
  146. int buf_len,
  147. CompletionOnceCallback callback,
  148. const NetworkTrafficAnnotationTag& traffic_annotation) override;
  149. // Sets the next Read() call and all future calls to return |error|.
  150. // If there is already a pending asynchronous read, the configured error
  151. // will not be returned until that asynchronous read has completed and Read()
  152. // is called again.
  153. void SetNextReadError(int error) {
  154. DCHECK_GE(0, error);
  155. have_read_error_ = true;
  156. pending_read_error_ = error;
  157. }
  158. // Sets the next Write() call and all future calls to return |error|.
  159. // If there is already a pending asynchronous write, the configured error
  160. // will not be returned until that asynchronous write has completed and
  161. // Write() is called again.
  162. void SetNextWriteError(int error) {
  163. DCHECK_GE(0, error);
  164. have_write_error_ = true;
  165. pending_write_error_ = error;
  166. }
  167. private:
  168. bool have_read_error_ = false;
  169. int pending_read_error_ = OK;
  170. bool have_write_error_ = false;
  171. int pending_write_error_ = OK;
  172. };
  173. int SynchronousErrorStreamSocket::Read(IOBuffer* buf,
  174. int buf_len,
  175. CompletionOnceCallback callback) {
  176. if (have_read_error_)
  177. return pending_read_error_;
  178. return transport_->Read(buf, buf_len, std::move(callback));
  179. }
  180. int SynchronousErrorStreamSocket::ReadIfReady(IOBuffer* buf,
  181. int buf_len,
  182. CompletionOnceCallback callback) {
  183. if (have_read_error_)
  184. return pending_read_error_;
  185. return transport_->ReadIfReady(buf, buf_len, std::move(callback));
  186. }
  187. int SynchronousErrorStreamSocket::Write(
  188. IOBuffer* buf,
  189. int buf_len,
  190. CompletionOnceCallback callback,
  191. const NetworkTrafficAnnotationTag& traffic_annotation) {
  192. if (have_write_error_)
  193. return pending_write_error_;
  194. return transport_->Write(buf, buf_len, std::move(callback),
  195. traffic_annotation);
  196. }
  197. // FakeBlockingStreamSocket wraps an existing StreamSocket and simulates the
  198. // underlying transport needing to complete things asynchronously in a
  199. // deterministic manner (e.g.: independent of the TestServer and the OS's
  200. // semantics).
  201. class FakeBlockingStreamSocket : public WrappedStreamSocket {
  202. public:
  203. explicit FakeBlockingStreamSocket(std::unique_ptr<StreamSocket> transport)
  204. : WrappedStreamSocket(std::move(transport)) {}
  205. ~FakeBlockingStreamSocket() override = default;
  206. // Socket implementation:
  207. int Read(IOBuffer* buf,
  208. int buf_len,
  209. CompletionOnceCallback callback) override;
  210. int ReadIfReady(IOBuffer* buf,
  211. int buf_len,
  212. CompletionOnceCallback callback) override;
  213. int CancelReadIfReady() override;
  214. int Write(IOBuffer* buf,
  215. int buf_len,
  216. CompletionOnceCallback callback,
  217. const NetworkTrafficAnnotationTag& traffic_annotation) override;
  218. int pending_read_result() const { return pending_read_result_; }
  219. IOBuffer* pending_read_buf() const { return pending_read_buf_.get(); }
  220. // Blocks read results on the socket. Reads will not complete until
  221. // UnblockReadResult() has been called and a result is ready from the
  222. // underlying transport. Note: if BlockReadResult() is called while there is a
  223. // hanging asynchronous Read(), that Read is blocked.
  224. void BlockReadResult();
  225. void UnblockReadResult();
  226. // Replaces the pending read with |data|. Returns true on success or false if
  227. // the caller's reads were too small.
  228. bool ReplaceReadResult(const std::string& data);
  229. // Waits for the blocked Read() call to be complete at the underlying
  230. // transport.
  231. void WaitForReadResult();
  232. // Causes the next call to Write() to return ERR_IO_PENDING, not beginning the
  233. // underlying transport until UnblockWrite() has been called. Note: if there
  234. // is a pending asynchronous write, it is NOT blocked. For purposes of
  235. // blocking writes, data is considered to have reached the underlying
  236. // transport as soon as Write() is called.
  237. void BlockWrite();
  238. void UnblockWrite();
  239. // Waits for the blocked Write() call to be scheduled.
  240. void WaitForWrite();
  241. private:
  242. // Handles completion from the underlying transport read.
  243. void OnReadCompleted(int result);
  244. // Handles async completion of ReadIfReady().
  245. void CompleteReadIfReady(scoped_refptr<IOBuffer> buffer, int rv);
  246. // Finishes the current read.
  247. void ReturnReadResult();
  248. // Callback for writes.
  249. void CallPendingWriteCallback(int result);
  250. // True if read callbacks are blocked.
  251. bool should_block_read_ = false;
  252. // Used to buffer result returned by a completed ReadIfReady().
  253. std::string read_if_ready_buf_;
  254. // Non-null if there is a pending ReadIfReady().
  255. CompletionOnceCallback read_if_ready_callback_;
  256. // The buffer for the pending read, or NULL if not consumed.
  257. scoped_refptr<IOBuffer> pending_read_buf_;
  258. // The size of the pending read buffer, or -1 if not set.
  259. int pending_read_buf_len_ = -1;
  260. // The user callback for the pending read call.
  261. CompletionOnceCallback pending_read_callback_;
  262. // The result for the blocked read callback, or ERR_IO_PENDING if not
  263. // completed.
  264. int pending_read_result_ = ERR_IO_PENDING;
  265. // WaitForReadResult() wait loop.
  266. std::unique_ptr<base::RunLoop> read_loop_;
  267. // True if write calls are blocked.
  268. bool should_block_write_ = false;
  269. // The buffer for the pending write, or NULL if not scheduled.
  270. scoped_refptr<IOBuffer> pending_write_buf_;
  271. // The callback for the pending write call.
  272. CompletionOnceCallback pending_write_callback_;
  273. // The length for the pending write, or -1 if not scheduled.
  274. int pending_write_len_ = -1;
  275. // WaitForWrite() wait loop.
  276. std::unique_ptr<base::RunLoop> write_loop_;
  277. };
  278. int FakeBlockingStreamSocket::Read(IOBuffer* buf,
  279. int len,
  280. CompletionOnceCallback callback) {
  281. DCHECK(!pending_read_buf_);
  282. DCHECK(pending_read_callback_.is_null());
  283. DCHECK_EQ(ERR_IO_PENDING, pending_read_result_);
  284. DCHECK(!callback.is_null());
  285. int rv = transport_->Read(
  286. buf, len,
  287. base::BindOnce(&FakeBlockingStreamSocket::OnReadCompleted,
  288. base::Unretained(this)));
  289. if (rv == ERR_IO_PENDING || should_block_read_) {
  290. // Save the callback to be called later.
  291. pending_read_buf_ = buf;
  292. pending_read_buf_len_ = len;
  293. pending_read_callback_ = std::move(callback);
  294. // Save the read result.
  295. if (rv != ERR_IO_PENDING) {
  296. OnReadCompleted(rv);
  297. rv = ERR_IO_PENDING;
  298. }
  299. }
  300. return rv;
  301. }
  302. int FakeBlockingStreamSocket::ReadIfReady(IOBuffer* buf,
  303. int len,
  304. CompletionOnceCallback callback) {
  305. if (!read_if_ready_buf_.empty()) {
  306. // If ReadIfReady() is used, asynchronous reads with a large enough buffer
  307. // and no BlockReadResult() are supported by this class. Explicitly check
  308. // that |should_block_read_| doesn't apply and |len| is greater than the
  309. // size of the buffered data.
  310. CHECK(!should_block_read_);
  311. CHECK_GE(len, static_cast<int>(read_if_ready_buf_.size()));
  312. int rv = read_if_ready_buf_.size();
  313. memcpy(buf->data(), read_if_ready_buf_.data(), rv);
  314. read_if_ready_buf_.clear();
  315. return rv;
  316. }
  317. scoped_refptr<IOBuffer> buf_copy = base::MakeRefCounted<IOBuffer>(len);
  318. int rv = Read(buf_copy.get(), len,
  319. base::BindOnce(&FakeBlockingStreamSocket::CompleteReadIfReady,
  320. base::Unretained(this), buf_copy));
  321. if (rv > 0)
  322. memcpy(buf->data(), buf_copy->data(), rv);
  323. if (rv == ERR_IO_PENDING)
  324. read_if_ready_callback_ = std::move(callback);
  325. return rv;
  326. }
  327. int FakeBlockingStreamSocket::CancelReadIfReady() {
  328. DCHECK(!read_if_ready_callback_.is_null());
  329. read_if_ready_callback_.Reset();
  330. return OK;
  331. }
  332. int FakeBlockingStreamSocket::Write(
  333. IOBuffer* buf,
  334. int len,
  335. CompletionOnceCallback callback,
  336. const NetworkTrafficAnnotationTag& traffic_annotation) {
  337. DCHECK(buf);
  338. DCHECK_LE(0, len);
  339. if (!should_block_write_)
  340. return transport_->Write(buf, len, std::move(callback), traffic_annotation);
  341. // Schedule the write, but do nothing.
  342. DCHECK(!pending_write_buf_.get());
  343. DCHECK_EQ(-1, pending_write_len_);
  344. DCHECK(pending_write_callback_.is_null());
  345. DCHECK(!callback.is_null());
  346. pending_write_buf_ = buf;
  347. pending_write_len_ = len;
  348. pending_write_callback_ = std::move(callback);
  349. // Stop the write loop, if any.
  350. if (write_loop_)
  351. write_loop_->Quit();
  352. return ERR_IO_PENDING;
  353. }
  354. void FakeBlockingStreamSocket::BlockReadResult() {
  355. DCHECK(!should_block_read_);
  356. should_block_read_ = true;
  357. }
  358. void FakeBlockingStreamSocket::UnblockReadResult() {
  359. DCHECK(should_block_read_);
  360. should_block_read_ = false;
  361. // If the operation has since completed, return the result to the caller.
  362. if (pending_read_result_ != ERR_IO_PENDING)
  363. ReturnReadResult();
  364. }
  365. bool FakeBlockingStreamSocket::ReplaceReadResult(const std::string& data) {
  366. DCHECK(should_block_read_);
  367. DCHECK_NE(ERR_IO_PENDING, pending_read_result_);
  368. DCHECK(pending_read_buf_);
  369. DCHECK_NE(-1, pending_read_buf_len_);
  370. if (static_cast<size_t>(pending_read_buf_len_) < data.size())
  371. return false;
  372. memcpy(pending_read_buf_->data(), data.data(), data.size());
  373. pending_read_result_ = data.size();
  374. return true;
  375. }
  376. void FakeBlockingStreamSocket::WaitForReadResult() {
  377. DCHECK(should_block_read_);
  378. DCHECK(!read_loop_);
  379. if (pending_read_result_ != ERR_IO_PENDING)
  380. return;
  381. read_loop_ = std::make_unique<base::RunLoop>();
  382. read_loop_->Run();
  383. read_loop_.reset();
  384. DCHECK_NE(ERR_IO_PENDING, pending_read_result_);
  385. }
  386. void FakeBlockingStreamSocket::BlockWrite() {
  387. DCHECK(!should_block_write_);
  388. should_block_write_ = true;
  389. }
  390. void FakeBlockingStreamSocket::CallPendingWriteCallback(int rv) {
  391. std::move(pending_write_callback_).Run(rv);
  392. }
  393. void FakeBlockingStreamSocket::UnblockWrite() {
  394. DCHECK(should_block_write_);
  395. should_block_write_ = false;
  396. // Do nothing if UnblockWrite() was called after BlockWrite(),
  397. // without a Write() in between.
  398. if (!pending_write_buf_.get())
  399. return;
  400. int rv = transport_->Write(
  401. pending_write_buf_.get(), pending_write_len_,
  402. base::BindOnce(&FakeBlockingStreamSocket::CallPendingWriteCallback,
  403. base::Unretained(this)),
  404. TRAFFIC_ANNOTATION_FOR_TESTS);
  405. pending_write_buf_ = nullptr;
  406. pending_write_len_ = -1;
  407. if (rv != ERR_IO_PENDING) {
  408. std::move(pending_write_callback_).Run(rv);
  409. }
  410. }
  411. void FakeBlockingStreamSocket::WaitForWrite() {
  412. DCHECK(should_block_write_);
  413. DCHECK(!write_loop_);
  414. if (pending_write_buf_.get())
  415. return;
  416. write_loop_ = std::make_unique<base::RunLoop>();
  417. write_loop_->Run();
  418. write_loop_.reset();
  419. DCHECK(pending_write_buf_.get());
  420. }
  421. void FakeBlockingStreamSocket::OnReadCompleted(int result) {
  422. DCHECK_EQ(ERR_IO_PENDING, pending_read_result_);
  423. DCHECK(!pending_read_callback_.is_null());
  424. pending_read_result_ = result;
  425. if (should_block_read_) {
  426. // Defer the result until UnblockReadResult is called.
  427. if (read_loop_)
  428. read_loop_->Quit();
  429. return;
  430. }
  431. ReturnReadResult();
  432. }
  433. void FakeBlockingStreamSocket::CompleteReadIfReady(scoped_refptr<IOBuffer> buf,
  434. int rv) {
  435. DCHECK(read_if_ready_buf_.empty());
  436. DCHECK(!should_block_read_);
  437. if (rv > 0)
  438. read_if_ready_buf_ = std::string(buf->data(), buf->data() + rv);
  439. // The callback may be null if CancelReadIfReady() was called.
  440. if (!read_if_ready_callback_.is_null())
  441. std::move(read_if_ready_callback_).Run(rv > 0 ? OK : rv);
  442. }
  443. void FakeBlockingStreamSocket::ReturnReadResult() {
  444. int result = pending_read_result_;
  445. pending_read_result_ = ERR_IO_PENDING;
  446. pending_read_buf_ = nullptr;
  447. pending_read_buf_len_ = -1;
  448. std::move(pending_read_callback_).Run(result);
  449. }
  450. // CountingStreamSocket wraps an existing StreamSocket and maintains a count of
  451. // reads and writes on the socket.
  452. class CountingStreamSocket : public WrappedStreamSocket {
  453. public:
  454. explicit CountingStreamSocket(std::unique_ptr<StreamSocket> transport)
  455. : WrappedStreamSocket(std::move(transport)) {}
  456. ~CountingStreamSocket() override = default;
  457. // Socket implementation:
  458. int Read(IOBuffer* buf,
  459. int buf_len,
  460. CompletionOnceCallback callback) override {
  461. read_count_++;
  462. return transport_->Read(buf, buf_len, std::move(callback));
  463. }
  464. int Write(IOBuffer* buf,
  465. int buf_len,
  466. CompletionOnceCallback callback,
  467. const NetworkTrafficAnnotationTag& traffic_annotation) override {
  468. write_count_++;
  469. return transport_->Write(buf, buf_len, std::move(callback),
  470. traffic_annotation);
  471. }
  472. int read_count() const { return read_count_; }
  473. int write_count() const { return write_count_; }
  474. private:
  475. int read_count_ = 0;
  476. int write_count_ = 0;
  477. };
  478. // A helper class that will delete |socket| when the callback is invoked.
  479. class DeleteSocketCallback : public TestCompletionCallbackBase {
  480. public:
  481. explicit DeleteSocketCallback(StreamSocket* socket) : socket_(socket) {}
  482. DeleteSocketCallback(const DeleteSocketCallback&) = delete;
  483. DeleteSocketCallback& operator=(const DeleteSocketCallback&) = delete;
  484. ~DeleteSocketCallback() override = default;
  485. CompletionOnceCallback callback() {
  486. return base::BindOnce(&DeleteSocketCallback::OnComplete,
  487. base::Unretained(this));
  488. }
  489. private:
  490. void OnComplete(int result) {
  491. if (socket_) {
  492. delete socket_;
  493. socket_ = nullptr;
  494. } else {
  495. ADD_FAILURE() << "Deleting socket twice";
  496. }
  497. SetResult(result);
  498. }
  499. raw_ptr<StreamSocket> socket_;
  500. };
  501. // A mock ExpectCTReporter that remembers the latest violation that was
  502. // reported and the number of violations reported.
  503. class MockExpectCTReporter : public TransportSecurityState::ExpectCTReporter {
  504. public:
  505. MockExpectCTReporter() = default;
  506. ~MockExpectCTReporter() override = default;
  507. void OnExpectCTFailed(
  508. const HostPortPair& host_port_pair,
  509. const GURL& report_uri,
  510. base::Time expiration,
  511. const X509Certificate* validated_certificate_chain,
  512. const X509Certificate* served_certificate_chain,
  513. const SignedCertificateTimestampAndStatusList&
  514. signed_certificate_timestamps,
  515. const NetworkIsolationKey& network_isolation_key) override {
  516. num_failures_++;
  517. host_port_pair_ = host_port_pair;
  518. report_uri_ = report_uri;
  519. served_certificate_chain_ = served_certificate_chain;
  520. validated_certificate_chain_ = validated_certificate_chain;
  521. signed_certificate_timestamps_ = signed_certificate_timestamps;
  522. network_isolation_key_ = network_isolation_key;
  523. }
  524. const HostPortPair& host_port_pair() const { return host_port_pair_; }
  525. const GURL& report_uri() const { return report_uri_; }
  526. uint32_t num_failures() const { return num_failures_; }
  527. const X509Certificate* served_certificate_chain() const {
  528. return served_certificate_chain_;
  529. }
  530. const X509Certificate* validated_certificate_chain() const {
  531. return validated_certificate_chain_;
  532. }
  533. const SignedCertificateTimestampAndStatusList& signed_certificate_timestamps()
  534. const {
  535. return signed_certificate_timestamps_;
  536. }
  537. const NetworkIsolationKey network_isolation_key() const {
  538. return network_isolation_key_;
  539. }
  540. private:
  541. HostPortPair host_port_pair_;
  542. GURL report_uri_;
  543. uint32_t num_failures_ = 0;
  544. raw_ptr<const X509Certificate> served_certificate_chain_;
  545. raw_ptr<const X509Certificate> validated_certificate_chain_;
  546. SignedCertificateTimestampAndStatusList signed_certificate_timestamps_;
  547. NetworkIsolationKey network_isolation_key_;
  548. };
  549. // A mock CTVerifier that records every call to Verify but doesn't verify
  550. // anything.
  551. class MockCTVerifier : public CTVerifier {
  552. public:
  553. MOCK_METHOD6(Verify,
  554. void(base::StringPiece,
  555. X509Certificate*,
  556. base::StringPiece,
  557. base::StringPiece,
  558. SignedCertificateTimestampAndStatusList*,
  559. const NetLogWithSource&));
  560. };
  561. // A mock CTPolicyEnforcer that returns a custom verification result.
  562. class MockCTPolicyEnforcer : public CTPolicyEnforcer {
  563. public:
  564. MOCK_METHOD3(CheckCompliance,
  565. ct::CTPolicyCompliance(X509Certificate* cert,
  566. const ct::SCTList&,
  567. const NetLogWithSource&));
  568. };
  569. class MockRequireCTDelegate : public TransportSecurityState::RequireCTDelegate {
  570. public:
  571. MOCK_METHOD3(IsCTRequiredForHost,
  572. CTRequirementLevel(const std::string& host,
  573. const X509Certificate* chain,
  574. const HashValueVector& hashes));
  575. };
  576. class MockSCTAuditingDelegate : public SCTAuditingDelegate {
  577. public:
  578. MOCK_METHOD(bool, IsSCTAuditingEnabled, ());
  579. MOCK_METHOD(void,
  580. MaybeEnqueueReport,
  581. (const net::HostPortPair&,
  582. const net::X509Certificate*,
  583. const net::SignedCertificateTimestampAndStatusList&));
  584. };
  585. class ManySmallRecordsHttpResponse : public test_server::HttpResponse {
  586. public:
  587. static std::unique_ptr<test_server::HttpResponse> HandleRequest(
  588. const test_server::HttpRequest& request) {
  589. if (request.relative_url != "/ssl-many-small-records") {
  590. return nullptr;
  591. }
  592. // Write ~26K of data, in 1350 byte chunks
  593. return std::make_unique<ManySmallRecordsHttpResponse>(/*chunk_size=*/1350,
  594. /*chunk_count=*/20);
  595. }
  596. ManySmallRecordsHttpResponse(size_t chunk_size, size_t chunk_count)
  597. : chunk_size_(chunk_size), chunk_count_(chunk_count) {}
  598. void SendResponse(
  599. base::WeakPtr<test_server::HttpResponseDelegate> delegate) override {
  600. base::StringPairs headers = {
  601. {"Connection", "close"},
  602. {"Content-Length", base::NumberToString(chunk_size_ * chunk_count_)},
  603. {"Content-Type", "text/plain"}};
  604. delegate->SendResponseHeaders(HTTP_OK, "OK", headers);
  605. SendChunks(chunk_size_, chunk_count_, delegate);
  606. }
  607. private:
  608. static void SendChunks(
  609. size_t chunk_size,
  610. size_t chunk_count,
  611. base::WeakPtr<test_server::HttpResponseDelegate> delegate) {
  612. if (!delegate)
  613. return;
  614. if (chunk_count == 0) {
  615. delegate->FinishResponse();
  616. return;
  617. }
  618. std::string chunk(chunk_size, '*');
  619. // This assumes that splitting output into separate |send| calls will
  620. // produce separate TLS records.
  621. delegate->SendContents(chunk, base::BindOnce(&SendChunks, chunk_size,
  622. chunk_count - 1, delegate));
  623. }
  624. size_t chunk_size_;
  625. size_t chunk_count_;
  626. };
  627. class SSLClientSocketTest : public PlatformTest, public WithTaskEnvironment {
  628. public:
  629. SSLClientSocketTest()
  630. : socket_factory_(ClientSocketFactory::GetDefaultFactory()),
  631. ssl_config_service_(
  632. std::make_unique<TestSSLConfigService>(SSLContextConfig())),
  633. cert_verifier_(std::make_unique<MockCertVerifier>()),
  634. transport_security_state_(std::make_unique<TransportSecurityState>()),
  635. ct_policy_enforcer_(std::make_unique<MockCTPolicyEnforcer>()),
  636. ssl_client_session_cache_(std::make_unique<SSLClientSessionCache>(
  637. SSLClientSessionCache::Config())),
  638. context_(
  639. std::make_unique<SSLClientContext>(ssl_config_service_.get(),
  640. cert_verifier_.get(),
  641. transport_security_state_.get(),
  642. ct_policy_enforcer_.get(),
  643. ssl_client_session_cache_.get(),
  644. nullptr)) {
  645. cert_verifier_->set_default_result(OK);
  646. cert_verifier_->set_async(true);
  647. EXPECT_CALL(*ct_policy_enforcer_, CheckCompliance(_, _, _))
  648. .WillRepeatedly(
  649. Return(ct::CTPolicyCompliance::CT_POLICY_COMPLIES_VIA_SCTS));
  650. }
  651. protected:
  652. // The address of the test server, after calling StartEmbeddedTestServer().
  653. const AddressList& addr() const { return addr_; }
  654. // The hostname of the test server, after calling StartEmbeddedTestServer().
  655. const HostPortPair& host_port_pair() const { return host_port_pair_; }
  656. // The EmbeddedTestServer object, after calling StartEmbeddedTestServer().
  657. EmbeddedTestServer* embedded_test_server() {
  658. return embedded_test_server_.get();
  659. }
  660. // Starts the embedded test server with the specified parameters. Returns true
  661. // on success.
  662. bool StartEmbeddedTestServer(EmbeddedTestServer::ServerCertificate cert,
  663. const SSLServerConfig& server_config) {
  664. embedded_test_server_ =
  665. std::make_unique<EmbeddedTestServer>(EmbeddedTestServer::TYPE_HTTPS);
  666. embedded_test_server_->SetSSLConfig(cert, server_config);
  667. return FinishStartingEmbeddedTestServer();
  668. }
  669. // Starts the embedded test server with the specified parameters. Returns true
  670. // on success.
  671. bool StartEmbeddedTestServer(
  672. const EmbeddedTestServer::ServerCertificateConfig& cert_config,
  673. const SSLServerConfig& server_config) {
  674. embedded_test_server_ =
  675. std::make_unique<EmbeddedTestServer>(EmbeddedTestServer::TYPE_HTTPS);
  676. embedded_test_server_->SetSSLConfig(cert_config, server_config);
  677. return FinishStartingEmbeddedTestServer();
  678. }
  679. bool FinishStartingEmbeddedTestServer() {
  680. RegisterEmbeddedTestServerHandlers(embedded_test_server_.get());
  681. if (!embedded_test_server_->Start()) {
  682. LOG(ERROR) << "Could not start EmbeddedTestServer";
  683. return false;
  684. }
  685. if (!embedded_test_server_->GetAddressList(&addr_)) {
  686. LOG(ERROR) << "Could not get EmbeddedTestServer address list";
  687. return false;
  688. }
  689. host_port_pair_ = embedded_test_server_->host_port_pair();
  690. return true;
  691. }
  692. // May be overridden by the subclass to customize the EmbeddedTestServer.
  693. virtual void RegisterEmbeddedTestServerHandlers(EmbeddedTestServer* server) {
  694. server->AddDefaultHandlers(base::FilePath());
  695. server->RegisterRequestHandler(
  696. base::BindRepeating(&ManySmallRecordsHttpResponse::HandleRequest));
  697. server->RegisterRequestHandler(
  698. base::BindRepeating(&HandleSSLInfoRequest, base::Unretained(this)));
  699. }
  700. std::unique_ptr<SSLClientSocket> CreateSSLClientSocket(
  701. std::unique_ptr<StreamSocket> transport_socket,
  702. const HostPortPair& host_and_port,
  703. const SSLConfig& ssl_config) {
  704. return socket_factory_->CreateSSLClientSocket(
  705. context_.get(), std::move(transport_socket), host_and_port, ssl_config);
  706. }
  707. // Create an SSLClientSocket object and use it to connect to a test server,
  708. // then wait for connection results. This must be called after a successful
  709. // StartEmbeddedTestServer() call.
  710. //
  711. // |ssl_config| The SSL configuration to use.
  712. // |host_port_pair| The hostname and port to use at the SSL layer. (The
  713. // socket connection will still be made to |embedded_test_server_|.)
  714. // |result| will retrieve the ::Connect() result value.
  715. //
  716. // Returns true on success, false otherwise. Success means that the SSL
  717. // socket could be created and its Connect() was called, not that the
  718. // connection itself was a success.
  719. bool CreateAndConnectSSLClientSocketWithHost(
  720. const SSLConfig& ssl_config,
  721. const HostPortPair& host_port_pair,
  722. int* result) {
  723. auto transport = std::make_unique<TCPClientSocket>(
  724. addr_, nullptr, nullptr, NetLog::Get(), NetLogSource());
  725. int rv = callback_.GetResult(transport->Connect(callback_.callback()));
  726. if (rv != OK) {
  727. LOG(ERROR) << "Could not connect to test server";
  728. return false;
  729. }
  730. sock_ =
  731. CreateSSLClientSocket(std::move(transport), host_port_pair, ssl_config);
  732. EXPECT_FALSE(sock_->IsConnected());
  733. *result = callback_.GetResult(sock_->Connect(callback_.callback()));
  734. return true;
  735. }
  736. bool CreateAndConnectSSLClientSocket(const SSLConfig& ssl_config,
  737. int* result) {
  738. return CreateAndConnectSSLClientSocketWithHost(ssl_config, host_port_pair(),
  739. result);
  740. }
  741. // Adds the server certificate with provided cert status.
  742. // Must be called after StartEmbeddedTestServer has been called.
  743. void AddServerCertStatusToSSLConfig(CertStatus status,
  744. SSLConfig* ssl_config) {
  745. ASSERT_TRUE(embedded_test_server());
  746. scoped_refptr<X509Certificate> server_cert =
  747. embedded_test_server()->GetCertificate();
  748. CertVerifyResult verify_result;
  749. verify_result.cert_status = status;
  750. verify_result.verified_cert = server_cert;
  751. cert_verifier_->AddResultForCert(server_cert.get(), verify_result, OK);
  752. }
  753. absl::optional<SSLInfo> LastSSLInfoFromServer() {
  754. // EmbeddedTestServer callbacks run on another thread, so protect this
  755. // with a lock.
  756. base::AutoLock lock(server_ssl_info_lock_);
  757. auto result = server_ssl_info_;
  758. server_ssl_info_ = absl::nullopt;
  759. return result;
  760. }
  761. RecordingNetLogObserver log_observer_;
  762. raw_ptr<ClientSocketFactory> socket_factory_;
  763. std::unique_ptr<TestSSLConfigService> ssl_config_service_;
  764. std::unique_ptr<MockCertVerifier> cert_verifier_;
  765. std::unique_ptr<TransportSecurityState> transport_security_state_;
  766. std::unique_ptr<MockCTPolicyEnforcer> ct_policy_enforcer_;
  767. std::unique_ptr<SSLClientSessionCache> ssl_client_session_cache_;
  768. std::unique_ptr<SSLClientContext> context_;
  769. std::unique_ptr<SSLClientSocket> sock_;
  770. private:
  771. static std::unique_ptr<test_server::HttpResponse> HandleSSLInfoRequest(
  772. SSLClientSocketTest* test,
  773. const test_server::HttpRequest& request) {
  774. if (request.relative_url != "/ssl-info") {
  775. return nullptr;
  776. }
  777. {
  778. // EmbeddedTestServer callbacks run on another thread, so protect this
  779. // with a lock.
  780. base::AutoLock lock(test->server_ssl_info_lock_);
  781. test->server_ssl_info_ = request.ssl_info;
  782. }
  783. return std::make_unique<test_server::BasicHttpResponse>();
  784. }
  785. std::unique_ptr<EmbeddedTestServer> embedded_test_server_;
  786. base::Lock server_ssl_info_lock_;
  787. absl::optional<SSLInfo> server_ssl_info_ GUARDED_BY(server_ssl_info_lock_);
  788. TestCompletionCallback callback_;
  789. AddressList addr_;
  790. HostPortPair host_port_pair_;
  791. };
  792. enum ReadIfReadyTransport {
  793. // ReadIfReady() is implemented by the underlying transport.
  794. READ_IF_READY_SUPPORTED,
  795. // ReadIfReady() is not implemented by the underlying transport.
  796. READ_IF_READY_NOT_SUPPORTED,
  797. };
  798. enum ReadIfReadySSL {
  799. // Test reads by calling ReadIfReady() on the SSL socket.
  800. TEST_SSL_READ_IF_READY,
  801. // Test reads by calling Read() on the SSL socket.
  802. TEST_SSL_READ,
  803. };
  804. class StreamSocketWithoutReadIfReady : public WrappedStreamSocket {
  805. public:
  806. explicit StreamSocketWithoutReadIfReady(
  807. std::unique_ptr<StreamSocket> transport)
  808. : WrappedStreamSocket(std::move(transport)) {}
  809. int ReadIfReady(IOBuffer* buf,
  810. int buf_len,
  811. CompletionOnceCallback callback) override {
  812. return ERR_READ_IF_READY_NOT_IMPLEMENTED;
  813. }
  814. int CancelReadIfReady() override { return ERR_READ_IF_READY_NOT_IMPLEMENTED; }
  815. };
  816. class ClientSocketFactoryWithoutReadIfReady : public ClientSocketFactory {
  817. public:
  818. explicit ClientSocketFactoryWithoutReadIfReady(ClientSocketFactory* factory)
  819. : factory_(factory) {}
  820. std::unique_ptr<DatagramClientSocket> CreateDatagramClientSocket(
  821. DatagramSocket::BindType bind_type,
  822. NetLog* net_log,
  823. const NetLogSource& source) override {
  824. return factory_->CreateDatagramClientSocket(bind_type, net_log, source);
  825. }
  826. std::unique_ptr<TransportClientSocket> CreateTransportClientSocket(
  827. const AddressList& addresses,
  828. std::unique_ptr<SocketPerformanceWatcher> socket_performance_watcher,
  829. NetworkQualityEstimator* network_quality_estimator,
  830. NetLog* net_log,
  831. const NetLogSource& source) override {
  832. return factory_->CreateTransportClientSocket(
  833. addresses, std::move(socket_performance_watcher),
  834. network_quality_estimator, net_log, source);
  835. }
  836. std::unique_ptr<SSLClientSocket> CreateSSLClientSocket(
  837. SSLClientContext* context,
  838. std::unique_ptr<StreamSocket> stream_socket,
  839. const HostPortPair& host_and_port,
  840. const SSLConfig& ssl_config) override {
  841. stream_socket = std::make_unique<StreamSocketWithoutReadIfReady>(
  842. std::move(stream_socket));
  843. return factory_->CreateSSLClientSocket(context, std::move(stream_socket),
  844. host_and_port, ssl_config);
  845. }
  846. private:
  847. const raw_ptr<ClientSocketFactory> factory_;
  848. };
  849. std::vector<uint16_t> GetTLSVersions() {
  850. return {SSL_PROTOCOL_VERSION_TLS1_2, SSL_PROTOCOL_VERSION_TLS1_3};
  851. }
  852. class SSLClientSocketVersionTest
  853. : public SSLClientSocketTest,
  854. public ::testing::WithParamInterface<uint16_t> {
  855. protected:
  856. SSLClientSocketVersionTest() = default;
  857. uint16_t version() const { return GetParam(); }
  858. SSLServerConfig GetServerConfig() {
  859. SSLServerConfig config;
  860. config.version_max = version();
  861. config.version_min = version();
  862. return config;
  863. }
  864. };
  865. // If GetParam(), try ReadIfReady() and fall back to Read() if needed.
  866. class SSLClientSocketReadTest
  867. : public SSLClientSocketTest,
  868. public ::testing::WithParamInterface<
  869. std::tuple<ReadIfReadyTransport, ReadIfReadySSL, uint16_t>> {
  870. protected:
  871. SSLClientSocketReadTest() : SSLClientSocketTest() {
  872. if (!read_if_ready_supported()) {
  873. wrapped_socket_factory_ =
  874. std::make_unique<ClientSocketFactoryWithoutReadIfReady>(
  875. socket_factory_);
  876. socket_factory_ = wrapped_socket_factory_.get();
  877. }
  878. }
  879. // Convienient wrapper to call Read()/ReadIfReady() depending on whether
  880. // ReadyIfReady() is enabled.
  881. int Read(StreamSocket* socket,
  882. IOBuffer* buf,
  883. int buf_len,
  884. CompletionOnceCallback callback) {
  885. if (test_ssl_read_if_ready())
  886. return socket->ReadIfReady(buf, buf_len, std::move(callback));
  887. return socket->Read(buf, buf_len, std::move(callback));
  888. }
  889. // Wait for Read()/ReadIfReady() to complete.
  890. int WaitForReadCompletion(StreamSocket* socket,
  891. IOBuffer* buf,
  892. int buf_len,
  893. TestCompletionCallback* callback,
  894. int rv) {
  895. if (!test_ssl_read_if_ready())
  896. return callback->GetResult(rv);
  897. while (rv == ERR_IO_PENDING) {
  898. rv = callback->GetResult(rv);
  899. if (rv != OK)
  900. return rv;
  901. rv = socket->ReadIfReady(buf, buf_len, callback->callback());
  902. }
  903. return rv;
  904. }
  905. // Calls Read()/ReadIfReady() and waits for it to return data.
  906. int ReadAndWaitForCompletion(StreamSocket* socket,
  907. IOBuffer* buf,
  908. int buf_len) {
  909. TestCompletionCallback callback;
  910. int rv = Read(socket, buf, buf_len, callback.callback());
  911. return WaitForReadCompletion(socket, buf, buf_len, &callback, rv);
  912. }
  913. SSLServerConfig GetServerConfig() {
  914. SSLServerConfig config;
  915. config.version_max = version();
  916. config.version_min = version();
  917. return config;
  918. }
  919. bool test_ssl_read_if_ready() const {
  920. return std::get<1>(GetParam()) == TEST_SSL_READ_IF_READY;
  921. }
  922. bool read_if_ready_supported() const {
  923. return std::get<0>(GetParam()) == READ_IF_READY_SUPPORTED;
  924. }
  925. uint16_t version() const { return std::get<2>(GetParam()); }
  926. private:
  927. std::unique_ptr<ClientSocketFactory> wrapped_socket_factory_;
  928. };
  929. INSTANTIATE_TEST_SUITE_P(All,
  930. SSLClientSocketReadTest,
  931. Combine(Values(READ_IF_READY_SUPPORTED,
  932. READ_IF_READY_NOT_SUPPORTED),
  933. Values(TEST_SSL_READ_IF_READY, TEST_SSL_READ),
  934. ValuesIn(GetTLSVersions())));
  935. // Verifies the correctness of GetSSLCertRequestInfo.
  936. class SSLClientSocketCertRequestInfoTest : public SSLClientSocketVersionTest {
  937. protected:
  938. // Connects to the test server and returns the SSLCertRequestInfo reported by
  939. // the socket.
  940. scoped_refptr<SSLCertRequestInfo> GetCertRequest() {
  941. int rv;
  942. if (!CreateAndConnectSSLClientSocket(SSLConfig(), &rv)) {
  943. return nullptr;
  944. }
  945. EXPECT_THAT(rv, IsError(ERR_SSL_CLIENT_AUTH_CERT_NEEDED));
  946. auto request_info = base::MakeRefCounted<SSLCertRequestInfo>();
  947. sock_->GetSSLCertRequestInfo(request_info.get());
  948. sock_->Disconnect();
  949. EXPECT_FALSE(sock_->IsConnected());
  950. EXPECT_TRUE(host_port_pair().Equals(request_info->host_and_port));
  951. return request_info;
  952. }
  953. };
  954. class SSLClientSocketFalseStartTest : public SSLClientSocketTest {
  955. protected:
  956. // Creates an SSLClientSocket with |client_config| attached to a
  957. // FakeBlockingStreamSocket, returning both in |*out_raw_transport| and
  958. // |*out_sock|. The FakeBlockingStreamSocket is owned by the SSLClientSocket,
  959. // so |*out_raw_transport| is a raw pointer.
  960. //
  961. // The client socket will begin a connect using |callback| but stop before the
  962. // server's finished message is received. The finished message will be blocked
  963. // in |*out_raw_transport|. To complete the handshake and successfully read
  964. // data, the caller must unblock reads on |*out_raw_transport|. (Note that, if
  965. // the client successfully false started, |callback.WaitForResult()| will
  966. // return OK without unblocking transport reads. But Read() will still block.)
  967. //
  968. // Must be called after StartEmbeddedTestServer is called.
  969. void CreateAndConnectUntilServerFinishedReceived(
  970. const SSLConfig& client_config,
  971. TestCompletionCallback* callback,
  972. FakeBlockingStreamSocket** out_raw_transport,
  973. std::unique_ptr<SSLClientSocket>* out_sock) {
  974. CHECK(embedded_test_server());
  975. auto real_transport = std::make_unique<TCPClientSocket>(
  976. addr(), nullptr, nullptr, nullptr, NetLogSource());
  977. auto transport =
  978. std::make_unique<FakeBlockingStreamSocket>(std::move(real_transport));
  979. int rv = callback->GetResult(transport->Connect(callback->callback()));
  980. EXPECT_THAT(rv, IsOk());
  981. FakeBlockingStreamSocket* raw_transport = transport.get();
  982. std::unique_ptr<SSLClientSocket> sock = CreateSSLClientSocket(
  983. std::move(transport), host_port_pair(), client_config);
  984. // Connect. Stop before the client processes the first server leg
  985. // (ServerHello, etc.)
  986. raw_transport->BlockReadResult();
  987. rv = sock->Connect(callback->callback());
  988. EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
  989. raw_transport->WaitForReadResult();
  990. // Release the ServerHello and wait for the client to write
  991. // ClientKeyExchange, etc. (A proxy for waiting for the entirety of the
  992. // server's leg to complete, since it may span multiple reads.)
  993. EXPECT_FALSE(callback->have_result());
  994. raw_transport->BlockWrite();
  995. raw_transport->UnblockReadResult();
  996. raw_transport->WaitForWrite();
  997. // And, finally, release that and block the next server leg
  998. // (ChangeCipherSpec, Finished).
  999. raw_transport->BlockReadResult();
  1000. raw_transport->UnblockWrite();
  1001. *out_raw_transport = raw_transport;
  1002. *out_sock = std::move(sock);
  1003. }
  1004. void TestFalseStart(const SSLServerConfig& server_config,
  1005. const SSLConfig& client_config,
  1006. bool expect_false_start) {
  1007. ASSERT_TRUE(
  1008. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  1009. TestCompletionCallback callback;
  1010. FakeBlockingStreamSocket* raw_transport = nullptr;
  1011. std::unique_ptr<SSLClientSocket> sock;
  1012. ASSERT_NO_FATAL_FAILURE(CreateAndConnectUntilServerFinishedReceived(
  1013. client_config, &callback, &raw_transport, &sock));
  1014. if (expect_false_start) {
  1015. // When False Starting, the handshake should complete before receiving the
  1016. // Change Cipher Spec and Finished messages.
  1017. //
  1018. // Note: callback.have_result() may not be true without waiting. The NSS
  1019. // state machine sometimes lives on a separate thread, so this thread may
  1020. // not yet have processed the signal that the handshake has completed.
  1021. int rv = callback.WaitForResult();
  1022. EXPECT_THAT(rv, IsOk());
  1023. EXPECT_TRUE(sock->IsConnected());
  1024. const char request_text[] = "GET / HTTP/1.0\r\n\r\n";
  1025. static const int kRequestTextSize =
  1026. static_cast<int>(std::size(request_text) - 1);
  1027. scoped_refptr<IOBuffer> request_buffer =
  1028. base::MakeRefCounted<IOBuffer>(kRequestTextSize);
  1029. memcpy(request_buffer->data(), request_text, kRequestTextSize);
  1030. // Write the request.
  1031. rv = callback.GetResult(sock->Write(request_buffer.get(),
  1032. kRequestTextSize, callback.callback(),
  1033. TRAFFIC_ANNOTATION_FOR_TESTS));
  1034. EXPECT_EQ(kRequestTextSize, rv);
  1035. // The read will hang; it's waiting for the peer to complete the
  1036. // handshake, and the handshake is still blocked.
  1037. scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(4096);
  1038. rv = sock->Read(buf.get(), 4096, callback.callback());
  1039. // After releasing reads, the connection proceeds.
  1040. raw_transport->UnblockReadResult();
  1041. rv = callback.GetResult(rv);
  1042. EXPECT_LT(0, rv);
  1043. } else {
  1044. // False Start is not enabled, so the handshake will not complete because
  1045. // the server second leg is blocked.
  1046. base::RunLoop().RunUntilIdle();
  1047. EXPECT_FALSE(callback.have_result());
  1048. }
  1049. }
  1050. };
  1051. // Sends an HTTP request on the socket and reads the response. This may be used
  1052. // to ensure some data has been consumed from the server.
  1053. int MakeHTTPRequest(StreamSocket* socket, const char* path = "/") {
  1054. std::string request = base::StringPrintf("GET %s HTTP/1.0\r\n\r\n", path);
  1055. TestCompletionCallback callback;
  1056. while (!request.empty()) {
  1057. auto request_buffer =
  1058. base::MakeRefCounted<StringIOBuffer>(std::string(request));
  1059. int rv = callback.GetResult(
  1060. socket->Write(request_buffer.get(), request_buffer->size(),
  1061. callback.callback(), TRAFFIC_ANNOTATION_FOR_TESTS));
  1062. if (rv < 0) {
  1063. return rv;
  1064. }
  1065. request = request.substr(rv);
  1066. }
  1067. auto response_buffer = base::MakeRefCounted<IOBuffer>(1024);
  1068. int rv = callback.GetResult(
  1069. socket->Read(response_buffer.get(), 1024, callback.callback()));
  1070. if (rv < 0) {
  1071. return rv;
  1072. }
  1073. return OK;
  1074. }
  1075. // Provides a response to the 0RTT request indicating whether it was received
  1076. // as early data.
  1077. class ZeroRTTResponse : public test_server::HttpResponse {
  1078. public:
  1079. explicit ZeroRTTResponse(bool zero_rtt) : zero_rtt_(zero_rtt) {}
  1080. ZeroRTTResponse(const ZeroRTTResponse&) = delete;
  1081. ZeroRTTResponse& operator=(const ZeroRTTResponse&) = delete;
  1082. ~ZeroRTTResponse() override = default;
  1083. void SendResponse(
  1084. base::WeakPtr<test_server::HttpResponseDelegate> delegate) override {
  1085. std::string response;
  1086. if (zero_rtt_) {
  1087. response = "1";
  1088. } else {
  1089. response = "0";
  1090. }
  1091. // Since the EmbeddedTestServer doesn't keep the socket open by default, it
  1092. // is explicitly kept alive to allow the remaining leg of the 0RTT handshake
  1093. // to be received after the early data.
  1094. delegate->SendContents(response);
  1095. }
  1096. private:
  1097. bool zero_rtt_;
  1098. };
  1099. std::unique_ptr<test_server::HttpResponse> HandleZeroRTTRequest(
  1100. const test_server::HttpRequest& request) {
  1101. if (request.GetURL().path() != "/zerortt" || !request.ssl_info)
  1102. return nullptr;
  1103. return std::make_unique<ZeroRTTResponse>(
  1104. request.ssl_info->early_data_received);
  1105. }
  1106. class SSLClientSocketZeroRTTTest : public SSLClientSocketTest {
  1107. protected:
  1108. SSLClientSocketZeroRTTTest() : SSLClientSocketTest() {
  1109. SSLContextConfig config;
  1110. config.version_max = SSL_PROTOCOL_VERSION_TLS1_3;
  1111. ssl_config_service_->UpdateSSLConfigAndNotify(config);
  1112. }
  1113. bool StartServer() {
  1114. SSLServerConfig server_config;
  1115. server_config.early_data_enabled = true;
  1116. server_config.version_max = SSL_PROTOCOL_VERSION_TLS1_3;
  1117. return StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config);
  1118. }
  1119. void RegisterEmbeddedTestServerHandlers(EmbeddedTestServer* server) override {
  1120. SSLClientSocketTest::RegisterEmbeddedTestServerHandlers(server);
  1121. server->RegisterRequestHandler(base::BindRepeating(&HandleZeroRTTRequest));
  1122. }
  1123. void SetServerConfig(SSLServerConfig server_config) {
  1124. embedded_test_server()->ResetSSLConfig(net::EmbeddedTestServer::CERT_OK,
  1125. server_config);
  1126. }
  1127. // Makes a new connection to the test server and returns a
  1128. // FakeBlockingStreamSocket which may be used to block transport I/O.
  1129. //
  1130. // Most tests should call BlockReadResult() before calling Connect(). This
  1131. // avoid race conditions by controlling the order of events. 0-RTT typically
  1132. // races the ServerHello from the server with early data from the client. If
  1133. // the ServerHello arrives before client calls Write(), the data may be sent
  1134. // with 1-RTT keys rather than 0-RTT keys.
  1135. FakeBlockingStreamSocket* MakeClient(bool early_data_enabled) {
  1136. SSLConfig ssl_config;
  1137. ssl_config.early_data_enabled = early_data_enabled;
  1138. real_transport_ = std::make_unique<TCPClientSocket>(
  1139. addr(), nullptr, nullptr, nullptr, NetLogSource());
  1140. auto transport =
  1141. std::make_unique<FakeBlockingStreamSocket>(std::move(real_transport_));
  1142. FakeBlockingStreamSocket* raw_transport = transport.get();
  1143. int rv = callback_.GetResult(transport->Connect(callback_.callback()));
  1144. EXPECT_THAT(rv, IsOk());
  1145. ssl_socket_ = CreateSSLClientSocket(std::move(transport), host_port_pair(),
  1146. ssl_config);
  1147. EXPECT_FALSE(ssl_socket_->IsConnected());
  1148. return raw_transport;
  1149. }
  1150. int Connect() {
  1151. return callback_.GetResult(ssl_socket_->Connect(callback_.callback()));
  1152. }
  1153. int WriteAndWait(base::StringPiece request) {
  1154. scoped_refptr<IOBuffer> request_buffer =
  1155. base::MakeRefCounted<IOBuffer>(request.size());
  1156. memcpy(request_buffer->data(), request.data(), request.size());
  1157. return callback_.GetResult(
  1158. ssl_socket_->Write(request_buffer.get(), request.size(),
  1159. callback_.callback(), TRAFFIC_ANNOTATION_FOR_TESTS));
  1160. }
  1161. int ReadAndWait(IOBuffer* buf, size_t len) {
  1162. return callback_.GetResult(
  1163. ssl_socket_->Read(buf, len, callback_.callback()));
  1164. }
  1165. bool GetSSLInfo(SSLInfo* ssl_info) {
  1166. return ssl_socket_->GetSSLInfo(ssl_info);
  1167. }
  1168. bool RunInitialConnection() {
  1169. if (MakeClient(true) == nullptr)
  1170. return false;
  1171. EXPECT_THAT(Connect(), IsOk());
  1172. // Use the socket for an HTTP request to ensure we've processed the
  1173. // post-handshake TLS 1.3 ticket.
  1174. EXPECT_THAT(MakeHTTPRequest(ssl_socket_.get()), IsOk());
  1175. SSLInfo ssl_info;
  1176. EXPECT_TRUE(GetSSLInfo(&ssl_info));
  1177. // Make sure all asynchronous histogram logging is complete.
  1178. base::RunLoop().RunUntilIdle();
  1179. return SSLInfo::HANDSHAKE_FULL == ssl_info.handshake_type;
  1180. }
  1181. SSLClientSocket* ssl_socket() { return ssl_socket_.get(); }
  1182. private:
  1183. TestCompletionCallback callback_;
  1184. std::unique_ptr<StreamSocket> real_transport_;
  1185. std::unique_ptr<SSLClientSocket> ssl_socket_;
  1186. };
  1187. // Returns a serialized unencrypted TLS 1.2 alert record for the given alert
  1188. // value.
  1189. std::string FormatTLS12Alert(uint8_t alert) {
  1190. std::string ret;
  1191. // ContentType.alert
  1192. ret.push_back(21);
  1193. // Record-layer version. Assume TLS 1.2.
  1194. ret.push_back(0x03);
  1195. ret.push_back(0x03);
  1196. // Record length.
  1197. ret.push_back(0);
  1198. ret.push_back(2);
  1199. // AlertLevel.fatal.
  1200. ret.push_back(2);
  1201. // The alert itself.
  1202. ret.push_back(alert);
  1203. return ret;
  1204. }
  1205. // A CertVerifier that never returns on any requests.
  1206. class HangingCertVerifier : public CertVerifier {
  1207. public:
  1208. int num_active_requests() const { return num_active_requests_; }
  1209. void WaitForRequest() {
  1210. if (!num_active_requests_) {
  1211. run_loop_.Run();
  1212. }
  1213. }
  1214. int Verify(const RequestParams& params,
  1215. CertVerifyResult* verify_result,
  1216. CompletionOnceCallback callback,
  1217. std::unique_ptr<Request>* out_req,
  1218. const NetLogWithSource& net_log) override {
  1219. *out_req = std::make_unique<HangingRequest>(this);
  1220. return ERR_IO_PENDING;
  1221. }
  1222. void SetConfig(const Config& config) override {}
  1223. private:
  1224. class HangingRequest : public Request {
  1225. public:
  1226. explicit HangingRequest(HangingCertVerifier* verifier)
  1227. : verifier_(verifier) {
  1228. verifier_->num_active_requests_++;
  1229. verifier_->run_loop_.Quit();
  1230. }
  1231. ~HangingRequest() override { verifier_->num_active_requests_--; }
  1232. private:
  1233. raw_ptr<HangingCertVerifier> verifier_;
  1234. };
  1235. base::RunLoop run_loop_;
  1236. int num_active_requests_ = 0;
  1237. };
  1238. } // namespace
  1239. INSTANTIATE_TEST_SUITE_P(TLSVersion,
  1240. SSLClientSocketVersionTest,
  1241. ValuesIn(GetTLSVersions()));
  1242. TEST_P(SSLClientSocketVersionTest, Connect) {
  1243. ASSERT_TRUE(
  1244. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, GetServerConfig()));
  1245. TestCompletionCallback callback;
  1246. auto transport = std::make_unique<TCPClientSocket>(
  1247. addr(), nullptr, nullptr, NetLog::Get(), NetLogSource());
  1248. int rv = callback.GetResult(transport->Connect(callback.callback()));
  1249. EXPECT_THAT(rv, IsOk());
  1250. std::unique_ptr<SSLClientSocket> sock(CreateSSLClientSocket(
  1251. std::move(transport), host_port_pair(), SSLConfig()));
  1252. EXPECT_FALSE(sock->IsConnected());
  1253. rv = sock->Connect(callback.callback());
  1254. auto entries = log_observer_.GetEntries();
  1255. EXPECT_TRUE(LogContainsBeginEvent(entries, 5, NetLogEventType::SSL_CONNECT));
  1256. if (rv == ERR_IO_PENDING)
  1257. rv = callback.WaitForResult();
  1258. EXPECT_THAT(rv, IsOk());
  1259. EXPECT_TRUE(sock->IsConnected());
  1260. entries = log_observer_.GetEntries();
  1261. EXPECT_TRUE(LogContainsEndEvent(entries, -1, NetLogEventType::SSL_CONNECT));
  1262. sock->Disconnect();
  1263. EXPECT_FALSE(sock->IsConnected());
  1264. }
  1265. TEST_P(SSLClientSocketVersionTest, ConnectSyncVerify) {
  1266. ASSERT_TRUE(
  1267. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, GetServerConfig()));
  1268. cert_verifier_->set_async(false);
  1269. int rv;
  1270. ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
  1271. EXPECT_THAT(rv, IsError(OK));
  1272. }
  1273. TEST_P(SSLClientSocketVersionTest, ConnectExpired) {
  1274. ASSERT_TRUE(StartEmbeddedTestServer(EmbeddedTestServer::CERT_EXPIRED,
  1275. GetServerConfig()));
  1276. cert_verifier_->set_default_result(ERR_CERT_DATE_INVALID);
  1277. int rv;
  1278. ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
  1279. EXPECT_THAT(rv, IsError(ERR_CERT_DATE_INVALID));
  1280. // Rather than testing whether or not the underlying socket is connected,
  1281. // test that the handshake has finished. This is because it may be
  1282. // desirable to disconnect the socket before showing a user prompt, since
  1283. // the user may take indefinitely long to respond.
  1284. auto entries = log_observer_.GetEntries();
  1285. EXPECT_TRUE(LogContainsEndEvent(entries, -1, NetLogEventType::SSL_CONNECT));
  1286. }
  1287. TEST_P(SSLClientSocketVersionTest, ConnectExpiredSyncVerify) {
  1288. ASSERT_TRUE(StartEmbeddedTestServer(EmbeddedTestServer::CERT_EXPIRED,
  1289. GetServerConfig()));
  1290. cert_verifier_->set_default_result(ERR_CERT_DATE_INVALID);
  1291. cert_verifier_->set_async(false);
  1292. int rv;
  1293. ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
  1294. EXPECT_THAT(rv, IsError(ERR_CERT_DATE_INVALID));
  1295. }
  1296. // Test that SSLClientSockets may be destroyed while waiting on a certificate
  1297. // verification.
  1298. TEST_P(SSLClientSocketVersionTest, SocketDestroyedDuringVerify) {
  1299. ASSERT_TRUE(
  1300. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, GetServerConfig()));
  1301. HangingCertVerifier verifier;
  1302. context_ = std::make_unique<SSLClientContext>(
  1303. ssl_config_service_.get(), &verifier, transport_security_state_.get(),
  1304. ct_policy_enforcer_.get(), ssl_client_session_cache_.get(), nullptr);
  1305. TestCompletionCallback callback;
  1306. auto transport = std::make_unique<TCPClientSocket>(
  1307. addr(), nullptr, nullptr, NetLog::Get(), NetLogSource());
  1308. int rv = callback.GetResult(transport->Connect(callback.callback()));
  1309. ASSERT_THAT(rv, IsOk());
  1310. std::unique_ptr<SSLClientSocket> sock = CreateSSLClientSocket(
  1311. std::move(transport), host_port_pair(), SSLConfig());
  1312. rv = sock->Connect(callback.callback());
  1313. EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
  1314. // The socket should attempt a certificate verification.
  1315. verifier.WaitForRequest();
  1316. EXPECT_EQ(1, verifier.num_active_requests());
  1317. // Destroying the socket should cancel it.
  1318. sock = nullptr;
  1319. EXPECT_EQ(0, verifier.num_active_requests());
  1320. context_ = nullptr;
  1321. }
  1322. TEST_P(SSLClientSocketVersionTest, ConnectMismatched) {
  1323. ASSERT_TRUE(StartEmbeddedTestServer(EmbeddedTestServer::CERT_MISMATCHED_NAME,
  1324. GetServerConfig()));
  1325. cert_verifier_->set_default_result(ERR_CERT_COMMON_NAME_INVALID);
  1326. int rv;
  1327. ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
  1328. EXPECT_THAT(rv, IsError(ERR_CERT_COMMON_NAME_INVALID));
  1329. // Rather than testing whether or not the underlying socket is connected,
  1330. // test that the handshake has finished. This is because it may be
  1331. // desirable to disconnect the socket before showing a user prompt, since
  1332. // the user may take indefinitely long to respond.
  1333. auto entries = log_observer_.GetEntries();
  1334. EXPECT_TRUE(LogContainsEndEvent(entries, -1, NetLogEventType::SSL_CONNECT));
  1335. }
  1336. // Tests that certificates parsable by SSLClientSocket's internal SSL
  1337. // implementation, but not X509Certificate are treated as fatal connection
  1338. // errors. This is a regression test for https://crbug.com/91341.
  1339. TEST_P(SSLClientSocketVersionTest, ConnectBadValidity) {
  1340. ASSERT_TRUE(StartEmbeddedTestServer(EmbeddedTestServer::CERT_BAD_VALIDITY,
  1341. GetServerConfig()));
  1342. cert_verifier_->set_default_result(ERR_CERT_DATE_INVALID);
  1343. SSLConfig ssl_config;
  1344. int rv;
  1345. ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
  1346. EXPECT_THAT(rv, IsError(ERR_CERT_DATE_INVALID));
  1347. }
  1348. // Ignoring the certificate error from an invalid certificate should
  1349. // allow a complete connection.
  1350. TEST_P(SSLClientSocketVersionTest, ConnectBadValidityIgnoreCertErrors) {
  1351. ASSERT_TRUE(StartEmbeddedTestServer(EmbeddedTestServer::CERT_BAD_VALIDITY,
  1352. GetServerConfig()));
  1353. cert_verifier_->set_default_result(ERR_CERT_DATE_INVALID);
  1354. SSLConfig ssl_config;
  1355. ssl_config.ignore_certificate_errors = true;
  1356. int rv;
  1357. CreateAndConnectSSLClientSocket(ssl_config, &rv);
  1358. EXPECT_THAT(rv, IsOk());
  1359. EXPECT_TRUE(sock_->IsConnected());
  1360. }
  1361. // Attempt to connect to a page which requests a client certificate. It should
  1362. // return an error code on connect.
  1363. TEST_P(SSLClientSocketVersionTest, ConnectClientAuthCertRequested) {
  1364. SSLServerConfig server_config = GetServerConfig();
  1365. server_config.client_cert_type = SSLServerConfig::OPTIONAL_CLIENT_CERT;
  1366. ASSERT_TRUE(
  1367. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  1368. int rv;
  1369. ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
  1370. EXPECT_THAT(rv, IsError(ERR_SSL_CLIENT_AUTH_CERT_NEEDED));
  1371. auto entries = log_observer_.GetEntries();
  1372. EXPECT_TRUE(LogContainsEndEvent(entries, -1, NetLogEventType::SSL_CONNECT));
  1373. EXPECT_FALSE(sock_->IsConnected());
  1374. }
  1375. // Connect to a server requesting optional client authentication. Send it a
  1376. // null certificate. It should allow the connection.
  1377. TEST_P(SSLClientSocketVersionTest, ConnectClientAuthSendNullCert) {
  1378. SSLServerConfig server_config = GetServerConfig();
  1379. server_config.client_cert_type = SSLServerConfig::OPTIONAL_CLIENT_CERT;
  1380. ASSERT_TRUE(
  1381. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  1382. // Our test server accepts certificate-less connections.
  1383. context_->SetClientCertificate(host_port_pair(), nullptr, nullptr);
  1384. int rv;
  1385. ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
  1386. EXPECT_THAT(rv, IsOk());
  1387. // We responded to the server's certificate request with a Certificate
  1388. // message with no client certificate in it. ssl_info.client_cert_sent
  1389. // should be false in this case.
  1390. SSLInfo ssl_info;
  1391. sock_->GetSSLInfo(&ssl_info);
  1392. EXPECT_FALSE(ssl_info.client_cert_sent);
  1393. sock_->Disconnect();
  1394. EXPECT_FALSE(sock_->IsConnected());
  1395. }
  1396. // TODO(wtc): Add unit tests for IsConnectedAndIdle:
  1397. // - Server closes an SSL connection (with a close_notify alert message).
  1398. // - Server closes the underlying TCP connection directly.
  1399. // - Server sends data unexpectedly.
  1400. // Tests that the socket can be read from successfully. Also test that a peer's
  1401. // close_notify alert is successfully processed without error.
  1402. TEST_P(SSLClientSocketReadTest, Read) {
  1403. ASSERT_TRUE(
  1404. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, GetServerConfig()));
  1405. TestCompletionCallback callback;
  1406. auto transport = std::make_unique<TCPClientSocket>(addr(), nullptr, nullptr,
  1407. nullptr, NetLogSource());
  1408. EXPECT_EQ(0, transport->GetTotalReceivedBytes());
  1409. int rv = callback.GetResult(transport->Connect(callback.callback()));
  1410. EXPECT_THAT(rv, IsOk());
  1411. std::unique_ptr<SSLClientSocket> sock(CreateSSLClientSocket(
  1412. std::move(transport), host_port_pair(), SSLConfig()));
  1413. EXPECT_EQ(0, sock->GetTotalReceivedBytes());
  1414. rv = callback.GetResult(sock->Connect(callback.callback()));
  1415. EXPECT_THAT(rv, IsOk());
  1416. // Number of network bytes received should increase because of SSL socket
  1417. // establishment.
  1418. EXPECT_GT(sock->GetTotalReceivedBytes(), 0);
  1419. const char request_text[] = "GET / HTTP/1.0\r\n\r\n";
  1420. scoped_refptr<IOBuffer> request_buffer =
  1421. base::MakeRefCounted<IOBuffer>(std::size(request_text) - 1);
  1422. memcpy(request_buffer->data(), request_text, std::size(request_text) - 1);
  1423. rv = callback.GetResult(
  1424. sock->Write(request_buffer.get(), std::size(request_text) - 1,
  1425. callback.callback(), TRAFFIC_ANNOTATION_FOR_TESTS));
  1426. EXPECT_EQ(static_cast<int>(std::size(request_text) - 1), rv);
  1427. scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(4096);
  1428. int64_t unencrypted_bytes_read = 0;
  1429. int64_t network_bytes_read_during_handshake = sock->GetTotalReceivedBytes();
  1430. do {
  1431. rv = ReadAndWaitForCompletion(sock.get(), buf.get(), 4096);
  1432. EXPECT_GE(rv, 0);
  1433. if (rv >= 0) {
  1434. unencrypted_bytes_read += rv;
  1435. }
  1436. } while (rv > 0);
  1437. EXPECT_GT(unencrypted_bytes_read, 0);
  1438. // Reading the payload should increase the number of bytes on network layer.
  1439. EXPECT_GT(sock->GetTotalReceivedBytes(), network_bytes_read_during_handshake);
  1440. // Number of bytes received on the network after the handshake should be
  1441. // higher than the number of encrypted bytes read.
  1442. EXPECT_GE(sock->GetTotalReceivedBytes() - network_bytes_read_during_handshake,
  1443. unencrypted_bytes_read);
  1444. // The peer should have cleanly closed the connection with a close_notify.
  1445. EXPECT_EQ(0, rv);
  1446. }
  1447. // Tests that SSLClientSocket properly handles when the underlying transport
  1448. // synchronously fails a transport write in during the handshake.
  1449. TEST_F(SSLClientSocketTest, Connect_WithSynchronousError) {
  1450. ASSERT_TRUE(
  1451. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, SSLServerConfig()));
  1452. TestCompletionCallback callback;
  1453. auto real_transport = std::make_unique<TCPClientSocket>(
  1454. addr(), nullptr, nullptr, nullptr, NetLogSource());
  1455. auto transport =
  1456. std::make_unique<SynchronousErrorStreamSocket>(std::move(real_transport));
  1457. int rv = callback.GetResult(transport->Connect(callback.callback()));
  1458. EXPECT_THAT(rv, IsOk());
  1459. SynchronousErrorStreamSocket* raw_transport = transport.get();
  1460. std::unique_ptr<SSLClientSocket> sock(CreateSSLClientSocket(
  1461. std::move(transport), host_port_pair(), SSLConfig()));
  1462. raw_transport->SetNextWriteError(ERR_CONNECTION_RESET);
  1463. rv = callback.GetResult(sock->Connect(callback.callback()));
  1464. EXPECT_THAT(rv, IsError(ERR_CONNECTION_RESET));
  1465. EXPECT_FALSE(sock->IsConnected());
  1466. }
  1467. // Tests that the SSLClientSocket properly handles when the underlying transport
  1468. // synchronously returns an error code - such as if an intermediary terminates
  1469. // the socket connection uncleanly.
  1470. // This is a regression test for http://crbug.com/238536
  1471. TEST_P(SSLClientSocketReadTest, Read_WithSynchronousError) {
  1472. ASSERT_TRUE(
  1473. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, GetServerConfig()));
  1474. TestCompletionCallback callback;
  1475. auto real_transport = std::make_unique<TCPClientSocket>(
  1476. addr(), nullptr, nullptr, nullptr, NetLogSource());
  1477. auto transport =
  1478. std::make_unique<SynchronousErrorStreamSocket>(std::move(real_transport));
  1479. int rv = callback.GetResult(transport->Connect(callback.callback()));
  1480. EXPECT_THAT(rv, IsOk());
  1481. SSLConfig config;
  1482. config.disable_post_handshake_peek_for_testing = true;
  1483. SynchronousErrorStreamSocket* raw_transport = transport.get();
  1484. std::unique_ptr<SSLClientSocket> sock(
  1485. CreateSSLClientSocket(std::move(transport), host_port_pair(), config));
  1486. rv = callback.GetResult(sock->Connect(callback.callback()));
  1487. EXPECT_THAT(rv, IsOk());
  1488. EXPECT_TRUE(sock->IsConnected());
  1489. const char request_text[] = "GET / HTTP/1.0\r\n\r\n";
  1490. static const int kRequestTextSize =
  1491. static_cast<int>(std::size(request_text) - 1);
  1492. scoped_refptr<IOBuffer> request_buffer =
  1493. base::MakeRefCounted<IOBuffer>(kRequestTextSize);
  1494. memcpy(request_buffer->data(), request_text, kRequestTextSize);
  1495. rv = callback.GetResult(sock->Write(request_buffer.get(), kRequestTextSize,
  1496. callback.callback(),
  1497. TRAFFIC_ANNOTATION_FOR_TESTS));
  1498. EXPECT_EQ(kRequestTextSize, rv);
  1499. // Simulate an unclean/forcible shutdown.
  1500. raw_transport->SetNextReadError(ERR_CONNECTION_RESET);
  1501. scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(4096);
  1502. // Note: This test will hang if this bug has regressed. Simply checking that
  1503. // rv != ERR_IO_PENDING is insufficient, as ERR_IO_PENDING is a legitimate
  1504. // result when using a dedicated task runner for NSS.
  1505. rv = ReadAndWaitForCompletion(sock.get(), buf.get(), 4096);
  1506. EXPECT_THAT(rv, IsError(ERR_CONNECTION_RESET));
  1507. }
  1508. // Tests that the SSLClientSocket properly handles when the underlying transport
  1509. // asynchronously returns an error code while writing data - such as if an
  1510. // intermediary terminates the socket connection uncleanly.
  1511. // This is a regression test for http://crbug.com/249848
  1512. TEST_P(SSLClientSocketVersionTest, Write_WithSynchronousError) {
  1513. ASSERT_TRUE(
  1514. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, GetServerConfig()));
  1515. TestCompletionCallback callback;
  1516. auto real_transport = std::make_unique<TCPClientSocket>(
  1517. addr(), nullptr, nullptr, nullptr, NetLogSource());
  1518. // Note: |error_socket|'s ownership is handed to |transport|, but a pointer
  1519. // is retained in order to configure additional errors.
  1520. auto error_socket =
  1521. std::make_unique<SynchronousErrorStreamSocket>(std::move(real_transport));
  1522. SynchronousErrorStreamSocket* raw_error_socket = error_socket.get();
  1523. auto transport =
  1524. std::make_unique<FakeBlockingStreamSocket>(std::move(error_socket));
  1525. FakeBlockingStreamSocket* raw_transport = transport.get();
  1526. int rv = callback.GetResult(transport->Connect(callback.callback()));
  1527. EXPECT_THAT(rv, IsOk());
  1528. std::unique_ptr<SSLClientSocket> sock(CreateSSLClientSocket(
  1529. std::move(transport), host_port_pair(), SSLConfig()));
  1530. rv = callback.GetResult(sock->Connect(callback.callback()));
  1531. EXPECT_THAT(rv, IsOk());
  1532. EXPECT_TRUE(sock->IsConnected());
  1533. const char request_text[] = "GET / HTTP/1.0\r\n\r\n";
  1534. static const int kRequestTextSize =
  1535. static_cast<int>(std::size(request_text) - 1);
  1536. scoped_refptr<IOBuffer> request_buffer =
  1537. base::MakeRefCounted<IOBuffer>(kRequestTextSize);
  1538. memcpy(request_buffer->data(), request_text, kRequestTextSize);
  1539. // Simulate an unclean/forcible shutdown on the underlying socket.
  1540. // However, simulate this error asynchronously.
  1541. raw_error_socket->SetNextWriteError(ERR_CONNECTION_RESET);
  1542. raw_transport->BlockWrite();
  1543. // This write should complete synchronously, because the TLS ciphertext
  1544. // can be created and placed into the outgoing buffers independent of the
  1545. // underlying transport.
  1546. rv = callback.GetResult(sock->Write(request_buffer.get(), kRequestTextSize,
  1547. callback.callback(),
  1548. TRAFFIC_ANNOTATION_FOR_TESTS));
  1549. EXPECT_EQ(kRequestTextSize, rv);
  1550. scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(4096);
  1551. rv = sock->Read(buf.get(), 4096, callback.callback());
  1552. EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
  1553. // Now unblock the outgoing request, having it fail with the connection
  1554. // being reset.
  1555. raw_transport->UnblockWrite();
  1556. // Note: This will cause an inifite loop if this bug has regressed. Simply
  1557. // checking that rv != ERR_IO_PENDING is insufficient, as ERR_IO_PENDING
  1558. // is a legitimate result when using a dedicated task runner for NSS.
  1559. rv = callback.GetResult(rv);
  1560. EXPECT_THAT(rv, IsError(ERR_CONNECTION_RESET));
  1561. }
  1562. // If there is a Write failure at the transport with no follow-up Read, although
  1563. // the write error will not be returned to the client until a future Read or
  1564. // Write operation, SSLClientSocket should not spin attempting to re-write on
  1565. // the socket. This is a regression test for part of https://crbug.com/381160.
  1566. TEST_P(SSLClientSocketVersionTest, Write_WithSynchronousErrorNoRead) {
  1567. ASSERT_TRUE(
  1568. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, SSLServerConfig()));
  1569. TestCompletionCallback callback;
  1570. auto real_transport = std::make_unique<TCPClientSocket>(
  1571. addr(), nullptr, nullptr, nullptr, NetLogSource());
  1572. // Note: intermediate sockets' ownership are handed to |sock|, but a pointer
  1573. // is retained in order to query them.
  1574. auto error_socket =
  1575. std::make_unique<SynchronousErrorStreamSocket>(std::move(real_transport));
  1576. SynchronousErrorStreamSocket* raw_error_socket = error_socket.get();
  1577. auto counting_socket =
  1578. std::make_unique<CountingStreamSocket>(std::move(error_socket));
  1579. CountingStreamSocket* raw_counting_socket = counting_socket.get();
  1580. int rv = callback.GetResult(counting_socket->Connect(callback.callback()));
  1581. ASSERT_THAT(rv, IsOk());
  1582. std::unique_ptr<SSLClientSocket> sock(CreateSSLClientSocket(
  1583. std::move(counting_socket), host_port_pair(), SSLConfig()));
  1584. rv = callback.GetResult(sock->Connect(callback.callback()));
  1585. ASSERT_THAT(rv, IsOk());
  1586. ASSERT_TRUE(sock->IsConnected());
  1587. // Simulate an unclean/forcible shutdown on the underlying socket.
  1588. raw_error_socket->SetNextWriteError(ERR_CONNECTION_RESET);
  1589. const char request_text[] = "GET / HTTP/1.0\r\n\r\n";
  1590. static const int kRequestTextSize =
  1591. static_cast<int>(std::size(request_text) - 1);
  1592. scoped_refptr<IOBuffer> request_buffer =
  1593. base::MakeRefCounted<IOBuffer>(kRequestTextSize);
  1594. memcpy(request_buffer->data(), request_text, kRequestTextSize);
  1595. // This write should complete synchronously, because the TLS ciphertext
  1596. // can be created and placed into the outgoing buffers independent of the
  1597. // underlying transport.
  1598. rv = callback.GetResult(sock->Write(request_buffer.get(), kRequestTextSize,
  1599. callback.callback(),
  1600. TRAFFIC_ANNOTATION_FOR_TESTS));
  1601. ASSERT_EQ(kRequestTextSize, rv);
  1602. // Let the event loop spin for a little bit of time. Even on platforms where
  1603. // pumping the state machine involve thread hops, there should be no further
  1604. // writes on the transport socket.
  1605. //
  1606. // TODO(davidben): Avoid the arbitrary timeout?
  1607. int old_write_count = raw_counting_socket->write_count();
  1608. base::RunLoop loop;
  1609. base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
  1610. FROM_HERE, loop.QuitClosure(), base::Milliseconds(100));
  1611. loop.Run();
  1612. EXPECT_EQ(old_write_count, raw_counting_socket->write_count());
  1613. }
  1614. // Test the full duplex mode, with Read and Write pending at the same time.
  1615. // This test also serves as a regression test for http://crbug.com/29815.
  1616. TEST_P(SSLClientSocketReadTest, Read_FullDuplex) {
  1617. ASSERT_TRUE(
  1618. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, GetServerConfig()));
  1619. int rv;
  1620. ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
  1621. EXPECT_THAT(rv, IsOk());
  1622. // Issue a "hanging" Read first.
  1623. TestCompletionCallback callback;
  1624. scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(4096);
  1625. int read_rv = Read(sock_.get(), buf.get(), 4096, callback.callback());
  1626. // We haven't written the request, so there should be no response yet.
  1627. ASSERT_THAT(read_rv, IsError(ERR_IO_PENDING));
  1628. // Write the request.
  1629. // The request is padded with a User-Agent header to a size that causes the
  1630. // memio circular buffer (4k bytes) in SSLClientSocketNSS to wrap around.
  1631. // This tests the fix for http://crbug.com/29815.
  1632. std::string request_text = "GET / HTTP/1.1\r\nUser-Agent: long browser name ";
  1633. for (int i = 0; i < 3770; ++i)
  1634. request_text.push_back('*');
  1635. request_text.append("\r\n\r\n");
  1636. scoped_refptr<IOBuffer> request_buffer =
  1637. base::MakeRefCounted<StringIOBuffer>(request_text);
  1638. TestCompletionCallback callback2; // Used for Write only.
  1639. rv = callback2.GetResult(
  1640. sock_->Write(request_buffer.get(), request_text.size(),
  1641. callback2.callback(), TRAFFIC_ANNOTATION_FOR_TESTS));
  1642. EXPECT_EQ(static_cast<int>(request_text.size()), rv);
  1643. // Now get the Read result.
  1644. read_rv =
  1645. WaitForReadCompletion(sock_.get(), buf.get(), 4096, &callback, read_rv);
  1646. EXPECT_GT(read_rv, 0);
  1647. }
  1648. // Attempts to Read() and Write() from an SSLClientSocketNSS in full duplex
  1649. // mode when the underlying transport is blocked on sending data. When the
  1650. // underlying transport completes due to an error, it should invoke both the
  1651. // Read() and Write() callbacks. If the socket is deleted by the Read()
  1652. // callback, the Write() callback should not be invoked.
  1653. // Regression test for http://crbug.com/232633
  1654. TEST_P(SSLClientSocketReadTest, Read_DeleteWhilePendingFullDuplex) {
  1655. ASSERT_TRUE(
  1656. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, GetServerConfig()));
  1657. TestCompletionCallback callback;
  1658. auto real_transport = std::make_unique<TCPClientSocket>(
  1659. addr(), nullptr, nullptr, nullptr, NetLogSource());
  1660. // Note: |error_socket|'s ownership is handed to |transport|, but a pointer
  1661. // is retained in order to configure additional errors.
  1662. auto error_socket =
  1663. std::make_unique<SynchronousErrorStreamSocket>(std::move(real_transport));
  1664. SynchronousErrorStreamSocket* raw_error_socket = error_socket.get();
  1665. auto transport =
  1666. std::make_unique<FakeBlockingStreamSocket>(std::move(error_socket));
  1667. FakeBlockingStreamSocket* raw_transport = transport.get();
  1668. int rv = callback.GetResult(transport->Connect(callback.callback()));
  1669. EXPECT_THAT(rv, IsOk());
  1670. SSLConfig config;
  1671. config.disable_post_handshake_peek_for_testing = true;
  1672. std::unique_ptr<SSLClientSocket> sock =
  1673. CreateSSLClientSocket(std::move(transport), host_port_pair(), config);
  1674. rv = callback.GetResult(sock->Connect(callback.callback()));
  1675. EXPECT_THAT(rv, IsOk());
  1676. EXPECT_TRUE(sock->IsConnected());
  1677. std::string request_text = "GET / HTTP/1.1\r\nUser-Agent: long browser name ";
  1678. request_text.append(20 * 1024, '*');
  1679. request_text.append("\r\n\r\n");
  1680. scoped_refptr<DrainableIOBuffer> request_buffer =
  1681. base::MakeRefCounted<DrainableIOBuffer>(
  1682. base::MakeRefCounted<StringIOBuffer>(request_text),
  1683. request_text.size());
  1684. // Simulate errors being returned from the underlying Read() and Write() ...
  1685. raw_error_socket->SetNextReadError(ERR_CONNECTION_RESET);
  1686. raw_error_socket->SetNextWriteError(ERR_CONNECTION_RESET);
  1687. // ... but have those errors returned asynchronously. Because the Write() will
  1688. // return first, this will trigger the error.
  1689. raw_transport->BlockReadResult();
  1690. raw_transport->BlockWrite();
  1691. // Enqueue a Read() before calling Write(), which should "hang" due to
  1692. // the ERR_IO_PENDING caused by SetReadShouldBlock() and thus return.
  1693. SSLClientSocket* raw_sock = sock.get();
  1694. DeleteSocketCallback read_callback(sock.release());
  1695. scoped_refptr<IOBuffer> read_buf = base::MakeRefCounted<IOBuffer>(4096);
  1696. rv = Read(raw_sock, read_buf.get(), 4096, read_callback.callback());
  1697. // Ensure things didn't complete synchronously, otherwise |sock| is invalid.
  1698. ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
  1699. ASSERT_FALSE(read_callback.have_result());
  1700. // Attempt to write the remaining data. OpenSSL will return that its blocked
  1701. // because the underlying transport is blocked.
  1702. rv = raw_sock->Write(request_buffer.get(), request_buffer->BytesRemaining(),
  1703. callback.callback(), TRAFFIC_ANNOTATION_FOR_TESTS);
  1704. ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
  1705. ASSERT_FALSE(callback.have_result());
  1706. // Now unblock Write(), which will invoke OnSendComplete and (eventually)
  1707. // call the Read() callback, deleting the socket and thus aborting calling
  1708. // the Write() callback.
  1709. raw_transport->UnblockWrite();
  1710. // |read_callback| deletes |sock| so if ReadIfReady() is used, we will get OK
  1711. // asynchronously but can't continue reading because the socket is gone.
  1712. rv = read_callback.WaitForResult();
  1713. if (test_ssl_read_if_ready()) {
  1714. EXPECT_THAT(rv, IsOk());
  1715. } else {
  1716. EXPECT_THAT(rv, IsError(ERR_CONNECTION_RESET));
  1717. }
  1718. // The Write callback should not have been called.
  1719. EXPECT_FALSE(callback.have_result());
  1720. }
  1721. // Tests that the SSLClientSocket does not crash if data is received on the
  1722. // transport socket after a failing write. This can occur if we have a Write
  1723. // error in a SPDY socket.
  1724. // Regression test for http://crbug.com/335557
  1725. TEST_P(SSLClientSocketReadTest, Read_WithWriteError) {
  1726. ASSERT_TRUE(
  1727. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, GetServerConfig()));
  1728. TestCompletionCallback callback;
  1729. auto real_transport = std::make_unique<TCPClientSocket>(
  1730. addr(), nullptr, nullptr, nullptr, NetLogSource());
  1731. // Note: |error_socket|'s ownership is handed to |transport|, but a pointer
  1732. // is retained in order to configure additional errors.
  1733. auto error_socket =
  1734. std::make_unique<SynchronousErrorStreamSocket>(std::move(real_transport));
  1735. SynchronousErrorStreamSocket* raw_error_socket = error_socket.get();
  1736. auto transport =
  1737. std::make_unique<FakeBlockingStreamSocket>(std::move(error_socket));
  1738. FakeBlockingStreamSocket* raw_transport = transport.get();
  1739. int rv = callback.GetResult(transport->Connect(callback.callback()));
  1740. EXPECT_THAT(rv, IsOk());
  1741. std::unique_ptr<SSLClientSocket> sock(CreateSSLClientSocket(
  1742. std::move(transport), host_port_pair(), SSLConfig()));
  1743. rv = callback.GetResult(sock->Connect(callback.callback()));
  1744. EXPECT_THAT(rv, IsOk());
  1745. EXPECT_TRUE(sock->IsConnected());
  1746. // Send a request so there is something to read from the socket.
  1747. const char request_text[] = "GET / HTTP/1.0\r\n\r\n";
  1748. static const int kRequestTextSize =
  1749. static_cast<int>(std::size(request_text) - 1);
  1750. scoped_refptr<IOBuffer> request_buffer =
  1751. base::MakeRefCounted<IOBuffer>(kRequestTextSize);
  1752. memcpy(request_buffer->data(), request_text, kRequestTextSize);
  1753. rv = callback.GetResult(sock->Write(request_buffer.get(), kRequestTextSize,
  1754. callback.callback(),
  1755. TRAFFIC_ANNOTATION_FOR_TESTS));
  1756. EXPECT_EQ(kRequestTextSize, rv);
  1757. // Start a hanging read.
  1758. TestCompletionCallback read_callback;
  1759. raw_transport->BlockReadResult();
  1760. scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(4096);
  1761. rv = Read(sock.get(), buf.get(), 4096, read_callback.callback());
  1762. EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
  1763. // Perform another write, but have it fail. Write a request larger than the
  1764. // internal socket buffers so that the request hits the underlying transport
  1765. // socket and detects the error.
  1766. std::string long_request_text =
  1767. "GET / HTTP/1.1\r\nUser-Agent: long browser name ";
  1768. long_request_text.append(20 * 1024, '*');
  1769. long_request_text.append("\r\n\r\n");
  1770. scoped_refptr<DrainableIOBuffer> long_request_buffer =
  1771. base::MakeRefCounted<DrainableIOBuffer>(
  1772. base::MakeRefCounted<StringIOBuffer>(long_request_text),
  1773. long_request_text.size());
  1774. raw_error_socket->SetNextWriteError(ERR_CONNECTION_RESET);
  1775. // Write as much data as possible until hitting an error.
  1776. do {
  1777. rv = callback.GetResult(sock->Write(
  1778. long_request_buffer.get(), long_request_buffer->BytesRemaining(),
  1779. callback.callback(), TRAFFIC_ANNOTATION_FOR_TESTS));
  1780. if (rv > 0) {
  1781. long_request_buffer->DidConsume(rv);
  1782. // Abort if the entire input is ever consumed. The input is larger than
  1783. // the SSLClientSocket's write buffers.
  1784. ASSERT_LT(0, long_request_buffer->BytesRemaining());
  1785. }
  1786. } while (rv > 0);
  1787. EXPECT_THAT(rv, IsError(ERR_CONNECTION_RESET));
  1788. // At this point the Read result is available. Transport write errors are
  1789. // surfaced through Writes. See https://crbug.com/249848.
  1790. rv = WaitForReadCompletion(sock.get(), buf.get(), 4096, &read_callback, rv);
  1791. EXPECT_THAT(rv, IsError(ERR_CONNECTION_RESET));
  1792. // Release the read. This does not cause a crash.
  1793. raw_transport->UnblockReadResult();
  1794. base::RunLoop().RunUntilIdle();
  1795. }
  1796. // Tests that SSLClientSocket fails the handshake if the underlying
  1797. // transport is cleanly closed.
  1798. TEST_F(SSLClientSocketTest, Connect_WithZeroReturn) {
  1799. // There is no need to vary by TLS version because this test never reads a
  1800. // response from the server.
  1801. ASSERT_TRUE(
  1802. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, SSLServerConfig()));
  1803. TestCompletionCallback callback;
  1804. auto real_transport = std::make_unique<TCPClientSocket>(
  1805. addr(), nullptr, nullptr, nullptr, NetLogSource());
  1806. auto transport =
  1807. std::make_unique<SynchronousErrorStreamSocket>(std::move(real_transport));
  1808. int rv = callback.GetResult(transport->Connect(callback.callback()));
  1809. EXPECT_THAT(rv, IsOk());
  1810. SynchronousErrorStreamSocket* raw_transport = transport.get();
  1811. std::unique_ptr<SSLClientSocket> sock(CreateSSLClientSocket(
  1812. std::move(transport), host_port_pair(), SSLConfig()));
  1813. raw_transport->SetNextReadError(0);
  1814. rv = callback.GetResult(sock->Connect(callback.callback()));
  1815. EXPECT_THAT(rv, IsError(ERR_CONNECTION_CLOSED));
  1816. EXPECT_FALSE(sock->IsConnected());
  1817. }
  1818. // Tests that SSLClientSocket returns a Read of size 0 if the underlying socket
  1819. // is cleanly closed, but the peer does not send close_notify.
  1820. // This is a regression test for https://crbug.com/422246
  1821. TEST_P(SSLClientSocketReadTest, Read_WithZeroReturn) {
  1822. ASSERT_TRUE(
  1823. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, GetServerConfig()));
  1824. TestCompletionCallback callback;
  1825. auto real_transport = std::make_unique<TCPClientSocket>(
  1826. addr(), nullptr, nullptr, nullptr, NetLogSource());
  1827. auto transport =
  1828. std::make_unique<SynchronousErrorStreamSocket>(std::move(real_transport));
  1829. int rv = callback.GetResult(transport->Connect(callback.callback()));
  1830. EXPECT_THAT(rv, IsOk());
  1831. SSLConfig config;
  1832. config.disable_post_handshake_peek_for_testing = true;
  1833. SynchronousErrorStreamSocket* raw_transport = transport.get();
  1834. std::unique_ptr<SSLClientSocket> sock(
  1835. CreateSSLClientSocket(std::move(transport), host_port_pair(), config));
  1836. rv = callback.GetResult(sock->Connect(callback.callback()));
  1837. EXPECT_THAT(rv, IsOk());
  1838. EXPECT_TRUE(sock->IsConnected());
  1839. raw_transport->SetNextReadError(0);
  1840. scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(4096);
  1841. rv = ReadAndWaitForCompletion(sock.get(), buf.get(), 4096);
  1842. EXPECT_EQ(0, rv);
  1843. }
  1844. // Tests that SSLClientSocket cleanly returns a Read of size 0 if the
  1845. // underlying socket is cleanly closed asynchronously.
  1846. // This is a regression test for https://crbug.com/422246
  1847. TEST_P(SSLClientSocketReadTest, Read_WithAsyncZeroReturn) {
  1848. ASSERT_TRUE(
  1849. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, GetServerConfig()));
  1850. TestCompletionCallback callback;
  1851. auto real_transport = std::make_unique<TCPClientSocket>(
  1852. addr(), nullptr, nullptr, nullptr, NetLogSource());
  1853. auto error_socket =
  1854. std::make_unique<SynchronousErrorStreamSocket>(std::move(real_transport));
  1855. SynchronousErrorStreamSocket* raw_error_socket = error_socket.get();
  1856. auto transport =
  1857. std::make_unique<FakeBlockingStreamSocket>(std::move(error_socket));
  1858. FakeBlockingStreamSocket* raw_transport = transport.get();
  1859. int rv = callback.GetResult(transport->Connect(callback.callback()));
  1860. EXPECT_THAT(rv, IsOk());
  1861. SSLConfig config;
  1862. config.disable_post_handshake_peek_for_testing = true;
  1863. std::unique_ptr<SSLClientSocket> sock(
  1864. CreateSSLClientSocket(std::move(transport), host_port_pair(), config));
  1865. rv = callback.GetResult(sock->Connect(callback.callback()));
  1866. EXPECT_THAT(rv, IsOk());
  1867. EXPECT_TRUE(sock->IsConnected());
  1868. raw_error_socket->SetNextReadError(0);
  1869. raw_transport->BlockReadResult();
  1870. scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(4096);
  1871. TestCompletionCallback read_callback;
  1872. rv = Read(sock.get(), buf.get(), 4096, read_callback.callback());
  1873. EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
  1874. raw_transport->UnblockReadResult();
  1875. rv = WaitForReadCompletion(sock.get(), buf.get(), 4096, &read_callback, rv);
  1876. EXPECT_EQ(0, rv);
  1877. }
  1878. // Tests that fatal alerts from the peer are processed. This is a regression
  1879. // test for https://crbug.com/466303.
  1880. TEST_P(SSLClientSocketReadTest, Read_WithFatalAlert) {
  1881. SSLServerConfig server_config = GetServerConfig();
  1882. server_config.alert_after_handshake_for_testing = SSL_AD_INTERNAL_ERROR;
  1883. ASSERT_TRUE(
  1884. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  1885. int rv;
  1886. ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
  1887. EXPECT_THAT(rv, IsOk());
  1888. // Receive the fatal alert.
  1889. TestCompletionCallback callback;
  1890. scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(4096);
  1891. EXPECT_EQ(ERR_SSL_PROTOCOL_ERROR,
  1892. ReadAndWaitForCompletion(sock_.get(), buf.get(), 4096));
  1893. }
  1894. TEST_P(SSLClientSocketReadTest, Read_SmallChunks) {
  1895. ASSERT_TRUE(
  1896. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, GetServerConfig()));
  1897. int rv;
  1898. ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
  1899. EXPECT_THAT(rv, IsOk());
  1900. const char request_text[] = "GET / HTTP/1.0\r\n\r\n";
  1901. scoped_refptr<IOBuffer> request_buffer =
  1902. base::MakeRefCounted<IOBuffer>(std::size(request_text) - 1);
  1903. memcpy(request_buffer->data(), request_text, std::size(request_text) - 1);
  1904. TestCompletionCallback callback;
  1905. rv = callback.GetResult(
  1906. sock_->Write(request_buffer.get(), std::size(request_text) - 1,
  1907. callback.callback(), TRAFFIC_ANNOTATION_FOR_TESTS));
  1908. EXPECT_EQ(static_cast<int>(std::size(request_text) - 1), rv);
  1909. scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(1);
  1910. do {
  1911. rv = ReadAndWaitForCompletion(sock_.get(), buf.get(), 1);
  1912. EXPECT_GE(rv, 0);
  1913. } while (rv > 0);
  1914. }
  1915. TEST_P(SSLClientSocketReadTest, Read_ManySmallRecords) {
  1916. ASSERT_TRUE(
  1917. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, GetServerConfig()));
  1918. TestCompletionCallback callback;
  1919. auto real_transport = std::make_unique<TCPClientSocket>(
  1920. addr(), nullptr, nullptr, nullptr, NetLogSource());
  1921. auto transport =
  1922. std::make_unique<ReadBufferingStreamSocket>(std::move(real_transport));
  1923. ReadBufferingStreamSocket* raw_transport = transport.get();
  1924. int rv = callback.GetResult(transport->Connect(callback.callback()));
  1925. ASSERT_THAT(rv, IsOk());
  1926. SSLConfig config;
  1927. config.disable_post_handshake_peek_for_testing = true;
  1928. std::unique_ptr<SSLClientSocket> sock(
  1929. CreateSSLClientSocket(std::move(transport), host_port_pair(), config));
  1930. rv = callback.GetResult(sock->Connect(callback.callback()));
  1931. ASSERT_THAT(rv, IsOk());
  1932. ASSERT_TRUE(sock->IsConnected());
  1933. const char request_text[] = "GET /ssl-many-small-records HTTP/1.0\r\n\r\n";
  1934. scoped_refptr<IOBuffer> request_buffer =
  1935. base::MakeRefCounted<IOBuffer>(std::size(request_text) - 1);
  1936. memcpy(request_buffer->data(), request_text, std::size(request_text) - 1);
  1937. rv = callback.GetResult(
  1938. sock->Write(request_buffer.get(), std::size(request_text) - 1,
  1939. callback.callback(), TRAFFIC_ANNOTATION_FOR_TESTS));
  1940. ASSERT_GT(rv, 0);
  1941. ASSERT_EQ(static_cast<int>(std::size(request_text) - 1), rv);
  1942. // Note: This relies on SSLClientSocketNSS attempting to read up to 17K of
  1943. // data (the max SSL record size) at a time. Ensure that at least 15K worth
  1944. // of SSL data is buffered first. The 15K of buffered data is made up of
  1945. // many smaller SSL records (the TestServer writes along 1350 byte
  1946. // plaintext boundaries), although there may also be a few records that are
  1947. // smaller or larger, due to timing and SSL False Start.
  1948. // 15K was chosen because 15K is smaller than the 17K (max) read issued by
  1949. // the SSLClientSocket implementation, and larger than the minimum amount
  1950. // of ciphertext necessary to contain the 8K of plaintext requested below.
  1951. raw_transport->BufferNextRead(15000);
  1952. scoped_refptr<IOBuffer> buffer = base::MakeRefCounted<IOBuffer>(8192);
  1953. rv = ReadAndWaitForCompletion(sock.get(), buffer.get(), 8192);
  1954. ASSERT_EQ(rv, 8192);
  1955. }
  1956. TEST_P(SSLClientSocketReadTest, Read_Interrupted) {
  1957. ASSERT_TRUE(
  1958. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, GetServerConfig()));
  1959. int rv;
  1960. ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
  1961. EXPECT_THAT(rv, IsOk());
  1962. const char request_text[] = "GET / HTTP/1.0\r\n\r\n";
  1963. scoped_refptr<IOBuffer> request_buffer =
  1964. base::MakeRefCounted<IOBuffer>(std::size(request_text) - 1);
  1965. memcpy(request_buffer->data(), request_text, std::size(request_text) - 1);
  1966. TestCompletionCallback callback;
  1967. rv = callback.GetResult(
  1968. sock_->Write(request_buffer.get(), std::size(request_text) - 1,
  1969. callback.callback(), TRAFFIC_ANNOTATION_FOR_TESTS));
  1970. EXPECT_EQ(static_cast<int>(std::size(request_text) - 1), rv);
  1971. // Do a partial read and then exit. This test should not crash!
  1972. scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(512);
  1973. rv = ReadAndWaitForCompletion(sock_.get(), buf.get(), 512);
  1974. EXPECT_GT(rv, 0);
  1975. }
  1976. TEST_P(SSLClientSocketReadTest, Read_FullLogging) {
  1977. ASSERT_TRUE(
  1978. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, GetServerConfig()));
  1979. TestCompletionCallback callback;
  1980. log_observer_.SetObserverCaptureMode(NetLogCaptureMode::kEverything);
  1981. auto transport = std::make_unique<TCPClientSocket>(
  1982. addr(), nullptr, nullptr, NetLog::Get(), NetLogSource());
  1983. int rv = callback.GetResult(transport->Connect(callback.callback()));
  1984. EXPECT_THAT(rv, IsOk());
  1985. std::unique_ptr<SSLClientSocket> sock(CreateSSLClientSocket(
  1986. std::move(transport), host_port_pair(), SSLConfig()));
  1987. rv = callback.GetResult(sock->Connect(callback.callback()));
  1988. EXPECT_THAT(rv, IsOk());
  1989. EXPECT_TRUE(sock->IsConnected());
  1990. const char request_text[] = "GET / HTTP/1.0\r\n\r\n";
  1991. scoped_refptr<IOBuffer> request_buffer =
  1992. base::MakeRefCounted<IOBuffer>(std::size(request_text) - 1);
  1993. memcpy(request_buffer->data(), request_text, std::size(request_text) - 1);
  1994. rv = callback.GetResult(
  1995. sock->Write(request_buffer.get(), std::size(request_text) - 1,
  1996. callback.callback(), TRAFFIC_ANNOTATION_FOR_TESTS));
  1997. EXPECT_EQ(static_cast<int>(std::size(request_text) - 1), rv);
  1998. auto entries = log_observer_.GetEntries();
  1999. size_t last_index = ExpectLogContainsSomewhereAfter(
  2000. entries, 5, NetLogEventType::SSL_SOCKET_BYTES_SENT,
  2001. NetLogEventPhase::NONE);
  2002. scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(4096);
  2003. for (;;) {
  2004. rv = ReadAndWaitForCompletion(sock.get(), buf.get(), 4096);
  2005. EXPECT_GE(rv, 0);
  2006. if (rv <= 0)
  2007. break;
  2008. entries = log_observer_.GetEntries();
  2009. last_index = ExpectLogContainsSomewhereAfter(
  2010. entries, last_index + 1, NetLogEventType::SSL_SOCKET_BYTES_RECEIVED,
  2011. NetLogEventPhase::NONE);
  2012. }
  2013. }
  2014. // Regression test for http://crbug.com/42538
  2015. TEST_F(SSLClientSocketTest, PrematureApplicationData) {
  2016. ASSERT_TRUE(
  2017. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, SSLServerConfig()));
  2018. static const unsigned char application_data[] = {
  2019. 0x17, 0x03, 0x01, 0x00, 0x4a, 0x02, 0x00, 0x00, 0x46, 0x03, 0x01, 0x4b,
  2020. 0xc2, 0xf8, 0xb2, 0xc1, 0x56, 0x42, 0xb9, 0x57, 0x7f, 0xde, 0x87, 0x46,
  2021. 0xf7, 0xa3, 0x52, 0x42, 0x21, 0xf0, 0x13, 0x1c, 0x9c, 0x83, 0x88, 0xd6,
  2022. 0x93, 0x0c, 0xf6, 0x36, 0x30, 0x05, 0x7e, 0x20, 0xb5, 0xb5, 0x73, 0x36,
  2023. 0x53, 0x83, 0x0a, 0xfc, 0x17, 0x63, 0xbf, 0xa0, 0xe4, 0x42, 0x90, 0x0d,
  2024. 0x2f, 0x18, 0x6d, 0x20, 0xd8, 0x36, 0x3f, 0xfc, 0xe6, 0x01, 0xfa, 0x0f,
  2025. 0xa5, 0x75, 0x7f, 0x09, 0x00, 0x04, 0x00, 0x16, 0x03, 0x01, 0x11, 0x57,
  2026. 0x0b, 0x00, 0x11, 0x53, 0x00, 0x11, 0x50, 0x00, 0x06, 0x22, 0x30, 0x82,
  2027. 0x06, 0x1e, 0x30, 0x82, 0x05, 0x06, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02,
  2028. 0x0a};
  2029. // All reads and writes complete synchronously (async=false).
  2030. MockRead data_reads[] = {
  2031. MockRead(SYNCHRONOUS, reinterpret_cast<const char*>(application_data),
  2032. std::size(application_data)),
  2033. MockRead(SYNCHRONOUS, OK),
  2034. };
  2035. StaticSocketDataProvider data(data_reads, base::span<MockWrite>());
  2036. TestCompletionCallback callback;
  2037. std::unique_ptr<StreamSocket> transport(
  2038. std::make_unique<MockTCPClientSocket>(addr(), nullptr, &data));
  2039. int rv = callback.GetResult(transport->Connect(callback.callback()));
  2040. EXPECT_THAT(rv, IsOk());
  2041. std::unique_ptr<SSLClientSocket> sock(CreateSSLClientSocket(
  2042. std::move(transport), host_port_pair(), SSLConfig()));
  2043. rv = callback.GetResult(sock->Connect(callback.callback()));
  2044. EXPECT_THAT(rv, IsError(ERR_SSL_PROTOCOL_ERROR));
  2045. }
  2046. TEST_F(SSLClientSocketTest, CipherSuiteDisables) {
  2047. SSLServerConfig server_config;
  2048. server_config.version_max = SSL_PROTOCOL_VERSION_TLS1_2;
  2049. server_config.cipher_suite_for_testing = kModernTLS12Cipher;
  2050. ASSERT_TRUE(
  2051. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  2052. SSLContextConfig ssl_context_config;
  2053. ssl_context_config.disabled_cipher_suites.push_back(kModernTLS12Cipher);
  2054. ssl_config_service_->UpdateSSLConfigAndNotify(ssl_context_config);
  2055. int rv;
  2056. ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
  2057. EXPECT_THAT(rv, IsError(ERR_SSL_VERSION_OR_CIPHER_MISMATCH));
  2058. }
  2059. // Test that connecting to a server only supporting TLS 1.0 will fail and
  2060. // results in ERR_SSL_VERSION_OR_CIPHER_MISMATCH.
  2061. TEST_F(SSLClientSocketTest, TLS1_NotSupported) {
  2062. SSLServerConfig config;
  2063. config.version_max = SSL_PROTOCOL_VERSION_TLS1;
  2064. config.version_min = SSL_PROTOCOL_VERSION_TLS1;
  2065. ASSERT_TRUE(StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, config));
  2066. int rv;
  2067. ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
  2068. EXPECT_THAT(rv, IsError(ERR_SSL_VERSION_OR_CIPHER_MISMATCH));
  2069. }
  2070. // Test that connecting to a server only supporting TLS 1.1 will fail and
  2071. // results in ERR_SSL_VERSION_OR_CIPHER_MISMATCH.
  2072. TEST_F(SSLClientSocketTest, TLS1_1_NotSupported) {
  2073. SSLServerConfig config;
  2074. config.version_max = SSL_PROTOCOL_VERSION_TLS1_1;
  2075. config.version_min = SSL_PROTOCOL_VERSION_TLS1_1;
  2076. ASSERT_TRUE(StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, config));
  2077. int rv;
  2078. ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
  2079. EXPECT_THAT(rv, IsError(ERR_SSL_VERSION_OR_CIPHER_MISMATCH));
  2080. }
  2081. // When creating an SSLClientSocket, it is allowed to pass in a
  2082. // ClientSocketHandle that is not obtained from a client socket pool.
  2083. // Here we verify that such a simple ClientSocketHandle, not associated with any
  2084. // client socket pool, can be destroyed safely.
  2085. TEST_F(SSLClientSocketTest, ClientSocketHandleNotFromPool) {
  2086. ASSERT_TRUE(
  2087. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, SSLServerConfig()));
  2088. TestCompletionCallback callback;
  2089. auto transport = std::make_unique<TCPClientSocket>(addr(), nullptr, nullptr,
  2090. nullptr, NetLogSource());
  2091. int rv = callback.GetResult(transport->Connect(callback.callback()));
  2092. EXPECT_THAT(rv, IsOk());
  2093. std::unique_ptr<SSLClientSocket> sock(socket_factory_->CreateSSLClientSocket(
  2094. context_.get(), std::move(transport), host_port_pair(), SSLConfig()));
  2095. EXPECT_FALSE(sock->IsConnected());
  2096. rv = callback.GetResult(sock->Connect(callback.callback()));
  2097. EXPECT_THAT(rv, IsOk());
  2098. }
  2099. // Verifies that SSLClientSocket::ExportKeyingMaterial return a success
  2100. // code and different keying label results in different keying material.
  2101. TEST_P(SSLClientSocketVersionTest, ExportKeyingMaterial) {
  2102. ASSERT_TRUE(
  2103. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, GetServerConfig()));
  2104. int rv;
  2105. ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
  2106. EXPECT_THAT(rv, IsOk());
  2107. EXPECT_TRUE(sock_->IsConnected());
  2108. const int kKeyingMaterialSize = 32;
  2109. const char kKeyingLabel1[] = "client-socket-test-1";
  2110. const char kKeyingContext1[] = "";
  2111. unsigned char client_out1[kKeyingMaterialSize];
  2112. memset(client_out1, 0, sizeof(client_out1));
  2113. rv = sock_->ExportKeyingMaterial(kKeyingLabel1, false, kKeyingContext1,
  2114. client_out1, sizeof(client_out1));
  2115. EXPECT_EQ(rv, OK);
  2116. const char kKeyingLabel2[] = "client-socket-test-2";
  2117. unsigned char client_out2[kKeyingMaterialSize];
  2118. memset(client_out2, 0, sizeof(client_out2));
  2119. rv = sock_->ExportKeyingMaterial(kKeyingLabel2, false, kKeyingContext1,
  2120. client_out2, sizeof(client_out2));
  2121. EXPECT_EQ(rv, OK);
  2122. EXPECT_NE(memcmp(client_out1, client_out2, kKeyingMaterialSize), 0);
  2123. const char kKeyingContext2[] = "context";
  2124. rv = sock_->ExportKeyingMaterial(kKeyingLabel1, true, kKeyingContext2,
  2125. client_out2, sizeof(client_out2));
  2126. EXPECT_EQ(rv, OK);
  2127. EXPECT_NE(memcmp(client_out1, client_out2, kKeyingMaterialSize), 0);
  2128. // Prior to TLS 1.3, using an empty context should give different key material
  2129. // from not using a context at all. In TLS 1.3, the distinction is deprecated
  2130. // and they are the same.
  2131. memset(client_out2, 0, sizeof(client_out2));
  2132. rv = sock_->ExportKeyingMaterial(kKeyingLabel1, true, kKeyingContext1,
  2133. client_out2, sizeof(client_out2));
  2134. EXPECT_EQ(rv, OK);
  2135. if (version() >= SSL_PROTOCOL_VERSION_TLS1_3) {
  2136. EXPECT_EQ(memcmp(client_out1, client_out2, kKeyingMaterialSize), 0);
  2137. } else {
  2138. EXPECT_NE(memcmp(client_out1, client_out2, kKeyingMaterialSize), 0);
  2139. }
  2140. }
  2141. TEST(SSLClientSocket, SerializeNextProtos) {
  2142. NextProtoVector next_protos;
  2143. next_protos.push_back(kProtoHTTP11);
  2144. next_protos.push_back(kProtoHTTP2);
  2145. static std::vector<uint8_t> serialized =
  2146. SSLClientSocket::SerializeNextProtos(next_protos);
  2147. ASSERT_EQ(12u, serialized.size());
  2148. EXPECT_EQ(8, serialized[0]); // length("http/1.1")
  2149. EXPECT_EQ('h', serialized[1]);
  2150. EXPECT_EQ('t', serialized[2]);
  2151. EXPECT_EQ('t', serialized[3]);
  2152. EXPECT_EQ('p', serialized[4]);
  2153. EXPECT_EQ('/', serialized[5]);
  2154. EXPECT_EQ('1', serialized[6]);
  2155. EXPECT_EQ('.', serialized[7]);
  2156. EXPECT_EQ('1', serialized[8]);
  2157. EXPECT_EQ(2, serialized[9]); // length("h2")
  2158. EXPECT_EQ('h', serialized[10]);
  2159. EXPECT_EQ('2', serialized[11]);
  2160. }
  2161. // Test that the server certificates are properly retrieved from the underlying
  2162. // SSL stack.
  2163. TEST_P(SSLClientSocketVersionTest, VerifyServerChainProperlyOrdered) {
  2164. // The connection does not have to be successful.
  2165. cert_verifier_->set_default_result(ERR_CERT_INVALID);
  2166. // Set up a test server with CERT_CHAIN_WRONG_ROOT.
  2167. // This makes the server present redundant-server-chain.pem, which contains
  2168. // intermediate certificates.
  2169. ASSERT_TRUE(StartEmbeddedTestServer(EmbeddedTestServer::CERT_CHAIN_WRONG_ROOT,
  2170. GetServerConfig()));
  2171. int rv;
  2172. ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
  2173. EXPECT_THAT(rv, IsError(ERR_CERT_INVALID));
  2174. EXPECT_FALSE(sock_->IsConnected());
  2175. // When given option CERT_CHAIN_WRONG_ROOT, EmbeddedTestServer will present
  2176. // certs from redundant-server-chain.pem.
  2177. CertificateList server_certs =
  2178. CreateCertificateListFromFile(GetTestCertsDirectory(),
  2179. "redundant-server-chain.pem",
  2180. X509Certificate::FORMAT_AUTO);
  2181. // Get the server certificate as received client side.
  2182. SSLInfo ssl_info;
  2183. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  2184. scoped_refptr<X509Certificate> server_certificate = ssl_info.unverified_cert;
  2185. // Get the intermediates as received client side.
  2186. const auto& server_intermediates = server_certificate->intermediate_buffers();
  2187. // Check that the unverified server certificate chain is properly retrieved
  2188. // from the underlying ssl stack.
  2189. ASSERT_EQ(4U, server_certs.size());
  2190. EXPECT_TRUE(x509_util::CryptoBufferEqual(server_certificate->cert_buffer(),
  2191. server_certs[0]->cert_buffer()));
  2192. ASSERT_EQ(3U, server_intermediates.size());
  2193. EXPECT_TRUE(x509_util::CryptoBufferEqual(server_intermediates[0].get(),
  2194. server_certs[1]->cert_buffer()));
  2195. EXPECT_TRUE(x509_util::CryptoBufferEqual(server_intermediates[1].get(),
  2196. server_certs[2]->cert_buffer()));
  2197. EXPECT_TRUE(x509_util::CryptoBufferEqual(server_intermediates[2].get(),
  2198. server_certs[3]->cert_buffer()));
  2199. sock_->Disconnect();
  2200. EXPECT_FALSE(sock_->IsConnected());
  2201. }
  2202. // This tests that SSLInfo contains a properly re-constructed certificate
  2203. // chain. That, in turn, verifies that GetSSLInfo is giving us the chain as
  2204. // verified, not the chain as served by the server. (They may be different.)
  2205. //
  2206. // CERT_CHAIN_WRONG_ROOT is redundant-server-chain.pem. It contains A
  2207. // (end-entity) -> B -> C, and C is signed by D. redundant-validated-chain.pem
  2208. // contains a chain of A -> B -> C2, where C2 is the same public key as C, but
  2209. // a self-signed root. Such a situation can occur when a new root (C2) is
  2210. // cross-certified by an old root (D) and has two different versions of its
  2211. // floating around. Servers may supply C2 as an intermediate, but the
  2212. // SSLClientSocket should return the chain that was verified, from
  2213. // verify_result, instead.
  2214. TEST_P(SSLClientSocketVersionTest, VerifyReturnChainProperlyOrdered) {
  2215. // By default, cause the CertVerifier to treat all certificates as
  2216. // expired.
  2217. cert_verifier_->set_default_result(ERR_CERT_DATE_INVALID);
  2218. CertificateList unverified_certs = CreateCertificateListFromFile(
  2219. GetTestCertsDirectory(), "redundant-server-chain.pem",
  2220. X509Certificate::FORMAT_AUTO);
  2221. ASSERT_EQ(4u, unverified_certs.size());
  2222. // We will expect SSLInfo to ultimately contain this chain.
  2223. CertificateList certs =
  2224. CreateCertificateListFromFile(GetTestCertsDirectory(),
  2225. "redundant-validated-chain.pem",
  2226. X509Certificate::FORMAT_AUTO);
  2227. ASSERT_EQ(3U, certs.size());
  2228. ASSERT_TRUE(certs[0]->EqualsExcludingChain(unverified_certs[0].get()));
  2229. std::vector<bssl::UniquePtr<CRYPTO_BUFFER>> temp_intermediates;
  2230. temp_intermediates.push_back(bssl::UpRef(certs[1]->cert_buffer()));
  2231. temp_intermediates.push_back(bssl::UpRef(certs[2]->cert_buffer()));
  2232. CertVerifyResult verify_result;
  2233. verify_result.verified_cert = X509Certificate::CreateFromBuffer(
  2234. bssl::UpRef(certs[0]->cert_buffer()), std::move(temp_intermediates));
  2235. ASSERT_TRUE(verify_result.verified_cert);
  2236. // Add a rule that maps the server cert (A) to the chain of A->B->C2
  2237. // rather than A->B->C.
  2238. cert_verifier_->AddResultForCert(certs[0].get(), verify_result, OK);
  2239. // Load and install the root for the validated chain.
  2240. scoped_refptr<X509Certificate> root_cert = ImportCertFromFile(
  2241. GetTestCertsDirectory(), "redundant-validated-chain-root.pem");
  2242. ASSERT_NE(static_cast<X509Certificate*>(nullptr), root_cert.get());
  2243. ScopedTestRoot scoped_root(root_cert.get());
  2244. // Set up a test server with CERT_CHAIN_WRONG_ROOT.
  2245. ASSERT_TRUE(StartEmbeddedTestServer(EmbeddedTestServer::CERT_CHAIN_WRONG_ROOT,
  2246. GetServerConfig()));
  2247. int rv;
  2248. ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
  2249. EXPECT_THAT(rv, IsOk());
  2250. EXPECT_TRUE(sock_->IsConnected());
  2251. auto entries = log_observer_.GetEntries();
  2252. EXPECT_TRUE(LogContainsEndEvent(entries, -1, NetLogEventType::SSL_CONNECT));
  2253. SSLInfo ssl_info;
  2254. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  2255. // Verify that SSLInfo contains the corrected re-constructed chain A -> B
  2256. // -> C2.
  2257. ASSERT_TRUE(ssl_info.cert);
  2258. const auto& intermediates = ssl_info.cert->intermediate_buffers();
  2259. ASSERT_EQ(2U, intermediates.size());
  2260. EXPECT_TRUE(x509_util::CryptoBufferEqual(ssl_info.cert->cert_buffer(),
  2261. certs[0]->cert_buffer()));
  2262. EXPECT_TRUE(x509_util::CryptoBufferEqual(intermediates[0].get(),
  2263. certs[1]->cert_buffer()));
  2264. EXPECT_TRUE(x509_util::CryptoBufferEqual(intermediates[1].get(),
  2265. certs[2]->cert_buffer()));
  2266. // Verify that SSLInfo also contains the chain as received from the server.
  2267. ASSERT_TRUE(ssl_info.unverified_cert);
  2268. const auto& served_intermediates =
  2269. ssl_info.unverified_cert->intermediate_buffers();
  2270. ASSERT_EQ(3U, served_intermediates.size());
  2271. EXPECT_TRUE(x509_util::CryptoBufferEqual(ssl_info.cert->cert_buffer(),
  2272. unverified_certs[0]->cert_buffer()));
  2273. EXPECT_TRUE(x509_util::CryptoBufferEqual(served_intermediates[0].get(),
  2274. unverified_certs[1]->cert_buffer()));
  2275. EXPECT_TRUE(x509_util::CryptoBufferEqual(served_intermediates[1].get(),
  2276. unverified_certs[2]->cert_buffer()));
  2277. EXPECT_TRUE(x509_util::CryptoBufferEqual(served_intermediates[2].get(),
  2278. unverified_certs[3]->cert_buffer()));
  2279. sock_->Disconnect();
  2280. EXPECT_FALSE(sock_->IsConnected());
  2281. }
  2282. INSTANTIATE_TEST_SUITE_P(TLSVersion,
  2283. SSLClientSocketCertRequestInfoTest,
  2284. ValuesIn(GetTLSVersions()));
  2285. TEST_P(SSLClientSocketCertRequestInfoTest,
  2286. DontRequestClientCertsIfServerCertInvalid) {
  2287. SSLServerConfig config = GetServerConfig();
  2288. config.client_cert_type = SSLServerConfig::OPTIONAL_CLIENT_CERT;
  2289. ASSERT_TRUE(
  2290. StartEmbeddedTestServer(EmbeddedTestServer::CERT_EXPIRED, config));
  2291. cert_verifier_->set_default_result(ERR_CERT_DATE_INVALID);
  2292. int rv;
  2293. ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
  2294. EXPECT_THAT(rv, IsError(ERR_CERT_DATE_INVALID));
  2295. }
  2296. TEST_P(SSLClientSocketCertRequestInfoTest, NoAuthorities) {
  2297. SSLServerConfig config = GetServerConfig();
  2298. config.client_cert_type = SSLServerConfig::OPTIONAL_CLIENT_CERT;
  2299. ASSERT_TRUE(StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, config));
  2300. scoped_refptr<SSLCertRequestInfo> request_info = GetCertRequest();
  2301. ASSERT_TRUE(request_info.get());
  2302. EXPECT_EQ(0u, request_info->cert_authorities.size());
  2303. }
  2304. TEST_P(SSLClientSocketCertRequestInfoTest, TwoAuthorities) {
  2305. const unsigned char kThawteDN[] = {
  2306. 0x30, 0x4c, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13,
  2307. 0x02, 0x5a, 0x41, 0x31, 0x25, 0x30, 0x23, 0x06, 0x03, 0x55, 0x04, 0x0a,
  2308. 0x13, 0x1c, 0x54, 0x68, 0x61, 0x77, 0x74, 0x65, 0x20, 0x43, 0x6f, 0x6e,
  2309. 0x73, 0x75, 0x6c, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x28, 0x50, 0x74, 0x79,
  2310. 0x29, 0x20, 0x4c, 0x74, 0x64, 0x2e, 0x31, 0x16, 0x30, 0x14, 0x06, 0x03,
  2311. 0x55, 0x04, 0x03, 0x13, 0x0d, 0x54, 0x68, 0x61, 0x77, 0x74, 0x65, 0x20,
  2312. 0x53, 0x47, 0x43, 0x20, 0x43, 0x41};
  2313. const unsigned char kDiginotarDN[] = {
  2314. 0x30, 0x5f, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13,
  2315. 0x02, 0x4e, 0x4c, 0x31, 0x12, 0x30, 0x10, 0x06, 0x03, 0x55, 0x04, 0x0a,
  2316. 0x13, 0x09, 0x44, 0x69, 0x67, 0x69, 0x4e, 0x6f, 0x74, 0x61, 0x72, 0x31,
  2317. 0x1a, 0x30, 0x18, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x11, 0x44, 0x69,
  2318. 0x67, 0x69, 0x4e, 0x6f, 0x74, 0x61, 0x72, 0x20, 0x52, 0x6f, 0x6f, 0x74,
  2319. 0x20, 0x43, 0x41, 0x31, 0x20, 0x30, 0x1e, 0x06, 0x09, 0x2a, 0x86, 0x48,
  2320. 0x86, 0xf7, 0x0d, 0x01, 0x09, 0x01, 0x16, 0x11, 0x69, 0x6e, 0x66, 0x6f,
  2321. 0x40, 0x64, 0x69, 0x67, 0x69, 0x6e, 0x6f, 0x74, 0x61, 0x72, 0x2e, 0x6e,
  2322. 0x6c};
  2323. SSLServerConfig config = GetServerConfig();
  2324. config.client_cert_type = SSLServerConfig::OPTIONAL_CLIENT_CERT;
  2325. config.cert_authorities.emplace_back(std::begin(kThawteDN),
  2326. std::end(kThawteDN));
  2327. config.cert_authorities.emplace_back(std::begin(kDiginotarDN),
  2328. std::end(kDiginotarDN));
  2329. ASSERT_TRUE(StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, config));
  2330. scoped_refptr<SSLCertRequestInfo> request_info = GetCertRequest();
  2331. ASSERT_TRUE(request_info.get());
  2332. EXPECT_EQ(config.cert_authorities, request_info->cert_authorities);
  2333. }
  2334. TEST_P(SSLClientSocketCertRequestInfoTest, CertKeyTypes) {
  2335. SSLServerConfig config = GetServerConfig();
  2336. config.client_cert_type = SSLServerConfig::OPTIONAL_CLIENT_CERT;
  2337. ASSERT_TRUE(StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, config));
  2338. scoped_refptr<SSLCertRequestInfo> request_info = GetCertRequest();
  2339. ASSERT_TRUE(request_info.get());
  2340. if (version() >= SSL_PROTOCOL_VERSION_TLS1_3) {
  2341. // TLS 1.3 does not use cert_key_types, only signature algorithms. This
  2342. // should be migrated to a more modern mechanism. See
  2343. // https://crbug.com/1270530.
  2344. EXPECT_EQ(0u, request_info->cert_key_types.size());
  2345. } else {
  2346. // BoringSSL always sends rsa_sign and ecdsa_sign.
  2347. ASSERT_EQ(2u, request_info->cert_key_types.size());
  2348. EXPECT_EQ(CLIENT_CERT_RSA_SIGN, request_info->cert_key_types[0]);
  2349. EXPECT_EQ(CLIENT_CERT_ECDSA_SIGN, request_info->cert_key_types[1]);
  2350. }
  2351. }
  2352. // Tests that the Certificate Transparency (RFC 6962) TLS extension is
  2353. // supported.
  2354. TEST_P(SSLClientSocketVersionTest, ConnectSignedCertTimestampsTLSExtension) {
  2355. // Encoding of SCT List containing 'test'.
  2356. base::StringPiece sct_ext("\x00\x06\x00\x04test", 8);
  2357. SSLServerConfig server_config = GetServerConfig();
  2358. server_config.signed_cert_timestamp_list =
  2359. std::vector<uint8_t>(sct_ext.begin(), sct_ext.end());
  2360. ASSERT_TRUE(
  2361. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  2362. auto ct_verifier = std::make_unique<MockCTVerifier>();
  2363. // Check that the SCT list is extracted from the TLS extension as expected,
  2364. // while also simulating that it was an unparsable response.
  2365. SignedCertificateTimestampAndStatusList sct_list;
  2366. EXPECT_CALL(*ct_verifier, Verify(_, _, _, sct_ext, _, _))
  2367. .WillOnce(testing::SetArgPointee<4>(sct_list));
  2368. auto cert_and_ct_verifier = std::make_unique<CertAndCTVerifier>(
  2369. std::move(cert_verifier_), std::move(ct_verifier));
  2370. context_ = std::make_unique<SSLClientContext>(
  2371. ssl_config_service_.get(), cert_and_ct_verifier.get(),
  2372. transport_security_state_.get(), ct_policy_enforcer_.get(),
  2373. ssl_client_session_cache_.get(), nullptr);
  2374. int rv;
  2375. ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
  2376. EXPECT_THAT(rv, IsOk());
  2377. EXPECT_TRUE(sock_->signed_cert_timestamps_received_);
  2378. sock_ = nullptr;
  2379. context_ = nullptr;
  2380. }
  2381. // Test that when a CT verifier and a CTPolicyEnforcer are defined, and
  2382. // the EV certificate used conforms to the CT/EV policy, its EV status
  2383. // is maintained.
  2384. TEST_P(SSLClientSocketVersionTest, EVCertStatusMaintainedForCompliantCert) {
  2385. ASSERT_TRUE(
  2386. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, GetServerConfig()));
  2387. SSLConfig ssl_config;
  2388. AddServerCertStatusToSSLConfig(CERT_STATUS_IS_EV, &ssl_config);
  2389. // Emulate compliance of the certificate to the policy.
  2390. EXPECT_CALL(*ct_policy_enforcer_, CheckCompliance(_, _, _))
  2391. .WillRepeatedly(
  2392. Return(ct::CTPolicyCompliance::CT_POLICY_COMPLIES_VIA_SCTS));
  2393. int rv;
  2394. ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
  2395. EXPECT_THAT(rv, IsOk());
  2396. SSLInfo result;
  2397. ASSERT_TRUE(sock_->GetSSLInfo(&result));
  2398. EXPECT_TRUE(result.cert_status & CERT_STATUS_IS_EV);
  2399. }
  2400. // Test that when a CT verifier and a CTPolicyEnforcer are defined, but
  2401. // the EV certificate used does not conform to the CT/EV policy, its EV status
  2402. // is removed.
  2403. TEST_P(SSLClientSocketVersionTest, EVCertStatusRemovedForNonCompliantCert) {
  2404. ASSERT_TRUE(
  2405. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, GetServerConfig()));
  2406. SSLConfig ssl_config;
  2407. AddServerCertStatusToSSLConfig(CERT_STATUS_IS_EV, &ssl_config);
  2408. // Emulate non-compliance of the certificate to the policy.
  2409. EXPECT_CALL(*ct_policy_enforcer_, CheckCompliance(_, _, _))
  2410. .WillRepeatedly(
  2411. Return(ct::CTPolicyCompliance::CT_POLICY_NOT_ENOUGH_SCTS));
  2412. int rv;
  2413. ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
  2414. EXPECT_THAT(rv, IsOk());
  2415. SSLInfo result;
  2416. ASSERT_TRUE(sock_->GetSSLInfo(&result));
  2417. EXPECT_FALSE(result.cert_status & CERT_STATUS_IS_EV);
  2418. EXPECT_TRUE(result.cert_status & CERT_STATUS_CT_COMPLIANCE_FAILED);
  2419. }
  2420. // Tests that OCSP stapling is requested, as per Certificate Transparency (RFC
  2421. // 6962).
  2422. TEST_P(SSLClientSocketVersionTest, ConnectSignedCertTimestampsEnablesOCSP) {
  2423. // The test server currently only knows how to generate OCSP responses
  2424. // for a freshly minted certificate.
  2425. EmbeddedTestServer::ServerCertificateConfig cert_config;
  2426. cert_config.stapled_ocsp_config = EmbeddedTestServer::OCSPConfig(
  2427. {{OCSPRevocationStatus::GOOD,
  2428. EmbeddedTestServer::OCSPConfig::SingleResponse::Date::kValid}});
  2429. ASSERT_TRUE(StartEmbeddedTestServer(cert_config, GetServerConfig()));
  2430. SSLConfig ssl_config;
  2431. int rv;
  2432. ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
  2433. EXPECT_THAT(rv, IsOk());
  2434. EXPECT_TRUE(sock_->stapled_ocsp_response_received_);
  2435. }
  2436. // Tests that IsConnectedAndIdle and WasEverUsed behave as expected.
  2437. TEST_P(SSLClientSocketVersionTest, ReuseStates) {
  2438. ASSERT_TRUE(
  2439. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, GetServerConfig()));
  2440. int rv;
  2441. ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
  2442. // The socket was just connected. It should be idle because it is speaking
  2443. // HTTP. Although the transport has been used for the handshake, WasEverUsed()
  2444. // returns false.
  2445. EXPECT_TRUE(sock_->IsConnected());
  2446. EXPECT_TRUE(sock_->IsConnectedAndIdle());
  2447. EXPECT_FALSE(sock_->WasEverUsed());
  2448. const char kRequestText[] = "GET / HTTP/1.0\r\n\r\n";
  2449. const size_t kRequestLen = std::size(kRequestText) - 1;
  2450. scoped_refptr<IOBuffer> request_buffer =
  2451. base::MakeRefCounted<IOBuffer>(kRequestLen);
  2452. memcpy(request_buffer->data(), kRequestText, kRequestLen);
  2453. TestCompletionCallback callback;
  2454. rv = callback.GetResult(sock_->Write(request_buffer.get(), kRequestLen,
  2455. callback.callback(),
  2456. TRAFFIC_ANNOTATION_FOR_TESTS));
  2457. EXPECT_EQ(static_cast<int>(kRequestLen), rv);
  2458. // The socket has now been used.
  2459. EXPECT_TRUE(sock_->WasEverUsed());
  2460. // TODO(davidben): Read one byte to ensure the test server has responded and
  2461. // then assert IsConnectedAndIdle is false. This currently doesn't work
  2462. // because SSLClientSocketImpl doesn't check the implementation's internal
  2463. // buffer. Call SSL_pending.
  2464. }
  2465. // Tests that |is_fatal_cert_error| does not get set for a certificate error,
  2466. // on a non-HSTS host.
  2467. TEST_P(SSLClientSocketVersionTest, IsFatalErrorNotSetOnNonFatalError) {
  2468. cert_verifier_->set_default_result(ERR_CERT_DATE_INVALID);
  2469. ASSERT_TRUE(StartEmbeddedTestServer(EmbeddedTestServer::CERT_CHAIN_WRONG_ROOT,
  2470. GetServerConfig()));
  2471. int rv;
  2472. ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
  2473. SSLInfo ssl_info;
  2474. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  2475. EXPECT_FALSE(ssl_info.is_fatal_cert_error);
  2476. }
  2477. // Tests that |is_fatal_cert_error| gets set for a certificate error on an
  2478. // HSTS host.
  2479. TEST_P(SSLClientSocketVersionTest, IsFatalErrorSetOnFatalError) {
  2480. cert_verifier_->set_default_result(ERR_CERT_DATE_INVALID);
  2481. ASSERT_TRUE(StartEmbeddedTestServer(EmbeddedTestServer::CERT_CHAIN_WRONG_ROOT,
  2482. GetServerConfig()));
  2483. int rv;
  2484. const base::Time expiry = base::Time::Now() + base::Seconds(1000);
  2485. transport_security_state_->AddHSTS(host_port_pair().host(), expiry, true);
  2486. ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
  2487. SSLInfo ssl_info;
  2488. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  2489. EXPECT_TRUE(ssl_info.is_fatal_cert_error);
  2490. }
  2491. // Tests that IsConnectedAndIdle treats a socket as idle even if a Write hasn't
  2492. // been flushed completely out of SSLClientSocket's internal buffers. This is a
  2493. // regression test for https://crbug.com/466147.
  2494. TEST_P(SSLClientSocketVersionTest, ReusableAfterWrite) {
  2495. ASSERT_TRUE(
  2496. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, GetServerConfig()));
  2497. TestCompletionCallback callback;
  2498. auto real_transport = std::make_unique<TCPClientSocket>(
  2499. addr(), nullptr, nullptr, nullptr, NetLogSource());
  2500. auto transport =
  2501. std::make_unique<FakeBlockingStreamSocket>(std::move(real_transport));
  2502. FakeBlockingStreamSocket* raw_transport = transport.get();
  2503. ASSERT_THAT(callback.GetResult(transport->Connect(callback.callback())),
  2504. IsOk());
  2505. std::unique_ptr<SSLClientSocket> sock(CreateSSLClientSocket(
  2506. std::move(transport), host_port_pair(), SSLConfig()));
  2507. ASSERT_THAT(callback.GetResult(sock->Connect(callback.callback())), IsOk());
  2508. // Block any application data from reaching the network.
  2509. raw_transport->BlockWrite();
  2510. // Write a partial HTTP request.
  2511. const char kRequestText[] = "GET / HTTP/1.0";
  2512. const size_t kRequestLen = std::size(kRequestText) - 1;
  2513. scoped_refptr<IOBuffer> request_buffer =
  2514. base::MakeRefCounted<IOBuffer>(kRequestLen);
  2515. memcpy(request_buffer->data(), kRequestText, kRequestLen);
  2516. // Although transport writes are blocked, SSLClientSocketImpl completes the
  2517. // outer Write operation.
  2518. EXPECT_EQ(static_cast<int>(kRequestLen),
  2519. callback.GetResult(sock->Write(request_buffer.get(), kRequestLen,
  2520. callback.callback(),
  2521. TRAFFIC_ANNOTATION_FOR_TESTS)));
  2522. // The Write operation is complete, so the socket should be treated as
  2523. // reusable, in case the server returns an HTTP response before completely
  2524. // consuming the request body. In this case, we assume the server will
  2525. // properly drain the request body before trying to read the next request.
  2526. EXPECT_TRUE(sock->IsConnectedAndIdle());
  2527. }
  2528. // Tests that basic session resumption works.
  2529. TEST_P(SSLClientSocketVersionTest, SessionResumption) {
  2530. ASSERT_TRUE(
  2531. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, GetServerConfig()));
  2532. // First, perform a full handshake.
  2533. SSLConfig ssl_config;
  2534. int rv;
  2535. ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
  2536. ASSERT_THAT(rv, IsOk());
  2537. SSLInfo ssl_info;
  2538. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  2539. EXPECT_EQ(SSLInfo::HANDSHAKE_FULL, ssl_info.handshake_type);
  2540. // TLS 1.2 with False Start and TLS 1.3 cause the ticket to arrive later, so
  2541. // use the socket to ensure the session ticket has been picked up.
  2542. EXPECT_THAT(MakeHTTPRequest(sock_.get()), IsOk());
  2543. // The next connection should resume.
  2544. ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
  2545. ASSERT_THAT(rv, IsOk());
  2546. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  2547. EXPECT_EQ(SSLInfo::HANDSHAKE_RESUME, ssl_info.handshake_type);
  2548. sock_.reset();
  2549. // Using a different HostPortPair uses a different session cache key.
  2550. auto transport = std::make_unique<TCPClientSocket>(
  2551. addr(), nullptr, nullptr, NetLog::Get(), NetLogSource());
  2552. TestCompletionCallback callback;
  2553. ASSERT_THAT(callback.GetResult(transport->Connect(callback.callback())),
  2554. IsOk());
  2555. std::unique_ptr<SSLClientSocket> sock = CreateSSLClientSocket(
  2556. std::move(transport), HostPortPair("example.com", 443), ssl_config);
  2557. ASSERT_THAT(callback.GetResult(sock->Connect(callback.callback())), IsOk());
  2558. ASSERT_TRUE(sock->GetSSLInfo(&ssl_info));
  2559. EXPECT_EQ(SSLInfo::HANDSHAKE_FULL, ssl_info.handshake_type);
  2560. sock.reset();
  2561. ssl_client_session_cache_->Flush();
  2562. // After clearing the session cache, the next handshake doesn't resume.
  2563. ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
  2564. ASSERT_THAT(rv, IsOk());
  2565. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  2566. EXPECT_EQ(SSLInfo::HANDSHAKE_FULL, ssl_info.handshake_type);
  2567. }
  2568. namespace {
  2569. // FakePeerAddressSocket wraps a |StreamSocket|, forwarding all calls except
  2570. // that it provides a given answer for |GetPeerAddress|.
  2571. class FakePeerAddressSocket : public WrappedStreamSocket {
  2572. public:
  2573. FakePeerAddressSocket(std::unique_ptr<StreamSocket> socket,
  2574. const IPEndPoint& address)
  2575. : WrappedStreamSocket(std::move(socket)), address_(address) {}
  2576. ~FakePeerAddressSocket() override = default;
  2577. int GetPeerAddress(IPEndPoint* address) const override {
  2578. *address = address_;
  2579. return OK;
  2580. }
  2581. private:
  2582. const IPEndPoint address_;
  2583. };
  2584. } // namespace
  2585. TEST_F(SSLClientSocketTest, SessionResumption_RSA) {
  2586. for (bool use_rsa : {false, true}) {
  2587. SCOPED_TRACE(use_rsa);
  2588. SSLServerConfig server_config;
  2589. server_config.version_max = SSL_PROTOCOL_VERSION_TLS1_2;
  2590. server_config.cipher_suite_for_testing =
  2591. use_rsa ? kRSACipher : kModernTLS12Cipher;
  2592. ASSERT_TRUE(
  2593. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  2594. SSLConfig ssl_config;
  2595. ssl_client_session_cache_->Flush();
  2596. for (int i = 0; i < 3; i++) {
  2597. SCOPED_TRACE(i);
  2598. auto transport = std::make_unique<TCPClientSocket>(
  2599. addr(), nullptr, nullptr, NetLog::Get(), NetLogSource());
  2600. TestCompletionCallback callback;
  2601. ASSERT_THAT(callback.GetResult(transport->Connect(callback.callback())),
  2602. IsOk());
  2603. // The third handshake sees a different destination IP address.
  2604. IPEndPoint fake_peer_address(IPAddress(1, 1, 1, i == 2 ? 2 : 1), 443);
  2605. auto socket = std::make_unique<FakePeerAddressSocket>(
  2606. std::move(transport), fake_peer_address);
  2607. std::unique_ptr<SSLClientSocket> sock = CreateSSLClientSocket(
  2608. std::move(socket), HostPortPair("example.com", 443), ssl_config);
  2609. ASSERT_THAT(callback.GetResult(sock->Connect(callback.callback())),
  2610. IsOk());
  2611. SSLInfo ssl_info;
  2612. ASSERT_TRUE(sock->GetSSLInfo(&ssl_info));
  2613. sock.reset();
  2614. switch (i) {
  2615. case 0:
  2616. // Initial handshake should be a full handshake.
  2617. EXPECT_EQ(SSLInfo::HANDSHAKE_FULL, ssl_info.handshake_type);
  2618. break;
  2619. case 1:
  2620. // Second handshake should resume.
  2621. EXPECT_EQ(SSLInfo::HANDSHAKE_RESUME, ssl_info.handshake_type);
  2622. break;
  2623. case 2:
  2624. // Third handshake gets a different IP address and, if the
  2625. // session used RSA key exchange, it should not resume.
  2626. EXPECT_EQ(
  2627. use_rsa ? SSLInfo::HANDSHAKE_FULL : SSLInfo::HANDSHAKE_RESUME,
  2628. ssl_info.handshake_type);
  2629. break;
  2630. default:
  2631. NOTREACHED();
  2632. }
  2633. }
  2634. }
  2635. }
  2636. // Tests that ALPN works with session resumption.
  2637. TEST_F(SSLClientSocketTest, SessionResumptionAlpn) {
  2638. SSLServerConfig server_config;
  2639. server_config.alpn_protos = {NextProto::kProtoHTTP2, NextProto::kProtoHTTP11};
  2640. ASSERT_TRUE(
  2641. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  2642. // First, perform a full handshake.
  2643. SSLConfig ssl_config;
  2644. ssl_config.alpn_protos.push_back(kProtoHTTP2);
  2645. int rv;
  2646. ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
  2647. ASSERT_THAT(rv, IsOk());
  2648. SSLInfo ssl_info;
  2649. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  2650. EXPECT_EQ(SSLInfo::HANDSHAKE_FULL, ssl_info.handshake_type);
  2651. EXPECT_EQ(kProtoHTTP2, sock_->GetNegotiatedProtocol());
  2652. // TLS 1.2 with False Start and TLS 1.3 cause the ticket to arrive later, so
  2653. // use the socket to ensure the session ticket has been picked up.
  2654. EXPECT_THAT(MakeHTTPRequest(sock_.get()), IsOk());
  2655. // The next connection should resume; ALPN should be renegotiated.
  2656. ssl_config.alpn_protos.clear();
  2657. ssl_config.alpn_protos.push_back(kProtoHTTP11);
  2658. ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
  2659. ASSERT_THAT(rv, IsOk());
  2660. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  2661. EXPECT_EQ(SSLInfo::HANDSHAKE_RESUME, ssl_info.handshake_type);
  2662. EXPECT_EQ(kProtoHTTP11, sock_->GetNegotiatedProtocol());
  2663. }
  2664. // Tests that the session cache is not sharded by NetworkIsolationKey if the
  2665. // feature is disabled.
  2666. TEST_P(SSLClientSocketVersionTest,
  2667. SessionResumptionNetworkIsolationKeyDisabled) {
  2668. base::test::ScopedFeatureList feature_list;
  2669. feature_list.InitAndDisableFeature(
  2670. features::kPartitionSSLSessionsByNetworkIsolationKey);
  2671. ASSERT_TRUE(
  2672. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, GetServerConfig()));
  2673. // First, perform a full handshake.
  2674. SSLConfig ssl_config;
  2675. int rv;
  2676. ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
  2677. ASSERT_THAT(rv, IsOk());
  2678. SSLInfo ssl_info;
  2679. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  2680. EXPECT_EQ(SSLInfo::HANDSHAKE_FULL, ssl_info.handshake_type);
  2681. // TLS 1.2 with False Start and TLS 1.3 cause the ticket to arrive later, so
  2682. // use the socket to ensure the session ticket has been picked up. Do this for
  2683. // every connection to avoid problems with TLS 1.3 single-use tickets.
  2684. EXPECT_THAT(MakeHTTPRequest(sock_.get()), IsOk());
  2685. // The next connection should resume.
  2686. ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
  2687. ASSERT_THAT(rv, IsOk());
  2688. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  2689. EXPECT_EQ(SSLInfo::HANDSHAKE_RESUME, ssl_info.handshake_type);
  2690. EXPECT_THAT(MakeHTTPRequest(sock_.get()), IsOk());
  2691. sock_.reset();
  2692. // Using a different NetworkIsolationKey shares session cache key because
  2693. // sharding is disabled.
  2694. const SchemefulSite kSiteA(GURL("https://a.test"));
  2695. ssl_config.network_isolation_key = NetworkIsolationKey(kSiteA, kSiteA);
  2696. ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
  2697. ASSERT_THAT(rv, IsOk());
  2698. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  2699. EXPECT_EQ(SSLInfo::HANDSHAKE_RESUME, ssl_info.handshake_type);
  2700. EXPECT_THAT(MakeHTTPRequest(sock_.get()), IsOk());
  2701. sock_.reset();
  2702. const SchemefulSite kSiteB(GURL("https://a.test"));
  2703. ssl_config.network_isolation_key = NetworkIsolationKey(kSiteB, kSiteB);
  2704. ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
  2705. ASSERT_THAT(rv, IsOk());
  2706. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  2707. EXPECT_EQ(SSLInfo::HANDSHAKE_RESUME, ssl_info.handshake_type);
  2708. EXPECT_THAT(MakeHTTPRequest(sock_.get()), IsOk());
  2709. sock_.reset();
  2710. }
  2711. // Tests that the session cache is sharded by NetworkIsolationKey if the
  2712. // feature is enabled.
  2713. TEST_P(SSLClientSocketVersionTest,
  2714. SessionResumptionNetworkIsolationKeyEnabled) {
  2715. base::test::ScopedFeatureList feature_list;
  2716. feature_list.InitAndEnableFeature(
  2717. features::kPartitionSSLSessionsByNetworkIsolationKey);
  2718. const SchemefulSite kSiteA(GURL("https://a.test"));
  2719. const SchemefulSite kSiteB(GURL("https://b.test"));
  2720. const NetworkIsolationKey kNetworkIsolationKeyA(kSiteA, kSiteA);
  2721. const NetworkIsolationKey kNetworkIsolationKeyB(kSiteB, kSiteB);
  2722. ASSERT_TRUE(
  2723. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, GetServerConfig()));
  2724. // First, perform a full handshake.
  2725. SSLConfig ssl_config;
  2726. int rv;
  2727. ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
  2728. ASSERT_THAT(rv, IsOk());
  2729. SSLInfo ssl_info;
  2730. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  2731. EXPECT_EQ(SSLInfo::HANDSHAKE_FULL, ssl_info.handshake_type);
  2732. // TLS 1.2 with False Start and TLS 1.3 cause the ticket to arrive later, so
  2733. // use the socket to ensure the session ticket has been picked up. Do this for
  2734. // every connection to avoid problems with TLS 1.3 single-use tickets.
  2735. EXPECT_THAT(MakeHTTPRequest(sock_.get()), IsOk());
  2736. // The next connection should resume.
  2737. ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
  2738. ASSERT_THAT(rv, IsOk());
  2739. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  2740. EXPECT_EQ(SSLInfo::HANDSHAKE_RESUME, ssl_info.handshake_type);
  2741. EXPECT_THAT(MakeHTTPRequest(sock_.get()), IsOk());
  2742. sock_.reset();
  2743. // Using a different NetworkIsolationKey uses a different session cache key.
  2744. ssl_config.network_isolation_key = kNetworkIsolationKeyA;
  2745. ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
  2746. ASSERT_THAT(rv, IsOk());
  2747. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  2748. EXPECT_EQ(SSLInfo::HANDSHAKE_FULL, ssl_info.handshake_type);
  2749. EXPECT_THAT(MakeHTTPRequest(sock_.get()), IsOk());
  2750. sock_.reset();
  2751. // We, however, can resume under that newly-established session.
  2752. ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
  2753. ASSERT_THAT(rv, IsOk());
  2754. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  2755. EXPECT_EQ(SSLInfo::HANDSHAKE_RESUME, ssl_info.handshake_type);
  2756. EXPECT_THAT(MakeHTTPRequest(sock_.get()), IsOk());
  2757. sock_.reset();
  2758. // Repeat with another non-null key.
  2759. ssl_config.network_isolation_key = kNetworkIsolationKeyB;
  2760. ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
  2761. ASSERT_THAT(rv, IsOk());
  2762. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  2763. EXPECT_EQ(SSLInfo::HANDSHAKE_FULL, ssl_info.handshake_type);
  2764. EXPECT_THAT(MakeHTTPRequest(sock_.get()), IsOk());
  2765. sock_.reset();
  2766. ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
  2767. ASSERT_THAT(rv, IsOk());
  2768. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  2769. EXPECT_EQ(SSLInfo::HANDSHAKE_RESUME, ssl_info.handshake_type);
  2770. EXPECT_THAT(MakeHTTPRequest(sock_.get()), IsOk());
  2771. sock_.reset();
  2772. // b.test does not evict a.test's session.
  2773. ssl_config.network_isolation_key = kNetworkIsolationKeyA;
  2774. ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
  2775. ASSERT_THAT(rv, IsOk());
  2776. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  2777. EXPECT_EQ(SSLInfo::HANDSHAKE_RESUME, ssl_info.handshake_type);
  2778. EXPECT_THAT(MakeHTTPRequest(sock_.get()), IsOk());
  2779. sock_.reset();
  2780. }
  2781. // Tests that connections with certificate errors do not add entries to the
  2782. // session cache.
  2783. TEST_P(SSLClientSocketVersionTest, CertificateErrorNoResume) {
  2784. ASSERT_TRUE(
  2785. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, GetServerConfig()));
  2786. cert_verifier_->set_default_result(ERR_CERT_COMMON_NAME_INVALID);
  2787. SSLConfig ssl_config;
  2788. int rv;
  2789. ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
  2790. ASSERT_THAT(rv, IsError(ERR_CERT_COMMON_NAME_INVALID));
  2791. cert_verifier_->set_default_result(OK);
  2792. // The next connection should perform a full handshake.
  2793. ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
  2794. ASSERT_THAT(rv, IsOk());
  2795. SSLInfo ssl_info;
  2796. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  2797. EXPECT_EQ(SSLInfo::HANDSHAKE_FULL, ssl_info.handshake_type);
  2798. }
  2799. TEST_F(SSLClientSocketTest, RequireECDHE) {
  2800. // Run test server without ECDHE.
  2801. SSLServerConfig server_config;
  2802. server_config.version_max = SSL_PROTOCOL_VERSION_TLS1_2;
  2803. server_config.cipher_suite_for_testing = kRSACipher;
  2804. ASSERT_TRUE(
  2805. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  2806. SSLConfig config;
  2807. config.require_ecdhe = true;
  2808. int rv;
  2809. ASSERT_TRUE(CreateAndConnectSSLClientSocket(config, &rv));
  2810. EXPECT_THAT(rv, IsError(ERR_SSL_VERSION_OR_CIPHER_MISMATCH));
  2811. }
  2812. TEST_F(SSLClientSocketTest, 3DES) {
  2813. SSLServerConfig server_config;
  2814. server_config.version_max = SSL_PROTOCOL_VERSION_TLS1_2;
  2815. server_config.cipher_suite_for_testing = k3DESCipher;
  2816. ASSERT_TRUE(
  2817. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  2818. // 3DES is always disabled.
  2819. int rv;
  2820. ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
  2821. EXPECT_THAT(rv, IsError(ERR_SSL_VERSION_OR_CIPHER_MISMATCH));
  2822. }
  2823. TEST_F(SSLClientSocketTest, SHA1) {
  2824. SSLServerConfig server_config;
  2825. server_config.version_max = SSL_PROTOCOL_VERSION_TLS1_2;
  2826. // Disable RSA key exchange, to ensure the server does not pick a non-signing
  2827. // cipher.
  2828. server_config.require_ecdhe = true;
  2829. server_config.signature_algorithm_for_testing = SSL_SIGN_RSA_PKCS1_SHA1;
  2830. ASSERT_TRUE(
  2831. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  2832. int rv;
  2833. ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
  2834. EXPECT_THAT(rv, IsOk());
  2835. SSLConfig config;
  2836. config.disable_legacy_crypto = true;
  2837. ASSERT_TRUE(CreateAndConnectSSLClientSocket(config, &rv));
  2838. EXPECT_THAT(rv, IsError(ERR_SSL_PROTOCOL_ERROR));
  2839. }
  2840. TEST_F(SSLClientSocketFalseStartTest, FalseStartEnabled) {
  2841. // False Start requires ALPN, ECDHE, and an AEAD.
  2842. SSLServerConfig server_config;
  2843. server_config.version_max = SSL_PROTOCOL_VERSION_TLS1_2;
  2844. server_config.cipher_suite_for_testing = kModernTLS12Cipher;
  2845. server_config.alpn_protos = {NextProto::kProtoHTTP11};
  2846. SSLConfig client_config;
  2847. client_config.alpn_protos.push_back(kProtoHTTP11);
  2848. ASSERT_NO_FATAL_FAILURE(TestFalseStart(server_config, client_config, true));
  2849. }
  2850. // Test that False Start is disabled without ALPN.
  2851. TEST_F(SSLClientSocketFalseStartTest, NoAlpn) {
  2852. SSLServerConfig server_config;
  2853. server_config.version_max = SSL_PROTOCOL_VERSION_TLS1_2;
  2854. server_config.cipher_suite_for_testing = kModernTLS12Cipher;
  2855. SSLConfig client_config;
  2856. client_config.alpn_protos.clear();
  2857. ASSERT_NO_FATAL_FAILURE(TestFalseStart(server_config, client_config, false));
  2858. }
  2859. // Test that False Start is disabled with plain RSA ciphers.
  2860. TEST_F(SSLClientSocketFalseStartTest, RSA) {
  2861. SSLServerConfig server_config;
  2862. server_config.version_max = SSL_PROTOCOL_VERSION_TLS1_2;
  2863. server_config.cipher_suite_for_testing = kRSACipher;
  2864. server_config.alpn_protos = {NextProto::kProtoHTTP11};
  2865. SSLConfig client_config;
  2866. client_config.alpn_protos.push_back(kProtoHTTP11);
  2867. ASSERT_NO_FATAL_FAILURE(TestFalseStart(server_config, client_config, false));
  2868. }
  2869. // Test that False Start is disabled without an AEAD.
  2870. TEST_F(SSLClientSocketFalseStartTest, NoAEAD) {
  2871. SSLServerConfig server_config;
  2872. server_config.version_max = SSL_PROTOCOL_VERSION_TLS1_2;
  2873. server_config.cipher_suite_for_testing = kCBCCipher;
  2874. server_config.alpn_protos = {NextProto::kProtoHTTP11};
  2875. SSLConfig client_config;
  2876. client_config.alpn_protos.push_back(kProtoHTTP11);
  2877. ASSERT_NO_FATAL_FAILURE(TestFalseStart(server_config, client_config, false));
  2878. }
  2879. // Test that sessions are resumable after receiving the server Finished message.
  2880. TEST_F(SSLClientSocketFalseStartTest, SessionResumption) {
  2881. // Start a server.
  2882. SSLServerConfig server_config;
  2883. server_config.version_max = SSL_PROTOCOL_VERSION_TLS1_2;
  2884. server_config.cipher_suite_for_testing = kModernTLS12Cipher;
  2885. server_config.alpn_protos = {NextProto::kProtoHTTP11};
  2886. SSLConfig client_config;
  2887. client_config.alpn_protos.push_back(kProtoHTTP11);
  2888. // Let a full handshake complete with False Start.
  2889. ASSERT_NO_FATAL_FAILURE(TestFalseStart(server_config, client_config, true));
  2890. // Make a second connection.
  2891. int rv;
  2892. ASSERT_TRUE(CreateAndConnectSSLClientSocket(client_config, &rv));
  2893. EXPECT_THAT(rv, IsOk());
  2894. // It should resume the session.
  2895. SSLInfo ssl_info;
  2896. EXPECT_TRUE(sock_->GetSSLInfo(&ssl_info));
  2897. EXPECT_EQ(SSLInfo::HANDSHAKE_RESUME, ssl_info.handshake_type);
  2898. }
  2899. // Test that the client completes the handshake in the background and installs
  2900. // new sessions, even if the socket isn't used. This also avoids a theoretical
  2901. // deadlock if NewSessionTicket is sufficiently large that neither it nor the
  2902. // client's HTTP/1.1 POST fit in transport windows.
  2903. TEST_F(SSLClientSocketFalseStartTest, CompleteHandshakeWithoutRequest) {
  2904. // Start a server.
  2905. SSLServerConfig server_config;
  2906. server_config.version_max = SSL_PROTOCOL_VERSION_TLS1_2;
  2907. server_config.cipher_suite_for_testing = kModernTLS12Cipher;
  2908. server_config.alpn_protos = {NextProto::kProtoHTTP11};
  2909. ASSERT_TRUE(
  2910. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  2911. SSLConfig client_config;
  2912. client_config.alpn_protos.push_back(kProtoHTTP11);
  2913. // Start a handshake up to the server Finished message.
  2914. TestCompletionCallback callback;
  2915. FakeBlockingStreamSocket* raw_transport = nullptr;
  2916. std::unique_ptr<SSLClientSocket> sock;
  2917. ASSERT_NO_FATAL_FAILURE(CreateAndConnectUntilServerFinishedReceived(
  2918. client_config, &callback, &raw_transport, &sock));
  2919. // Wait for the server Finished to arrive, release it, and allow
  2920. // SSLClientSocket to process it. This should install a session. It make take
  2921. // a few iterations to complete if the server writes in small chunks
  2922. while (ssl_client_session_cache_->size() == 0) {
  2923. raw_transport->WaitForReadResult();
  2924. raw_transport->UnblockReadResult();
  2925. base::RunLoop().RunUntilIdle();
  2926. raw_transport->BlockReadResult();
  2927. }
  2928. // Drop the old socket. This is needed because the Python test server can't
  2929. // service two sockets in parallel.
  2930. sock.reset();
  2931. // Make a second connection.
  2932. int rv;
  2933. ASSERT_TRUE(CreateAndConnectSSLClientSocket(client_config, &rv));
  2934. EXPECT_THAT(rv, IsOk());
  2935. // It should resume the session.
  2936. SSLInfo ssl_info;
  2937. EXPECT_TRUE(sock_->GetSSLInfo(&ssl_info));
  2938. EXPECT_EQ(SSLInfo::HANDSHAKE_RESUME, ssl_info.handshake_type);
  2939. }
  2940. // Test that False Started sessions are not resumable before receiving the
  2941. // server Finished message.
  2942. TEST_F(SSLClientSocketFalseStartTest, NoSessionResumptionBeforeFinished) {
  2943. // Start a server.
  2944. SSLServerConfig server_config;
  2945. server_config.version_max = SSL_PROTOCOL_VERSION_TLS1_2;
  2946. server_config.cipher_suite_for_testing = kModernTLS12Cipher;
  2947. server_config.alpn_protos = {NextProto::kProtoHTTP11};
  2948. ASSERT_TRUE(
  2949. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  2950. SSLConfig client_config;
  2951. client_config.alpn_protos.push_back(kProtoHTTP11);
  2952. // Start a handshake up to the server Finished message.
  2953. TestCompletionCallback callback;
  2954. FakeBlockingStreamSocket* raw_transport1 = nullptr;
  2955. std::unique_ptr<SSLClientSocket> sock1;
  2956. ASSERT_NO_FATAL_FAILURE(CreateAndConnectUntilServerFinishedReceived(
  2957. client_config, &callback, &raw_transport1, &sock1));
  2958. // Although raw_transport1 has the server Finished blocked, the handshake
  2959. // still completes.
  2960. EXPECT_THAT(callback.WaitForResult(), IsOk());
  2961. // Continue to block the client (|sock1|) from processing the Finished
  2962. // message, but allow it to arrive on the socket. This ensures that, from the
  2963. // server's point of view, it has completed the handshake and added the
  2964. // session to its session cache.
  2965. //
  2966. // The actual read on |sock1| will not complete until the Finished message is
  2967. // processed; however, pump the underlying transport so that it is read from
  2968. // the socket. NOTE: This may flakily pass if the server's final flight
  2969. // doesn't come in one Read.
  2970. scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(4096);
  2971. int rv = sock1->Read(buf.get(), 4096, callback.callback());
  2972. EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
  2973. raw_transport1->WaitForReadResult();
  2974. // Drop the old socket. This is needed because the Python test server can't
  2975. // service two sockets in parallel.
  2976. sock1.reset();
  2977. // Start a second connection.
  2978. ASSERT_TRUE(CreateAndConnectSSLClientSocket(client_config, &rv));
  2979. EXPECT_THAT(rv, IsOk());
  2980. // No session resumption because the first connection never received a server
  2981. // Finished message.
  2982. SSLInfo ssl_info;
  2983. EXPECT_TRUE(sock_->GetSSLInfo(&ssl_info));
  2984. EXPECT_EQ(SSLInfo::HANDSHAKE_FULL, ssl_info.handshake_type);
  2985. }
  2986. // Test that False Started sessions are not resumable if the server Finished
  2987. // message was bad.
  2988. TEST_F(SSLClientSocketFalseStartTest, NoSessionResumptionBadFinished) {
  2989. // Start a server.
  2990. SSLServerConfig server_config;
  2991. server_config.version_max = SSL_PROTOCOL_VERSION_TLS1_2;
  2992. server_config.cipher_suite_for_testing = kModernTLS12Cipher;
  2993. server_config.alpn_protos = {NextProto::kProtoHTTP11};
  2994. ASSERT_TRUE(
  2995. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  2996. SSLConfig client_config;
  2997. client_config.alpn_protos.push_back(kProtoHTTP11);
  2998. // Start a handshake up to the server Finished message.
  2999. TestCompletionCallback callback;
  3000. FakeBlockingStreamSocket* raw_transport1 = nullptr;
  3001. std::unique_ptr<SSLClientSocket> sock1;
  3002. ASSERT_NO_FATAL_FAILURE(CreateAndConnectUntilServerFinishedReceived(
  3003. client_config, &callback, &raw_transport1, &sock1));
  3004. // Although raw_transport1 has the server Finished blocked, the handshake
  3005. // still completes.
  3006. EXPECT_THAT(callback.WaitForResult(), IsOk());
  3007. // Continue to block the client (|sock1|) from processing the Finished
  3008. // message, but allow it to arrive on the socket. This ensures that, from the
  3009. // server's point of view, it has completed the handshake and added the
  3010. // session to its session cache.
  3011. //
  3012. // The actual read on |sock1| will not complete until the Finished message is
  3013. // processed; however, pump the underlying transport so that it is read from
  3014. // the socket.
  3015. scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(4096);
  3016. int rv = sock1->Read(buf.get(), 4096, callback.callback());
  3017. EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
  3018. raw_transport1->WaitForReadResult();
  3019. // The server's second leg, or part of it, is now received but not yet sent to
  3020. // |sock1|. Before doing so, break the server's second leg.
  3021. int bytes_read = raw_transport1->pending_read_result();
  3022. ASSERT_LT(0, bytes_read);
  3023. raw_transport1->pending_read_buf()->data()[bytes_read - 1]++;
  3024. // Unblock the Finished message. |sock1->Read| should now fail.
  3025. raw_transport1->UnblockReadResult();
  3026. EXPECT_THAT(callback.GetResult(rv), IsError(ERR_SSL_PROTOCOL_ERROR));
  3027. // Drop the old socket. This is needed because the Python test server can't
  3028. // service two sockets in parallel.
  3029. sock1.reset();
  3030. // Start a second connection.
  3031. ASSERT_TRUE(CreateAndConnectSSLClientSocket(client_config, &rv));
  3032. EXPECT_THAT(rv, IsOk());
  3033. // No session resumption because the first connection never received a server
  3034. // Finished message.
  3035. SSLInfo ssl_info;
  3036. EXPECT_TRUE(sock_->GetSSLInfo(&ssl_info));
  3037. EXPECT_EQ(SSLInfo::HANDSHAKE_FULL, ssl_info.handshake_type);
  3038. }
  3039. // Server preference should win in ALPN.
  3040. TEST_F(SSLClientSocketTest, Alpn) {
  3041. SSLServerConfig server_config;
  3042. server_config.alpn_protos = {NextProto::kProtoHTTP2, NextProto::kProtoHTTP11};
  3043. ASSERT_TRUE(
  3044. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  3045. SSLConfig client_config;
  3046. client_config.alpn_protos.push_back(kProtoHTTP11);
  3047. client_config.alpn_protos.push_back(kProtoHTTP2);
  3048. int rv;
  3049. ASSERT_TRUE(CreateAndConnectSSLClientSocket(client_config, &rv));
  3050. EXPECT_THAT(rv, IsOk());
  3051. EXPECT_EQ(kProtoHTTP2, sock_->GetNegotiatedProtocol());
  3052. }
  3053. // If the server supports ALPN but the client does not, then ALPN is not used.
  3054. TEST_F(SSLClientSocketTest, AlpnClientDisabled) {
  3055. SSLServerConfig server_config;
  3056. server_config.alpn_protos = {NextProto::kProtoHTTP2};
  3057. ASSERT_TRUE(
  3058. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  3059. SSLConfig client_config;
  3060. int rv;
  3061. ASSERT_TRUE(CreateAndConnectSSLClientSocket(client_config, &rv));
  3062. EXPECT_THAT(rv, IsOk());
  3063. EXPECT_EQ(kProtoUnknown, sock_->GetNegotiatedProtocol());
  3064. }
  3065. // Connect to a server requesting client authentication, do not send
  3066. // any client certificates. It should refuse the connection.
  3067. TEST_P(SSLClientSocketVersionTest, NoCert) {
  3068. SSLServerConfig server_config = GetServerConfig();
  3069. server_config.client_cert_type = SSLServerConfig::OPTIONAL_CLIENT_CERT;
  3070. ASSERT_TRUE(
  3071. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  3072. int rv;
  3073. ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
  3074. EXPECT_THAT(rv, IsError(ERR_SSL_CLIENT_AUTH_CERT_NEEDED));
  3075. EXPECT_FALSE(sock_->IsConnected());
  3076. }
  3077. // Connect to a server requesting client authentication, and send it
  3078. // an empty certificate.
  3079. TEST_P(SSLClientSocketVersionTest, SendEmptyCert) {
  3080. SSLServerConfig server_config = GetServerConfig();
  3081. server_config.client_cert_type = SSLServerConfig::OPTIONAL_CLIENT_CERT;
  3082. ASSERT_TRUE(
  3083. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  3084. context_->SetClientCertificate(host_port_pair(), nullptr, nullptr);
  3085. int rv;
  3086. ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
  3087. EXPECT_THAT(rv, IsOk());
  3088. EXPECT_TRUE(sock_->IsConnected());
  3089. SSLInfo ssl_info;
  3090. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  3091. EXPECT_FALSE(ssl_info.client_cert_sent);
  3092. }
  3093. // Connect to a server requesting client authentication and send a certificate.
  3094. TEST_P(SSLClientSocketVersionTest, SendGoodCert) {
  3095. base::FilePath certs_dir = GetTestCertsDirectory();
  3096. scoped_refptr<X509Certificate> client_cert =
  3097. ImportCertFromFile(certs_dir, "client_1.pem");
  3098. ASSERT_TRUE(client_cert);
  3099. // Configure the server to only accept |client_cert|.
  3100. MockClientCertVerifier verifier;
  3101. verifier.set_default_result(ERR_CERT_INVALID);
  3102. verifier.AddResultForCert(client_cert.get(), OK);
  3103. SSLServerConfig server_config = GetServerConfig();
  3104. server_config.client_cert_type = SSLServerConfig::REQUIRE_CLIENT_CERT;
  3105. server_config.client_cert_verifier = &verifier;
  3106. ASSERT_TRUE(
  3107. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  3108. context_->SetClientCertificate(
  3109. host_port_pair(), client_cert,
  3110. key_util::LoadPrivateKeyOpenSSL(certs_dir.AppendASCII("client_1.key")));
  3111. int rv;
  3112. ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
  3113. EXPECT_THAT(rv, IsOk());
  3114. EXPECT_TRUE(sock_->IsConnected());
  3115. SSLInfo ssl_info;
  3116. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  3117. EXPECT_TRUE(ssl_info.client_cert_sent);
  3118. sock_->Disconnect();
  3119. EXPECT_FALSE(sock_->IsConnected());
  3120. // Shut down the test server before |verifier| goes out of scope.
  3121. ASSERT_TRUE(embedded_test_server()->ShutdownAndWaitUntilComplete());
  3122. }
  3123. // When client certificate preferences change, the session cache should be
  3124. // cleared so the client certificate preferences are applied.
  3125. TEST_F(SSLClientSocketTest, ClearSessionCacheOnClientCertChange) {
  3126. SSLServerConfig server_config;
  3127. // TLS 1.3 reports client certificate errors after the handshake, so test at
  3128. // TLS 1.2 for simplicity.
  3129. server_config.version_max = SSL_PROTOCOL_VERSION_TLS1_2;
  3130. server_config.client_cert_type = SSLServerConfig::REQUIRE_CLIENT_CERT;
  3131. ASSERT_TRUE(
  3132. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  3133. // Connecting without a client certificate will fail with
  3134. // ERR_SSL_CLIENT_AUTH_CERT_NEEDED.
  3135. int rv;
  3136. ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
  3137. EXPECT_THAT(rv, IsError(ERR_SSL_CLIENT_AUTH_CERT_NEEDED));
  3138. // Configure a client certificate.
  3139. base::FilePath certs_dir = GetTestCertsDirectory();
  3140. context_->SetClientCertificate(
  3141. host_port_pair(), ImportCertFromFile(certs_dir, "client_1.pem"),
  3142. key_util::LoadPrivateKeyOpenSSL(certs_dir.AppendASCII("client_1.key")));
  3143. // Now the connection succeeds.
  3144. ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
  3145. EXPECT_THAT(rv, IsOk());
  3146. EXPECT_TRUE(sock_->IsConnected());
  3147. SSLInfo ssl_info;
  3148. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  3149. EXPECT_TRUE(ssl_info.client_cert_sent);
  3150. EXPECT_EQ(ssl_info.handshake_type, SSLInfo::HANDSHAKE_FULL);
  3151. // Make a second connection. This should resume the session from the previous
  3152. // connection.
  3153. ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
  3154. EXPECT_THAT(rv, IsOk());
  3155. EXPECT_TRUE(sock_->IsConnected());
  3156. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  3157. EXPECT_TRUE(ssl_info.client_cert_sent);
  3158. EXPECT_EQ(ssl_info.handshake_type, SSLInfo::HANDSHAKE_RESUME);
  3159. // Clear the client certificate preference.
  3160. context_->ClearClientCertificate(host_port_pair());
  3161. // Connections return to failing, rather than resume the previous session.
  3162. ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
  3163. EXPECT_THAT(rv, IsError(ERR_SSL_CLIENT_AUTH_CERT_NEEDED));
  3164. // Establish a new session with the correct client certificate.
  3165. context_->SetClientCertificate(
  3166. host_port_pair(), ImportCertFromFile(certs_dir, "client_1.pem"),
  3167. key_util::LoadPrivateKeyOpenSSL(certs_dir.AppendASCII("client_1.key")));
  3168. ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
  3169. EXPECT_THAT(rv, IsOk());
  3170. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  3171. EXPECT_TRUE(ssl_info.client_cert_sent);
  3172. EXPECT_EQ(ssl_info.handshake_type, SSLInfo::HANDSHAKE_FULL);
  3173. // Switch to continuing without a client certificate.
  3174. context_->SetClientCertificate(host_port_pair(), nullptr, nullptr);
  3175. // This also clears the session cache and the new preference is applied.
  3176. ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
  3177. EXPECT_THAT(rv, IsError(ERR_BAD_SSL_CLIENT_AUTH_CERT));
  3178. }
  3179. HashValueVector MakeHashValueVector(uint8_t value) {
  3180. HashValueVector out;
  3181. HashValue hash(HASH_VALUE_SHA256);
  3182. memset(hash.data(), value, hash.size());
  3183. out.push_back(hash);
  3184. return out;
  3185. }
  3186. // Test that |ssl_info.pkp_bypassed| is set when a local trust anchor causes
  3187. // pinning to be bypassed.
  3188. TEST_P(SSLClientSocketVersionTest, PKPBypassedSet) {
  3189. base::test::ScopedFeatureList scoped_feature_list_;
  3190. scoped_feature_list_.InitAndEnableFeature(
  3191. net::features::kStaticKeyPinningEnforcement);
  3192. ASSERT_TRUE(
  3193. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, GetServerConfig()));
  3194. scoped_refptr<X509Certificate> server_cert =
  3195. embedded_test_server()->GetCertificate();
  3196. // The certificate needs to be trusted, but chain to a local root with
  3197. // different public key hashes than specified in the pin.
  3198. CertVerifyResult verify_result;
  3199. verify_result.is_issued_by_known_root = false;
  3200. verify_result.verified_cert = server_cert;
  3201. verify_result.public_key_hashes =
  3202. MakeHashValueVector(kBadHashValueVectorInput);
  3203. cert_verifier_->AddResultForCert(server_cert.get(), verify_result, OK);
  3204. transport_security_state_->EnableStaticPinsForTesting();
  3205. transport_security_state_->SetPinningListAlwaysTimelyForTesting(true);
  3206. ScopedTransportSecurityStateSource scoped_security_state_source;
  3207. SSLConfig ssl_config;
  3208. int rv;
  3209. HostPortPair new_host_port_pair("example.test", host_port_pair().port());
  3210. ASSERT_TRUE(CreateAndConnectSSLClientSocketWithHost(ssl_config,
  3211. new_host_port_pair, &rv));
  3212. SSLInfo ssl_info;
  3213. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  3214. EXPECT_THAT(rv, IsOk());
  3215. EXPECT_TRUE(sock_->IsConnected());
  3216. EXPECT_TRUE(ssl_info.pkp_bypassed);
  3217. EXPECT_FALSE(ssl_info.cert_status & CERT_STATUS_PINNED_KEY_MISSING);
  3218. }
  3219. TEST_P(SSLClientSocketVersionTest, PKPEnforced) {
  3220. base::test::ScopedFeatureList scoped_feature_list_;
  3221. scoped_feature_list_.InitAndEnableFeature(
  3222. net::features::kStaticKeyPinningEnforcement);
  3223. ASSERT_TRUE(
  3224. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, GetServerConfig()));
  3225. scoped_refptr<X509Certificate> server_cert =
  3226. embedded_test_server()->GetCertificate();
  3227. // Certificate is trusted, but chains to a public root that doesn't match the
  3228. // pin hashes.
  3229. CertVerifyResult verify_result;
  3230. verify_result.is_issued_by_known_root = true;
  3231. verify_result.verified_cert = server_cert;
  3232. verify_result.public_key_hashes =
  3233. MakeHashValueVector(kBadHashValueVectorInput);
  3234. cert_verifier_->AddResultForCert(server_cert.get(), verify_result, OK);
  3235. transport_security_state_->EnableStaticPinsForTesting();
  3236. transport_security_state_->SetPinningListAlwaysTimelyForTesting(true);
  3237. ScopedTransportSecurityStateSource scoped_security_state_source;
  3238. SSLConfig ssl_config;
  3239. int rv;
  3240. HostPortPair new_host_port_pair("example.test", host_port_pair().port());
  3241. ASSERT_TRUE(CreateAndConnectSSLClientSocketWithHost(ssl_config,
  3242. new_host_port_pair, &rv));
  3243. SSLInfo ssl_info;
  3244. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  3245. EXPECT_THAT(rv, IsError(ERR_SSL_PINNED_KEY_NOT_IN_CERT_CHAIN));
  3246. EXPECT_TRUE(ssl_info.cert_status & CERT_STATUS_PINNED_KEY_MISSING);
  3247. EXPECT_FALSE(sock_->IsConnected());
  3248. EXPECT_FALSE(ssl_info.pkp_bypassed);
  3249. }
  3250. namespace {
  3251. // TLS_RSA_WITH_AES_128_GCM_SHA256's key exchange involves encrypting to the
  3252. // server long-term key.
  3253. const uint16_t kEncryptingCipher = kRSACipher;
  3254. // TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256's key exchange involves a signature by
  3255. // the server long-term key.
  3256. const uint16_t kSigningCipher = kModernTLS12Cipher;
  3257. } // namespace
  3258. struct KeyUsageTest {
  3259. EmbeddedTestServer::ServerCertificate server_cert;
  3260. uint16_t cipher_suite;
  3261. bool known_root;
  3262. bool success;
  3263. };
  3264. class SSLClientSocketKeyUsageTest
  3265. : public SSLClientSocketTest,
  3266. public ::testing::WithParamInterface<struct KeyUsageTest> {};
  3267. const struct KeyUsageTest kKeyUsageTests[] = {
  3268. // Known Root: Success iff keyUsage allows the key exchange method
  3269. {EmbeddedTestServer::CERT_KEY_USAGE_RSA_ENCIPHERMENT, kSigningCipher, true,
  3270. false},
  3271. {EmbeddedTestServer::CERT_KEY_USAGE_RSA_DIGITAL_SIGNATURE, kSigningCipher,
  3272. true, true},
  3273. {EmbeddedTestServer::CERT_KEY_USAGE_RSA_ENCIPHERMENT, kEncryptingCipher,
  3274. true, true},
  3275. {EmbeddedTestServer::CERT_KEY_USAGE_RSA_DIGITAL_SIGNATURE,
  3276. kEncryptingCipher, true, false},
  3277. // Unknown Root: Always succeeds
  3278. {EmbeddedTestServer::CERT_KEY_USAGE_RSA_ENCIPHERMENT, kSigningCipher, false,
  3279. true},
  3280. {EmbeddedTestServer::CERT_KEY_USAGE_RSA_DIGITAL_SIGNATURE, kSigningCipher,
  3281. false, true},
  3282. {EmbeddedTestServer::CERT_KEY_USAGE_RSA_ENCIPHERMENT, kEncryptingCipher,
  3283. false, true},
  3284. {EmbeddedTestServer::CERT_KEY_USAGE_RSA_DIGITAL_SIGNATURE,
  3285. kEncryptingCipher, false, true},
  3286. };
  3287. TEST_P(SSLClientSocketKeyUsageTest, RSAKeyUsageEnforcedForKnownRoot) {
  3288. const KeyUsageTest test = GetParam();
  3289. SSLServerConfig server_config;
  3290. server_config.version_max = SSL_PROTOCOL_VERSION_TLS1_2;
  3291. server_config.cipher_suite_for_testing = test.cipher_suite;
  3292. ASSERT_TRUE(StartEmbeddedTestServer(test.server_cert, server_config));
  3293. scoped_refptr<X509Certificate> server_cert =
  3294. embedded_test_server()->GetCertificate();
  3295. // Certificate is trusted.
  3296. CertVerifyResult verify_result;
  3297. verify_result.is_issued_by_known_root = test.known_root;
  3298. verify_result.verified_cert = server_cert;
  3299. verify_result.public_key_hashes =
  3300. MakeHashValueVector(kGoodHashValueVectorInput);
  3301. cert_verifier_->AddResultForCert(server_cert.get(), verify_result, OK);
  3302. SSLConfig ssl_config;
  3303. int rv;
  3304. ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
  3305. SSLInfo ssl_info;
  3306. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  3307. if (test.success) {
  3308. EXPECT_THAT(rv, IsOk());
  3309. EXPECT_TRUE(sock_->IsConnected());
  3310. } else {
  3311. EXPECT_THAT(rv, IsError(ERR_SSL_KEY_USAGE_INCOMPATIBLE));
  3312. EXPECT_FALSE(sock_->IsConnected());
  3313. }
  3314. }
  3315. INSTANTIATE_TEST_SUITE_P(RSAKeyUsageInstantiation,
  3316. SSLClientSocketKeyUsageTest,
  3317. ValuesIn(kKeyUsageTests));
  3318. // Test that when CT is required (in this case, by the delegate), the
  3319. // absence of CT information is a socket error.
  3320. TEST_P(SSLClientSocketVersionTest, CTIsRequired) {
  3321. ASSERT_TRUE(
  3322. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, GetServerConfig()));
  3323. scoped_refptr<X509Certificate> server_cert =
  3324. embedded_test_server()->GetCertificate();
  3325. // Certificate is trusted and chains to a public root.
  3326. CertVerifyResult verify_result;
  3327. verify_result.is_issued_by_known_root = true;
  3328. verify_result.verified_cert = server_cert;
  3329. verify_result.public_key_hashes =
  3330. MakeHashValueVector(kGoodHashValueVectorInput);
  3331. cert_verifier_->AddResultForCert(server_cert.get(), verify_result, OK);
  3332. // Set up CT
  3333. MockRequireCTDelegate require_ct_delegate;
  3334. transport_security_state_->SetRequireCTDelegate(&require_ct_delegate);
  3335. EXPECT_CALL(require_ct_delegate, IsCTRequiredForHost(_, _, _))
  3336. .WillRepeatedly(Return(TransportSecurityState::RequireCTDelegate::
  3337. CTRequirementLevel::NOT_REQUIRED));
  3338. EXPECT_CALL(require_ct_delegate,
  3339. IsCTRequiredForHost(host_port_pair().host(), _, _))
  3340. .WillRepeatedly(Return(TransportSecurityState::RequireCTDelegate::
  3341. CTRequirementLevel::REQUIRED));
  3342. EXPECT_CALL(*ct_policy_enforcer_, CheckCompliance(server_cert.get(), _, _))
  3343. .WillRepeatedly(
  3344. Return(ct::CTPolicyCompliance::CT_POLICY_NOT_ENOUGH_SCTS));
  3345. SSLConfig ssl_config;
  3346. int rv;
  3347. ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
  3348. SSLInfo ssl_info;
  3349. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  3350. EXPECT_THAT(rv, IsError(ERR_CERTIFICATE_TRANSPARENCY_REQUIRED));
  3351. EXPECT_TRUE(ssl_info.cert_status &
  3352. CERT_STATUS_CERTIFICATE_TRANSPARENCY_REQUIRED);
  3353. EXPECT_FALSE(sock_->IsConnected());
  3354. }
  3355. // Test that when CT is required, setting ignore_certificate_errors
  3356. // ignores errors in CT.
  3357. TEST_P(SSLClientSocketVersionTest, IgnoreCertificateErrorsBypassesRequiredCT) {
  3358. ASSERT_TRUE(
  3359. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, GetServerConfig()));
  3360. scoped_refptr<X509Certificate> server_cert =
  3361. embedded_test_server()->GetCertificate();
  3362. // Certificate is trusted and chains to a public root.
  3363. CertVerifyResult verify_result;
  3364. verify_result.is_issued_by_known_root = true;
  3365. verify_result.verified_cert = server_cert;
  3366. verify_result.public_key_hashes =
  3367. MakeHashValueVector(kGoodHashValueVectorInput);
  3368. cert_verifier_->AddResultForCert(server_cert.get(), verify_result, OK);
  3369. // Set up CT
  3370. MockRequireCTDelegate require_ct_delegate;
  3371. transport_security_state_->SetRequireCTDelegate(&require_ct_delegate);
  3372. EXPECT_CALL(require_ct_delegate, IsCTRequiredForHost(_, _, _))
  3373. .WillRepeatedly(Return(TransportSecurityState::RequireCTDelegate::
  3374. CTRequirementLevel::NOT_REQUIRED));
  3375. EXPECT_CALL(require_ct_delegate,
  3376. IsCTRequiredForHost(host_port_pair().host(), _, _))
  3377. .WillRepeatedly(Return(TransportSecurityState::RequireCTDelegate::
  3378. CTRequirementLevel::REQUIRED));
  3379. EXPECT_CALL(*ct_policy_enforcer_, CheckCompliance(server_cert.get(), _, _))
  3380. .WillRepeatedly(
  3381. Return(ct::CTPolicyCompliance::CT_POLICY_NOT_ENOUGH_SCTS));
  3382. SSLConfig ssl_config;
  3383. ssl_config.ignore_certificate_errors = true;
  3384. int rv;
  3385. ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
  3386. SSLInfo ssl_info;
  3387. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  3388. EXPECT_THAT(rv, IsOk());
  3389. EXPECT_TRUE(ssl_info.cert_status &
  3390. CERT_STATUS_CERTIFICATE_TRANSPARENCY_REQUIRED);
  3391. EXPECT_TRUE(sock_->IsConnected());
  3392. }
  3393. // Test that when CT is required (in this case, by an Expect-CT opt-in), the
  3394. // absence of CT information is a socket error.
  3395. TEST_P(SSLClientSocketVersionTest, CTIsRequiredByExpectCT) {
  3396. base::test::ScopedFeatureList feature_list;
  3397. feature_list.InitAndEnableFeature(
  3398. TransportSecurityState::kDynamicExpectCTFeature);
  3399. ASSERT_TRUE(
  3400. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, GetServerConfig()));
  3401. scoped_refptr<X509Certificate> server_cert =
  3402. embedded_test_server()->GetCertificate();
  3403. // Certificate is trusted and chains to a public root.
  3404. CertVerifyResult verify_result;
  3405. verify_result.is_issued_by_known_root = true;
  3406. verify_result.verified_cert = server_cert;
  3407. verify_result.public_key_hashes =
  3408. MakeHashValueVector(kGoodHashValueVectorInput);
  3409. cert_verifier_->AddResultForCert(server_cert.get(), verify_result, OK);
  3410. // Set up the Expect-CT opt-in.
  3411. NetworkIsolationKey network_isolation_key =
  3412. NetworkIsolationKey::CreateTransient();
  3413. const base::Time current_time(base::Time::Now());
  3414. const base::Time expiry = current_time + base::Seconds(1000);
  3415. transport_security_state_->AddExpectCT(
  3416. host_port_pair().host(), expiry, true /* enforce */,
  3417. GURL("https://example-report.test"), network_isolation_key);
  3418. MockExpectCTReporter reporter;
  3419. transport_security_state_->SetExpectCTReporter(&reporter);
  3420. EXPECT_CALL(*ct_policy_enforcer_, CheckCompliance(server_cert.get(), _, _))
  3421. .WillRepeatedly(
  3422. Return(ct::CTPolicyCompliance::CT_POLICY_NOT_ENOUGH_SCTS));
  3423. SSLConfig ssl_config;
  3424. ssl_config.network_isolation_key = network_isolation_key;
  3425. int rv;
  3426. ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
  3427. SSLInfo ssl_info;
  3428. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  3429. EXPECT_THAT(rv, IsError(ERR_CERTIFICATE_TRANSPARENCY_REQUIRED));
  3430. EXPECT_TRUE(ssl_info.cert_status &
  3431. CERT_STATUS_CERTIFICATE_TRANSPARENCY_REQUIRED);
  3432. EXPECT_FALSE(sock_->IsConnected());
  3433. EXPECT_EQ(1u, reporter.num_failures());
  3434. EXPECT_EQ(GURL("https://example-report.test"), reporter.report_uri());
  3435. EXPECT_EQ(ssl_info.unverified_cert.get(),
  3436. reporter.served_certificate_chain());
  3437. EXPECT_EQ(ssl_info.cert.get(), reporter.validated_certificate_chain());
  3438. EXPECT_EQ(0u, reporter.signed_certificate_timestamps().size());
  3439. EXPECT_EQ(network_isolation_key, reporter.network_isolation_key());
  3440. transport_security_state_->ClearReportCachesForTesting();
  3441. EXPECT_CALL(*ct_policy_enforcer_, CheckCompliance(server_cert.get(), _, _))
  3442. .WillRepeatedly(
  3443. Return(ct::CTPolicyCompliance::CT_POLICY_NOT_DIVERSE_SCTS));
  3444. ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
  3445. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  3446. EXPECT_THAT(rv, IsError(ERR_CERTIFICATE_TRANSPARENCY_REQUIRED));
  3447. EXPECT_TRUE(ssl_info.cert_status &
  3448. CERT_STATUS_CERTIFICATE_TRANSPARENCY_REQUIRED);
  3449. EXPECT_FALSE(sock_->IsConnected());
  3450. EXPECT_EQ(2u, reporter.num_failures());
  3451. EXPECT_EQ(GURL("https://example-report.test"), reporter.report_uri());
  3452. EXPECT_EQ(ssl_info.unverified_cert.get(),
  3453. reporter.served_certificate_chain());
  3454. EXPECT_EQ(ssl_info.cert.get(), reporter.validated_certificate_chain());
  3455. EXPECT_EQ(0u, reporter.signed_certificate_timestamps().size());
  3456. EXPECT_EQ(network_isolation_key, reporter.network_isolation_key());
  3457. // If the connection is CT compliant, then there should be no socket error nor
  3458. // a report.
  3459. EXPECT_CALL(*ct_policy_enforcer_, CheckCompliance(server_cert.get(), _, _))
  3460. .WillRepeatedly(
  3461. Return(ct::CTPolicyCompliance::CT_POLICY_COMPLIES_VIA_SCTS));
  3462. ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
  3463. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  3464. EXPECT_EQ(net::OK, rv);
  3465. EXPECT_FALSE(ssl_info.cert_status &
  3466. CERT_STATUS_CERTIFICATE_TRANSPARENCY_REQUIRED);
  3467. EXPECT_TRUE(sock_->IsConnected());
  3468. EXPECT_EQ(2u, reporter.num_failures());
  3469. EXPECT_CALL(*ct_policy_enforcer_, CheckCompliance(server_cert.get(), _, _))
  3470. .WillRepeatedly(
  3471. Return(ct::CTPolicyCompliance::CT_POLICY_BUILD_NOT_TIMELY));
  3472. ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
  3473. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  3474. EXPECT_EQ(net::OK, rv);
  3475. EXPECT_FALSE(ssl_info.cert_status &
  3476. CERT_STATUS_CERTIFICATE_TRANSPARENCY_REQUIRED);
  3477. EXPECT_TRUE(sock_->IsConnected());
  3478. EXPECT_EQ(2u, reporter.num_failures());
  3479. }
  3480. // When both PKP and CT are required for a host, and both fail, the more
  3481. // serious error is that the pin validation failed.
  3482. TEST_P(SSLClientSocketVersionTest, PKPMoreImportantThanCT) {
  3483. base::test::ScopedFeatureList scoped_feature_list_;
  3484. scoped_feature_list_.InitAndEnableFeature(
  3485. net::features::kStaticKeyPinningEnforcement);
  3486. ASSERT_TRUE(
  3487. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, GetServerConfig()));
  3488. scoped_refptr<X509Certificate> server_cert =
  3489. embedded_test_server()->GetCertificate();
  3490. // Certificate is trusted, but chains to a public root that doesn't match the
  3491. // pin hashes.
  3492. CertVerifyResult verify_result;
  3493. verify_result.is_issued_by_known_root = true;
  3494. verify_result.verified_cert = server_cert;
  3495. verify_result.public_key_hashes =
  3496. MakeHashValueVector(kBadHashValueVectorInput);
  3497. cert_verifier_->AddResultForCert(server_cert.get(), verify_result, OK);
  3498. transport_security_state_->EnableStaticPinsForTesting();
  3499. transport_security_state_->SetPinningListAlwaysTimelyForTesting(true);
  3500. ScopedTransportSecurityStateSource scoped_security_state_source;
  3501. const char kCTHost[] = "pkp-expect-ct.preloaded.test";
  3502. // Set up CT.
  3503. MockRequireCTDelegate require_ct_delegate;
  3504. transport_security_state_->SetRequireCTDelegate(&require_ct_delegate);
  3505. EXPECT_CALL(require_ct_delegate, IsCTRequiredForHost(_, _, _))
  3506. .WillRepeatedly(Return(TransportSecurityState::RequireCTDelegate::
  3507. CTRequirementLevel::NOT_REQUIRED));
  3508. EXPECT_CALL(require_ct_delegate, IsCTRequiredForHost(kCTHost, _, _))
  3509. .WillRepeatedly(Return(TransportSecurityState::RequireCTDelegate::
  3510. CTRequirementLevel::REQUIRED));
  3511. EXPECT_CALL(*ct_policy_enforcer_, CheckCompliance(server_cert.get(), _, _))
  3512. .WillRepeatedly(
  3513. Return(ct::CTPolicyCompliance::CT_POLICY_NOT_ENOUGH_SCTS));
  3514. SSLConfig ssl_config;
  3515. int rv;
  3516. HostPortPair ct_host_port_pair(kCTHost, host_port_pair().port());
  3517. ASSERT_TRUE(CreateAndConnectSSLClientSocketWithHost(ssl_config,
  3518. ct_host_port_pair, &rv));
  3519. SSLInfo ssl_info;
  3520. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  3521. EXPECT_THAT(rv, IsError(ERR_SSL_PINNED_KEY_NOT_IN_CERT_CHAIN));
  3522. EXPECT_TRUE(ssl_info.cert_status & CERT_STATUS_PINNED_KEY_MISSING);
  3523. EXPECT_TRUE(ssl_info.cert_status &
  3524. CERT_STATUS_CERTIFICATE_TRANSPARENCY_REQUIRED);
  3525. EXPECT_FALSE(sock_->IsConnected());
  3526. }
  3527. // Tests that the SCTAuditingDelegate is called to enqueue SCT reports.
  3528. TEST_P(SSLClientSocketVersionTest, SCTAuditingReportCollected) {
  3529. ASSERT_TRUE(
  3530. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, GetServerConfig()));
  3531. scoped_refptr<X509Certificate> server_cert =
  3532. embedded_test_server()->GetCertificate();
  3533. // Certificate is trusted and chains to a public root.
  3534. CertVerifyResult verify_result;
  3535. verify_result.is_issued_by_known_root = true;
  3536. verify_result.verified_cert = server_cert;
  3537. verify_result.public_key_hashes =
  3538. MakeHashValueVector(kGoodHashValueVectorInput);
  3539. cert_verifier_->AddResultForCert(server_cert.get(), verify_result, OK);
  3540. // Set up CT and auditing delegate.
  3541. MockRequireCTDelegate require_ct_delegate;
  3542. transport_security_state_->SetRequireCTDelegate(&require_ct_delegate);
  3543. EXPECT_CALL(require_ct_delegate, IsCTRequiredForHost(_, _, _))
  3544. .WillRepeatedly(Return(TransportSecurityState::RequireCTDelegate::
  3545. CTRequirementLevel::REQUIRED));
  3546. EXPECT_CALL(*ct_policy_enforcer_, CheckCompliance(server_cert.get(), _, _))
  3547. .WillRepeatedly(
  3548. Return(ct::CTPolicyCompliance::CT_POLICY_COMPLIES_VIA_SCTS));
  3549. MockSCTAuditingDelegate sct_auditing_delegate;
  3550. context_ = std::make_unique<SSLClientContext>(
  3551. ssl_config_service_.get(), cert_verifier_.get(),
  3552. transport_security_state_.get(), ct_policy_enforcer_.get(),
  3553. ssl_client_session_cache_.get(), &sct_auditing_delegate);
  3554. EXPECT_CALL(sct_auditing_delegate, IsSCTAuditingEnabled())
  3555. .WillRepeatedly(Return(true));
  3556. EXPECT_CALL(sct_auditing_delegate,
  3557. MaybeEnqueueReport(host_port_pair(), server_cert.get(), _))
  3558. .Times(1);
  3559. SSLConfig ssl_config;
  3560. int rv;
  3561. ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
  3562. EXPECT_THAT(rv, 0);
  3563. EXPECT_TRUE(sock_->IsConnected());
  3564. }
  3565. // Test that handshake_failure alerts at the ServerHello are mapped to
  3566. // ERR_SSL_VERSION_OR_CIPHER_MISMATCH.
  3567. TEST_F(SSLClientSocketTest, HandshakeFailureServerHello) {
  3568. ASSERT_TRUE(
  3569. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, SSLServerConfig()));
  3570. TestCompletionCallback callback;
  3571. auto real_transport = std::make_unique<TCPClientSocket>(
  3572. addr(), nullptr, nullptr, nullptr, NetLogSource());
  3573. auto transport =
  3574. std::make_unique<FakeBlockingStreamSocket>(std::move(real_transport));
  3575. FakeBlockingStreamSocket* raw_transport = transport.get();
  3576. int rv = callback.GetResult(transport->Connect(callback.callback()));
  3577. ASSERT_THAT(rv, IsOk());
  3578. std::unique_ptr<SSLClientSocket> sock(CreateSSLClientSocket(
  3579. std::move(transport), host_port_pair(), SSLConfig()));
  3580. // Connect. Stop before the client processes ServerHello.
  3581. raw_transport->BlockReadResult();
  3582. rv = sock->Connect(callback.callback());
  3583. ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
  3584. raw_transport->WaitForReadResult();
  3585. // Replace it with an alert.
  3586. raw_transport->ReplaceReadResult(
  3587. FormatTLS12Alert(40 /* AlertDescription.handshake_failure */));
  3588. raw_transport->UnblockReadResult();
  3589. rv = callback.GetResult(rv);
  3590. EXPECT_THAT(rv, IsError(ERR_SSL_VERSION_OR_CIPHER_MISMATCH));
  3591. }
  3592. // Test that handshake_failure alerts after the ServerHello but without a
  3593. // CertificateRequest are mapped to ERR_SSL_PROTOCOL_ERROR.
  3594. TEST_F(SSLClientSocketTest, HandshakeFailureNoClientCerts) {
  3595. SSLServerConfig server_config;
  3596. server_config.version_max = SSL_PROTOCOL_VERSION_TLS1_2;
  3597. ASSERT_TRUE(
  3598. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  3599. TestCompletionCallback callback;
  3600. auto real_transport = std::make_unique<TCPClientSocket>(
  3601. addr(), nullptr, nullptr, nullptr, NetLogSource());
  3602. auto transport =
  3603. std::make_unique<FakeBlockingStreamSocket>(std::move(real_transport));
  3604. FakeBlockingStreamSocket* raw_transport = transport.get();
  3605. int rv = callback.GetResult(transport->Connect(callback.callback()));
  3606. ASSERT_THAT(rv, IsOk());
  3607. std::unique_ptr<SSLClientSocket> sock(CreateSSLClientSocket(
  3608. std::move(transport), host_port_pair(), SSLConfig()));
  3609. // Connect. Stop before the client processes ServerHello.
  3610. raw_transport->BlockReadResult();
  3611. rv = sock->Connect(callback.callback());
  3612. ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
  3613. raw_transport->WaitForReadResult();
  3614. // Release the ServerHello and wait for the client to write its second flight.
  3615. raw_transport->BlockWrite();
  3616. raw_transport->UnblockReadResult();
  3617. raw_transport->WaitForWrite();
  3618. // Wait for the server's final flight.
  3619. raw_transport->BlockReadResult();
  3620. raw_transport->UnblockWrite();
  3621. raw_transport->WaitForReadResult();
  3622. // Replace it with an alert.
  3623. raw_transport->ReplaceReadResult(
  3624. FormatTLS12Alert(40 /* AlertDescription.handshake_failure */));
  3625. raw_transport->UnblockReadResult();
  3626. rv = callback.GetResult(rv);
  3627. EXPECT_THAT(rv, IsError(ERR_SSL_PROTOCOL_ERROR));
  3628. }
  3629. // Test that handshake_failure alerts after the ServerHello map to
  3630. // ERR_BAD_SSL_CLIENT_AUTH_CERT if a client certificate was requested but not
  3631. // supplied. TLS does not have an alert for this case, so handshake_failure is
  3632. // common. See https://crbug.com/646567.
  3633. TEST_F(SSLClientSocketTest, LateHandshakeFailureMissingClientCerts) {
  3634. // Request a client certificate.
  3635. SSLServerConfig server_config;
  3636. server_config.version_max = SSL_PROTOCOL_VERSION_TLS1_2;
  3637. server_config.client_cert_type = SSLServerConfig::OPTIONAL_CLIENT_CERT;
  3638. ASSERT_TRUE(
  3639. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  3640. TestCompletionCallback callback;
  3641. auto real_transport = std::make_unique<TCPClientSocket>(
  3642. addr(), nullptr, nullptr, nullptr, NetLogSource());
  3643. auto transport =
  3644. std::make_unique<FakeBlockingStreamSocket>(std::move(real_transport));
  3645. FakeBlockingStreamSocket* raw_transport = transport.get();
  3646. int rv = callback.GetResult(transport->Connect(callback.callback()));
  3647. ASSERT_THAT(rv, IsOk());
  3648. // Send no client certificate.
  3649. context_->SetClientCertificate(host_port_pair(), nullptr, nullptr);
  3650. std::unique_ptr<SSLClientSocket> sock(CreateSSLClientSocket(
  3651. std::move(transport), host_port_pair(), SSLConfig()));
  3652. // Connect. Stop before the client processes ServerHello.
  3653. raw_transport->BlockReadResult();
  3654. rv = sock->Connect(callback.callback());
  3655. ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
  3656. raw_transport->WaitForReadResult();
  3657. // Release the ServerHello and wait for the client to write its second flight.
  3658. raw_transport->BlockWrite();
  3659. raw_transport->UnblockReadResult();
  3660. raw_transport->WaitForWrite();
  3661. // Wait for the server's final flight.
  3662. raw_transport->BlockReadResult();
  3663. raw_transport->UnblockWrite();
  3664. raw_transport->WaitForReadResult();
  3665. // Replace it with an alert.
  3666. raw_transport->ReplaceReadResult(
  3667. FormatTLS12Alert(40 /* AlertDescription.handshake_failure */));
  3668. raw_transport->UnblockReadResult();
  3669. rv = callback.GetResult(rv);
  3670. EXPECT_THAT(rv, IsError(ERR_BAD_SSL_CLIENT_AUTH_CERT));
  3671. }
  3672. // Test that handshake_failure alerts after the ServerHello map to
  3673. // ERR_SSL_PROTOCOL_ERROR if received after sending a client certificate. It is
  3674. // assumed servers will send a more appropriate alert in this case.
  3675. TEST_F(SSLClientSocketTest, LateHandshakeFailureSendClientCerts) {
  3676. // Request a client certificate.
  3677. SSLServerConfig server_config;
  3678. server_config.version_max = SSL_PROTOCOL_VERSION_TLS1_2;
  3679. server_config.client_cert_type = SSLServerConfig::OPTIONAL_CLIENT_CERT;
  3680. ASSERT_TRUE(
  3681. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  3682. TestCompletionCallback callback;
  3683. auto real_transport = std::make_unique<TCPClientSocket>(
  3684. addr(), nullptr, nullptr, nullptr, NetLogSource());
  3685. auto transport =
  3686. std::make_unique<FakeBlockingStreamSocket>(std::move(real_transport));
  3687. FakeBlockingStreamSocket* raw_transport = transport.get();
  3688. int rv = callback.GetResult(transport->Connect(callback.callback()));
  3689. ASSERT_THAT(rv, IsOk());
  3690. // Send a client certificate.
  3691. base::FilePath certs_dir = GetTestCertsDirectory();
  3692. context_->SetClientCertificate(
  3693. host_port_pair(), ImportCertFromFile(certs_dir, "client_1.pem"),
  3694. key_util::LoadPrivateKeyOpenSSL(certs_dir.AppendASCII("client_1.key")));
  3695. std::unique_ptr<SSLClientSocket> sock(CreateSSLClientSocket(
  3696. std::move(transport), host_port_pair(), SSLConfig()));
  3697. // Connect. Stop before the client processes ServerHello.
  3698. raw_transport->BlockReadResult();
  3699. rv = sock->Connect(callback.callback());
  3700. ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
  3701. raw_transport->WaitForReadResult();
  3702. // Release the ServerHello and wait for the client to write its second flight.
  3703. raw_transport->BlockWrite();
  3704. raw_transport->UnblockReadResult();
  3705. raw_transport->WaitForWrite();
  3706. // Wait for the server's final flight.
  3707. raw_transport->BlockReadResult();
  3708. raw_transport->UnblockWrite();
  3709. raw_transport->WaitForReadResult();
  3710. // Replace it with an alert.
  3711. raw_transport->ReplaceReadResult(
  3712. FormatTLS12Alert(40 /* AlertDescription.handshake_failure */));
  3713. raw_transport->UnblockReadResult();
  3714. rv = callback.GetResult(rv);
  3715. EXPECT_THAT(rv, IsError(ERR_SSL_PROTOCOL_ERROR));
  3716. }
  3717. // Test that access_denied alerts are mapped to ERR_SSL_PROTOCOL_ERROR if
  3718. // received on a connection not requesting client certificates. This is an
  3719. // incorrect use of the alert but is common. See https://crbug.com/630883.
  3720. TEST_F(SSLClientSocketTest, AccessDeniedNoClientCerts) {
  3721. // Request a client certificate.
  3722. SSLServerConfig server_config;
  3723. server_config.version_max = SSL_PROTOCOL_VERSION_TLS1_2;
  3724. ASSERT_TRUE(
  3725. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  3726. TestCompletionCallback callback;
  3727. auto real_transport = std::make_unique<TCPClientSocket>(
  3728. addr(), nullptr, nullptr, nullptr, NetLogSource());
  3729. auto transport =
  3730. std::make_unique<FakeBlockingStreamSocket>(std::move(real_transport));
  3731. FakeBlockingStreamSocket* raw_transport = transport.get();
  3732. int rv = callback.GetResult(transport->Connect(callback.callback()));
  3733. ASSERT_THAT(rv, IsOk());
  3734. std::unique_ptr<SSLClientSocket> sock(CreateSSLClientSocket(
  3735. std::move(transport), host_port_pair(), SSLConfig()));
  3736. // Connect. Stop before the client processes ServerHello.
  3737. raw_transport->BlockReadResult();
  3738. rv = sock->Connect(callback.callback());
  3739. ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
  3740. raw_transport->WaitForReadResult();
  3741. // Release the ServerHello and wait for the client to write its second flight.
  3742. raw_transport->BlockWrite();
  3743. raw_transport->UnblockReadResult();
  3744. raw_transport->WaitForWrite();
  3745. // Wait for the server's final flight.
  3746. raw_transport->BlockReadResult();
  3747. raw_transport->UnblockWrite();
  3748. raw_transport->WaitForReadResult();
  3749. // Replace it with an alert.
  3750. raw_transport->ReplaceReadResult(
  3751. FormatTLS12Alert(49 /* AlertDescription.access_denied */));
  3752. raw_transport->UnblockReadResult();
  3753. rv = callback.GetResult(rv);
  3754. EXPECT_THAT(rv, IsError(ERR_SSL_PROTOCOL_ERROR));
  3755. }
  3756. // Test that access_denied alerts are mapped to ERR_BAD_SSL_CLIENT_AUTH_CERT if
  3757. // received on a connection requesting client certificates.
  3758. TEST_F(SSLClientSocketTest, AccessDeniedClientCerts) {
  3759. // Request a client certificate.
  3760. SSLServerConfig server_config;
  3761. server_config.version_max = SSL_PROTOCOL_VERSION_TLS1_2;
  3762. server_config.client_cert_type = SSLServerConfig::OPTIONAL_CLIENT_CERT;
  3763. ASSERT_TRUE(
  3764. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  3765. TestCompletionCallback callback;
  3766. auto real_transport = std::make_unique<TCPClientSocket>(
  3767. addr(), nullptr, nullptr, nullptr, NetLogSource());
  3768. auto transport =
  3769. std::make_unique<FakeBlockingStreamSocket>(std::move(real_transport));
  3770. FakeBlockingStreamSocket* raw_transport = transport.get();
  3771. int rv = callback.GetResult(transport->Connect(callback.callback()));
  3772. ASSERT_THAT(rv, IsOk());
  3773. // Send a client certificate.
  3774. base::FilePath certs_dir = GetTestCertsDirectory();
  3775. context_->SetClientCertificate(
  3776. host_port_pair(), ImportCertFromFile(certs_dir, "client_1.pem"),
  3777. key_util::LoadPrivateKeyOpenSSL(certs_dir.AppendASCII("client_1.key")));
  3778. std::unique_ptr<SSLClientSocket> sock(CreateSSLClientSocket(
  3779. std::move(transport), host_port_pair(), SSLConfig()));
  3780. // Connect. Stop before the client processes ServerHello.
  3781. raw_transport->BlockReadResult();
  3782. rv = sock->Connect(callback.callback());
  3783. ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
  3784. raw_transport->WaitForReadResult();
  3785. // Release the ServerHello and wait for the client to write its second flight.
  3786. raw_transport->BlockWrite();
  3787. raw_transport->UnblockReadResult();
  3788. raw_transport->WaitForWrite();
  3789. // Wait for the server's final flight.
  3790. raw_transport->BlockReadResult();
  3791. raw_transport->UnblockWrite();
  3792. raw_transport->WaitForReadResult();
  3793. // Replace it with an alert.
  3794. raw_transport->ReplaceReadResult(
  3795. FormatTLS12Alert(49 /* AlertDescription.access_denied */));
  3796. raw_transport->UnblockReadResult();
  3797. rv = callback.GetResult(rv);
  3798. EXPECT_THAT(rv, IsError(ERR_BAD_SSL_CLIENT_AUTH_CERT));
  3799. }
  3800. // Test the client can send application data before the ServerHello comes in.
  3801. TEST_F(SSLClientSocketZeroRTTTest, ZeroRTTEarlyDataBeforeServerHello) {
  3802. ASSERT_TRUE(StartServer());
  3803. ASSERT_TRUE(RunInitialConnection());
  3804. // Make a 0-RTT Connection. Connect() and Write() complete even though the
  3805. // ServerHello is blocked.
  3806. FakeBlockingStreamSocket* socket = MakeClient(true);
  3807. socket->BlockReadResult();
  3808. ASSERT_THAT(Connect(), IsOk());
  3809. constexpr base::StringPiece kRequest = "GET /zerortt HTTP/1.0\r\n\r\n";
  3810. EXPECT_EQ(static_cast<int>(kRequest.size()), WriteAndWait(kRequest));
  3811. // Release the ServerHello. Now reads complete.
  3812. socket->UnblockReadResult();
  3813. scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(4096);
  3814. int size = ReadAndWait(buf.get(), 4096);
  3815. EXPECT_GT(size, 0);
  3816. EXPECT_EQ('1', buf->data()[size - 1]);
  3817. SSLInfo ssl_info;
  3818. ASSERT_TRUE(GetSSLInfo(&ssl_info));
  3819. EXPECT_EQ(SSLInfo::HANDSHAKE_RESUME, ssl_info.handshake_type);
  3820. }
  3821. // Test that the client sends 1-RTT data if the ServerHello happens to come in
  3822. // before Write() is called. See https://crbug.com/950706.
  3823. TEST_F(SSLClientSocketZeroRTTTest, ZeroRTTEarlyDataAfterServerHello) {
  3824. ASSERT_TRUE(StartServer());
  3825. ASSERT_TRUE(RunInitialConnection());
  3826. // Make a 0-RTT Connection. Connect() completes even though the ServerHello is
  3827. // blocked.
  3828. FakeBlockingStreamSocket* socket = MakeClient(true);
  3829. socket->BlockReadResult();
  3830. ASSERT_THAT(Connect(), IsOk());
  3831. // Wait for the ServerHello to come in and for SSLClientSocket to process it.
  3832. socket->WaitForReadResult();
  3833. socket->UnblockReadResult();
  3834. base::RunLoop().RunUntilIdle();
  3835. // Now write to the socket.
  3836. constexpr base::StringPiece kRequest = "GET /zerortt HTTP/1.0\r\n\r\n";
  3837. EXPECT_EQ(static_cast<int>(kRequest.size()), WriteAndWait(kRequest));
  3838. // Although the socket was created in early data state and the client never
  3839. // explicitly called ReaD() or ConfirmHandshake(), SSLClientSocketImpl
  3840. // internally consumed the ServerHello and switch keys. The server then
  3841. // responds with '0'.
  3842. scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(4096);
  3843. int size = ReadAndWait(buf.get(), 4096);
  3844. EXPECT_GT(size, 0);
  3845. EXPECT_EQ('0', buf->data()[size - 1]);
  3846. SSLInfo ssl_info;
  3847. ASSERT_TRUE(GetSSLInfo(&ssl_info));
  3848. EXPECT_EQ(SSLInfo::HANDSHAKE_RESUME, ssl_info.handshake_type);
  3849. }
  3850. // Check that 0RTT is confirmed after a Write and Read.
  3851. TEST_F(SSLClientSocketZeroRTTTest, ZeroRTTConfirmedAfterRead) {
  3852. ASSERT_TRUE(StartServer());
  3853. ASSERT_TRUE(RunInitialConnection());
  3854. // Make a 0-RTT Connection. Connect() and Write() complete even though the
  3855. // ServerHello is blocked.
  3856. FakeBlockingStreamSocket* socket = MakeClient(true);
  3857. socket->BlockReadResult();
  3858. ASSERT_THAT(Connect(), IsOk());
  3859. constexpr base::StringPiece kRequest = "GET /zerortt HTTP/1.0\r\n\r\n";
  3860. EXPECT_EQ(static_cast<int>(kRequest.size()), WriteAndWait(kRequest));
  3861. socket->UnblockReadResult();
  3862. scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(4096);
  3863. int size = ReadAndWait(buf.get(), 4096);
  3864. EXPECT_GT(size, 0);
  3865. EXPECT_EQ('1', buf->data()[size - 1]);
  3866. // After the handshake is confirmed, ConfirmHandshake should return
  3867. // synchronously.
  3868. TestCompletionCallback callback;
  3869. ASSERT_THAT(ssl_socket()->ConfirmHandshake(callback.callback()), IsOk());
  3870. SSLInfo ssl_info;
  3871. ASSERT_TRUE(GetSSLInfo(&ssl_info));
  3872. EXPECT_EQ(SSLInfo::HANDSHAKE_RESUME, ssl_info.handshake_type);
  3873. }
  3874. // Test that writes wait for the ServerHello once it has reached the early data
  3875. // limit.
  3876. TEST_F(SSLClientSocketZeroRTTTest, ZeroRTTEarlyDataLimit) {
  3877. ASSERT_TRUE(StartServer());
  3878. ASSERT_TRUE(RunInitialConnection());
  3879. // Make a 0-RTT Connection. Connect() completes even though the ServerHello is
  3880. // blocked.
  3881. FakeBlockingStreamSocket* socket = MakeClient(true);
  3882. socket->BlockReadResult();
  3883. ASSERT_THAT(Connect(), IsOk());
  3884. // EmbeddedTestServer uses BoringSSL's hard-coded early data limit, which is
  3885. // below 16k.
  3886. constexpr size_t kRequestSize = 16 * 1024;
  3887. std::string request = "GET /zerortt HTTP/1.0\r\n";
  3888. while (request.size() < kRequestSize) {
  3889. request += "The-Answer-To-Life-The-Universe-And-Everything: 42\r\n";
  3890. }
  3891. request += "\r\n";
  3892. // Writing the large input should not succeed. It is blocked on the
  3893. // ServerHello.
  3894. TestCompletionCallback write_callback;
  3895. auto write_buf = base::MakeRefCounted<StringIOBuffer>(request);
  3896. int write_rv = ssl_socket()->Write(write_buf.get(), request.size(),
  3897. write_callback.callback(),
  3898. TRAFFIC_ANNOTATION_FOR_TESTS);
  3899. ASSERT_THAT(write_rv, IsError(ERR_IO_PENDING));
  3900. // The Write should have issued a read for the ServerHello, so
  3901. // WaitForReadResult has something to wait for.
  3902. socket->WaitForReadResult();
  3903. EXPECT_TRUE(socket->pending_read_result());
  3904. // Queue a read. It should be blocked on the ServerHello.
  3905. TestCompletionCallback read_callback;
  3906. auto read_buf = base::MakeRefCounted<IOBuffer>(4096);
  3907. int read_rv =
  3908. ssl_socket()->Read(read_buf.get(), 4096, read_callback.callback());
  3909. ASSERT_THAT(read_rv, IsError(ERR_IO_PENDING));
  3910. // Also queue a ConfirmHandshake. It should also be blocked on ServerHello.
  3911. TestCompletionCallback confirm_callback;
  3912. int confirm_rv = ssl_socket()->ConfirmHandshake(confirm_callback.callback());
  3913. ASSERT_THAT(confirm_rv, IsError(ERR_IO_PENDING));
  3914. // Double-check the write was not accidentally blocked on the network.
  3915. base::RunLoop().RunUntilIdle();
  3916. EXPECT_FALSE(write_callback.have_result());
  3917. // At this point, the maximum possible number of events are all blocked on the
  3918. // same thing. Release the ServerHello. All three should complete.
  3919. socket->UnblockReadResult();
  3920. EXPECT_EQ(static_cast<int>(request.size()),
  3921. write_callback.GetResult(write_rv));
  3922. EXPECT_THAT(confirm_callback.GetResult(confirm_rv), IsOk());
  3923. int size = read_callback.GetResult(read_rv);
  3924. ASSERT_GT(size, 0);
  3925. EXPECT_EQ('1', read_buf->data()[size - 1]);
  3926. SSLInfo ssl_info;
  3927. ASSERT_TRUE(GetSSLInfo(&ssl_info));
  3928. EXPECT_EQ(SSLInfo::HANDSHAKE_RESUME, ssl_info.handshake_type);
  3929. }
  3930. // When a client socket reaches the 0-RTT early data limit, both Write() and
  3931. // ConfirmHandshake() become blocked on a transport read. Test that
  3932. // CancelReadIfReady() does not interrupt those.
  3933. TEST_F(SSLClientSocketZeroRTTTest, ZeroRTTEarlyDataLimitCancelReadIfReady) {
  3934. ASSERT_TRUE(StartServer());
  3935. ASSERT_TRUE(RunInitialConnection());
  3936. // Make a 0-RTT Connection. Connect() completes even though the ServerHello is
  3937. // blocked.
  3938. FakeBlockingStreamSocket* socket = MakeClient(true);
  3939. socket->BlockReadResult();
  3940. ASSERT_THAT(Connect(), IsOk());
  3941. // EmbeddedTestServer uses BoringSSL's hard-coded early data limit, which is
  3942. // below 16k.
  3943. constexpr size_t kRequestSize = 16 * 1024;
  3944. std::string request = "GET /zerortt HTTP/1.0\r\n";
  3945. while (request.size() < kRequestSize) {
  3946. request += "The-Answer-To-Life-The-Universe-And-Everything: 42\r\n";
  3947. }
  3948. request += "\r\n";
  3949. // Writing the large input should not succeed. It is blocked on the
  3950. // ServerHello.
  3951. TestCompletionCallback write_callback;
  3952. auto write_buf = base::MakeRefCounted<StringIOBuffer>(request);
  3953. int write_rv = ssl_socket()->Write(write_buf.get(), request.size(),
  3954. write_callback.callback(),
  3955. TRAFFIC_ANNOTATION_FOR_TESTS);
  3956. ASSERT_THAT(write_rv, IsError(ERR_IO_PENDING));
  3957. // The Write should have issued a read for the ServerHello, so
  3958. // WaitForReadResult has something to wait for.
  3959. socket->WaitForReadResult();
  3960. EXPECT_TRUE(socket->pending_read_result());
  3961. // Attempt a ReadIfReady(). It should be blocked on the ServerHello.
  3962. TestCompletionCallback read_callback;
  3963. auto read_buf = base::MakeRefCounted<IOBuffer>(4096);
  3964. int read_rv =
  3965. ssl_socket()->ReadIfReady(read_buf.get(), 4096, read_callback.callback());
  3966. ASSERT_THAT(read_rv, IsError(ERR_IO_PENDING));
  3967. // Also queue a ConfirmHandshake. It should also be blocked on ServerHello.
  3968. TestCompletionCallback confirm_callback;
  3969. int confirm_rv = ssl_socket()->ConfirmHandshake(confirm_callback.callback());
  3970. ASSERT_THAT(confirm_rv, IsError(ERR_IO_PENDING));
  3971. // Cancel the ReadIfReady() and release the ServerHello. The remaining
  3972. // operations should complete.
  3973. ASSERT_THAT(ssl_socket()->CancelReadIfReady(), IsOk());
  3974. socket->UnblockReadResult();
  3975. EXPECT_EQ(static_cast<int>(request.size()),
  3976. write_callback.GetResult(write_rv));
  3977. EXPECT_THAT(confirm_callback.GetResult(confirm_rv), IsOk());
  3978. // ReadIfReady() should not complete.
  3979. base::RunLoop().RunUntilIdle();
  3980. EXPECT_FALSE(read_callback.have_result());
  3981. SSLInfo ssl_info;
  3982. ASSERT_TRUE(GetSSLInfo(&ssl_info));
  3983. EXPECT_EQ(SSLInfo::HANDSHAKE_RESUME, ssl_info.handshake_type);
  3984. // After a canceled read, future reads are still possible.
  3985. TestCompletionCallback read_callback2;
  3986. read_rv = read_callback2.GetResult(
  3987. ssl_socket()->Read(read_buf.get(), 4096, read_callback2.callback()));
  3988. ASSERT_GT(read_rv, 0);
  3989. }
  3990. TEST_F(SSLClientSocketZeroRTTTest, ZeroRTTReject) {
  3991. ASSERT_TRUE(StartServer());
  3992. ASSERT_TRUE(RunInitialConnection());
  3993. SSLServerConfig server_config;
  3994. server_config.early_data_enabled = false;
  3995. server_config.version_max = SSL_PROTOCOL_VERSION_TLS1_3;
  3996. SetServerConfig(server_config);
  3997. // 0-RTT Connection
  3998. FakeBlockingStreamSocket* socket = MakeClient(true);
  3999. socket->BlockReadResult();
  4000. ASSERT_THAT(Connect(), IsOk());
  4001. constexpr base::StringPiece kRequest = "GET /zerortt HTTP/1.0\r\n\r\n";
  4002. EXPECT_EQ(static_cast<int>(kRequest.size()), WriteAndWait(kRequest));
  4003. socket->UnblockReadResult();
  4004. // Expect early data to be rejected.
  4005. scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(4096);
  4006. int rv = ReadAndWait(buf.get(), 4096);
  4007. EXPECT_EQ(ERR_EARLY_DATA_REJECTED, rv);
  4008. rv = WriteAndWait(kRequest);
  4009. EXPECT_EQ(ERR_EARLY_DATA_REJECTED, rv);
  4010. // Retrying the connection should succeed.
  4011. socket = MakeClient(true);
  4012. ASSERT_THAT(Connect(), IsOk());
  4013. ASSERT_THAT(MakeHTTPRequest(ssl_socket()), IsOk());
  4014. SSLInfo ssl_info;
  4015. ASSERT_TRUE(GetSSLInfo(&ssl_info));
  4016. EXPECT_EQ(SSLInfo::HANDSHAKE_FULL, ssl_info.handshake_type);
  4017. }
  4018. TEST_F(SSLClientSocketZeroRTTTest, ZeroRTTWrongVersion) {
  4019. ASSERT_TRUE(StartServer());
  4020. ASSERT_TRUE(RunInitialConnection());
  4021. SSLServerConfig server_config;
  4022. server_config.version_max = SSL_PROTOCOL_VERSION_TLS1_2;
  4023. SetServerConfig(server_config);
  4024. // 0-RTT Connection
  4025. FakeBlockingStreamSocket* socket = MakeClient(true);
  4026. socket->BlockReadResult();
  4027. ASSERT_THAT(Connect(), IsOk());
  4028. constexpr base::StringPiece kRequest = "GET /zerortt HTTP/1.0\r\n\r\n";
  4029. EXPECT_EQ(static_cast<int>(kRequest.size()), WriteAndWait(kRequest));
  4030. socket->UnblockReadResult();
  4031. // Expect early data to be rejected because the TLS version was incorrect.
  4032. scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(4096);
  4033. int rv = ReadAndWait(buf.get(), 4096);
  4034. EXPECT_EQ(ERR_WRONG_VERSION_ON_EARLY_DATA, rv);
  4035. rv = WriteAndWait(kRequest);
  4036. EXPECT_EQ(ERR_WRONG_VERSION_ON_EARLY_DATA, rv);
  4037. // Retrying the connection should succeed.
  4038. socket = MakeClient(true);
  4039. ASSERT_THAT(Connect(), IsOk());
  4040. ASSERT_THAT(MakeHTTPRequest(ssl_socket()), IsOk());
  4041. SSLInfo ssl_info;
  4042. ASSERT_TRUE(GetSSLInfo(&ssl_info));
  4043. EXPECT_EQ(SSLInfo::HANDSHAKE_FULL, ssl_info.handshake_type);
  4044. }
  4045. // Test that the ConfirmHandshake successfully completes the handshake and that
  4046. // it blocks until the server's leg has been received.
  4047. TEST_F(SSLClientSocketZeroRTTTest, ZeroRTTConfirmHandshake) {
  4048. ASSERT_TRUE(StartServer());
  4049. ASSERT_TRUE(RunInitialConnection());
  4050. // 0-RTT Connection
  4051. FakeBlockingStreamSocket* socket = MakeClient(true);
  4052. socket->BlockReadResult();
  4053. ASSERT_THAT(Connect(), IsOk());
  4054. // The ServerHello is blocked, so ConfirmHandshake should not complete.
  4055. TestCompletionCallback callback;
  4056. ASSERT_EQ(ERR_IO_PENDING,
  4057. ssl_socket()->ConfirmHandshake(callback.callback()));
  4058. base::RunLoop().RunUntilIdle();
  4059. EXPECT_FALSE(callback.have_result());
  4060. // Release the ServerHello. ConfirmHandshake now completes.
  4061. socket->UnblockReadResult();
  4062. ASSERT_THAT(callback.GetResult(ERR_IO_PENDING), IsOk());
  4063. constexpr base::StringPiece kRequest = "GET /zerortt HTTP/1.0\r\n\r\n";
  4064. EXPECT_EQ(static_cast<int>(kRequest.size()), WriteAndWait(kRequest));
  4065. scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(4096);
  4066. int size = ReadAndWait(buf.get(), 4096);
  4067. EXPECT_GT(size, 0);
  4068. EXPECT_EQ('0', buf->data()[size - 1]);
  4069. SSLInfo ssl_info;
  4070. ASSERT_TRUE(GetSSLInfo(&ssl_info));
  4071. EXPECT_EQ(SSLInfo::HANDSHAKE_RESUME, ssl_info.handshake_type);
  4072. }
  4073. // Test that an early read does not break during zero RTT.
  4074. TEST_F(SSLClientSocketZeroRTTTest, ZeroRTTReadBeforeWrite) {
  4075. ASSERT_TRUE(StartServer());
  4076. ASSERT_TRUE(RunInitialConnection());
  4077. // Make a 0-RTT Connection. Connect() completes even though the ServerHello is
  4078. // blocked.
  4079. FakeBlockingStreamSocket* socket = MakeClient(true);
  4080. socket->BlockReadResult();
  4081. ASSERT_THAT(Connect(), IsOk());
  4082. // Read() does not make progress.
  4083. scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(4096);
  4084. TestCompletionCallback read_callback;
  4085. ASSERT_EQ(ERR_IO_PENDING,
  4086. ssl_socket()->Read(buf.get(), 4096, read_callback.callback()));
  4087. // Write() completes, even though reads are blocked.
  4088. constexpr base::StringPiece kRequest = "GET /zerortt HTTP/1.0\r\n\r\n";
  4089. EXPECT_EQ(static_cast<int>(kRequest.size()), WriteAndWait(kRequest));
  4090. // Release the ServerHello, etc. The Read() now completes.
  4091. socket->UnblockReadResult();
  4092. int size = read_callback.GetResult(ERR_IO_PENDING);
  4093. EXPECT_GT(size, 0);
  4094. EXPECT_EQ('1', buf->data()[size - 1]);
  4095. SSLInfo ssl_info;
  4096. ASSERT_TRUE(GetSSLInfo(&ssl_info));
  4097. EXPECT_EQ(SSLInfo::HANDSHAKE_RESUME, ssl_info.handshake_type);
  4098. }
  4099. TEST_F(SSLClientSocketZeroRTTTest, ZeroRTTDoubleConfirmHandshake) {
  4100. ASSERT_TRUE(StartServer());
  4101. ASSERT_TRUE(RunInitialConnection());
  4102. // 0-RTT Connection
  4103. MakeClient(true);
  4104. ASSERT_THAT(Connect(), IsOk());
  4105. TestCompletionCallback callback;
  4106. ASSERT_THAT(
  4107. callback.GetResult(ssl_socket()->ConfirmHandshake(callback.callback())),
  4108. IsOk());
  4109. // After the handshake is confirmed, ConfirmHandshake should return
  4110. // synchronously.
  4111. ASSERT_THAT(ssl_socket()->ConfirmHandshake(callback.callback()), IsOk());
  4112. constexpr base::StringPiece kRequest = "GET /zerortt HTTP/1.0\r\n\r\n";
  4113. EXPECT_EQ(static_cast<int>(kRequest.size()), WriteAndWait(kRequest));
  4114. scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(4096);
  4115. int size = ReadAndWait(buf.get(), 4096);
  4116. EXPECT_GT(size, 0);
  4117. EXPECT_EQ('0', buf->data()[size - 1]);
  4118. SSLInfo ssl_info;
  4119. ASSERT_TRUE(GetSSLInfo(&ssl_info));
  4120. EXPECT_EQ(SSLInfo::HANDSHAKE_RESUME, ssl_info.handshake_type);
  4121. }
  4122. TEST_F(SSLClientSocketZeroRTTTest, ZeroRTTParallelReadConfirm) {
  4123. ASSERT_TRUE(StartServer());
  4124. ASSERT_TRUE(RunInitialConnection());
  4125. // 0-RTT Connection
  4126. FakeBlockingStreamSocket* socket = MakeClient(true);
  4127. socket->BlockReadResult();
  4128. ASSERT_THAT(Connect(), IsOk());
  4129. constexpr base::StringPiece kRequest = "GET /zerortt HTTP/1.0\r\n\r\n";
  4130. EXPECT_EQ(static_cast<int>(kRequest.size()), WriteAndWait(kRequest));
  4131. // The ServerHello is blocked, so ConfirmHandshake should not complete.
  4132. TestCompletionCallback callback;
  4133. ASSERT_EQ(ERR_IO_PENDING,
  4134. ssl_socket()->ConfirmHandshake(callback.callback()));
  4135. base::RunLoop().RunUntilIdle();
  4136. EXPECT_FALSE(callback.have_result());
  4137. scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(4096);
  4138. TestCompletionCallback read_callback;
  4139. ASSERT_EQ(ERR_IO_PENDING,
  4140. ssl_socket()->Read(buf.get(), 4096, read_callback.callback()));
  4141. base::RunLoop().RunUntilIdle();
  4142. EXPECT_FALSE(read_callback.have_result());
  4143. // Release the ServerHello. ConfirmHandshake now completes.
  4144. socket->UnblockReadResult();
  4145. ASSERT_THAT(callback.WaitForResult(), IsOk());
  4146. int result = read_callback.WaitForResult();
  4147. EXPECT_GT(result, 0);
  4148. EXPECT_EQ('1', buf->data()[result - 1]);
  4149. SSLInfo ssl_info;
  4150. ASSERT_TRUE(GetSSLInfo(&ssl_info));
  4151. EXPECT_EQ(SSLInfo::HANDSHAKE_RESUME, ssl_info.handshake_type);
  4152. }
  4153. TEST_P(SSLClientSocketReadTest, IdleAfterRead) {
  4154. // Set up a TCP server.
  4155. TCPServerSocket server_listener(nullptr, NetLogSource());
  4156. ASSERT_THAT(
  4157. server_listener.Listen(IPEndPoint(IPAddress::IPv4Localhost(), 0), 1),
  4158. IsOk());
  4159. IPEndPoint server_address;
  4160. ASSERT_THAT(server_listener.GetLocalAddress(&server_address), IsOk());
  4161. // Connect a TCP client and server socket.
  4162. TestCompletionCallback server_callback;
  4163. std::unique_ptr<StreamSocket> server_transport;
  4164. int server_rv =
  4165. server_listener.Accept(&server_transport, server_callback.callback());
  4166. TestCompletionCallback client_callback;
  4167. auto client_transport = std::make_unique<TCPClientSocket>(
  4168. AddressList(server_address), nullptr, nullptr, nullptr, NetLogSource());
  4169. int client_rv = client_transport->Connect(client_callback.callback());
  4170. EXPECT_THAT(server_callback.GetResult(server_rv), IsOk());
  4171. EXPECT_THAT(client_callback.GetResult(client_rv), IsOk());
  4172. // Set up an SSL server.
  4173. base::FilePath certs_dir = GetTestCertsDirectory();
  4174. scoped_refptr<net::X509Certificate> cert =
  4175. ImportCertFromFile(certs_dir, "ok_cert.pem");
  4176. ASSERT_TRUE(cert);
  4177. bssl::UniquePtr<EVP_PKEY> pkey =
  4178. key_util::LoadEVP_PKEYFromPEM(certs_dir.AppendASCII("ok_cert.pem"));
  4179. ASSERT_TRUE(pkey);
  4180. std::unique_ptr<crypto::RSAPrivateKey> key =
  4181. crypto::RSAPrivateKey::CreateFromKey(pkey.get());
  4182. ASSERT_TRUE(key);
  4183. std::unique_ptr<SSLServerContext> server_context =
  4184. CreateSSLServerContext(cert.get(), *key.get(), GetServerConfig());
  4185. // Complete the SSL handshake on both sides.
  4186. std::unique_ptr<SSLClientSocket> client(CreateSSLClientSocket(
  4187. std::move(client_transport), HostPortPair::FromIPEndPoint(server_address),
  4188. SSLConfig()));
  4189. std::unique_ptr<SSLServerSocket> server(
  4190. server_context->CreateSSLServerSocket(std::move(server_transport)));
  4191. server_rv = server->Handshake(server_callback.callback());
  4192. client_rv = client->Connect(client_callback.callback());
  4193. EXPECT_THAT(server_callback.GetResult(server_rv), IsOk());
  4194. EXPECT_THAT(client_callback.GetResult(client_rv), IsOk());
  4195. // Write a single record on the server.
  4196. scoped_refptr<IOBuffer> write_buf = base::MakeRefCounted<StringIOBuffer>("a");
  4197. server_rv = server->Write(write_buf.get(), 1, server_callback.callback(),
  4198. TRAFFIC_ANNOTATION_FOR_TESTS);
  4199. // Read that record on the server, but with a much larger buffer than
  4200. // necessary.
  4201. scoped_refptr<IOBuffer> read_buf = base::MakeRefCounted<IOBuffer>(1024);
  4202. client_rv =
  4203. Read(client.get(), read_buf.get(), 1024, client_callback.callback());
  4204. EXPECT_EQ(1, server_callback.GetResult(server_rv));
  4205. EXPECT_EQ(1, WaitForReadCompletion(client.get(), read_buf.get(), 1024,
  4206. &client_callback, client_rv));
  4207. // At this point the client socket should be idle.
  4208. EXPECT_TRUE(client->IsConnectedAndIdle());
  4209. }
  4210. // Test that certificate errors are properly reported when the underlying
  4211. // transport is itself a TLS connection, such as when tunneling over an HTTPS
  4212. // proxy. See https://crbug.com/959305.
  4213. TEST_F(SSLClientSocketTest, SSLOverSSLBadCertificate) {
  4214. // Load a pair of certificates.
  4215. base::FilePath certs_dir = GetTestCertsDirectory();
  4216. scoped_refptr<net::X509Certificate> ok_cert =
  4217. ImportCertFromFile(certs_dir, "ok_cert.pem");
  4218. ASSERT_TRUE(ok_cert);
  4219. bssl::UniquePtr<EVP_PKEY> ok_pkey =
  4220. key_util::LoadEVP_PKEYFromPEM(certs_dir.AppendASCII("ok_cert.pem"));
  4221. ASSERT_TRUE(ok_pkey);
  4222. scoped_refptr<net::X509Certificate> expired_cert =
  4223. ImportCertFromFile(certs_dir, "expired_cert.pem");
  4224. ASSERT_TRUE(expired_cert);
  4225. bssl::UniquePtr<EVP_PKEY> expired_pkey =
  4226. key_util::LoadEVP_PKEYFromPEM(certs_dir.AppendASCII("expired_cert.pem"));
  4227. ASSERT_TRUE(expired_pkey);
  4228. CertVerifyResult expired_result;
  4229. expired_result.verified_cert = expired_cert;
  4230. expired_result.cert_status = CERT_STATUS_DATE_INVALID;
  4231. cert_verifier_->AddResultForCert(expired_cert, expired_result,
  4232. ERR_CERT_DATE_INVALID);
  4233. // Set up a TCP server.
  4234. TCPServerSocket server_listener(nullptr, NetLogSource());
  4235. ASSERT_THAT(
  4236. server_listener.Listen(IPEndPoint(IPAddress::IPv4Localhost(), 0), 1),
  4237. IsOk());
  4238. IPEndPoint server_address;
  4239. ASSERT_THAT(server_listener.GetLocalAddress(&server_address), IsOk());
  4240. // Connect a TCP client and server socket.
  4241. TestCompletionCallback server_callback;
  4242. std::unique_ptr<StreamSocket> server_transport;
  4243. int server_rv =
  4244. server_listener.Accept(&server_transport, server_callback.callback());
  4245. TestCompletionCallback client_callback;
  4246. auto client_transport = std::make_unique<TCPClientSocket>(
  4247. AddressList(server_address), nullptr, nullptr, nullptr, NetLogSource());
  4248. int client_rv = client_transport->Connect(client_callback.callback());
  4249. ASSERT_THAT(server_callback.GetResult(server_rv), IsOk());
  4250. ASSERT_THAT(client_callback.GetResult(client_rv), IsOk());
  4251. // Set up a pair of SSL servers.
  4252. std::unique_ptr<crypto::RSAPrivateKey> ok_key =
  4253. crypto::RSAPrivateKey::CreateFromKey(ok_pkey.get());
  4254. ASSERT_TRUE(ok_key);
  4255. std::unique_ptr<SSLServerContext> ok_server_context =
  4256. CreateSSLServerContext(ok_cert.get(), *ok_key.get(), SSLServerConfig());
  4257. std::unique_ptr<crypto::RSAPrivateKey> expired_key =
  4258. crypto::RSAPrivateKey::CreateFromKey(expired_pkey.get());
  4259. ASSERT_TRUE(expired_key);
  4260. std::unique_ptr<SSLServerContext> expired_server_context =
  4261. CreateSSLServerContext(expired_cert.get(), *expired_key.get(),
  4262. SSLServerConfig());
  4263. // Complete the proxy SSL handshake with ok_cert.pem. This should succeed.
  4264. std::unique_ptr<SSLClientSocket> client =
  4265. CreateSSLClientSocket(std::move(client_transport),
  4266. HostPortPair("proxy.test", 443), SSLConfig());
  4267. std::unique_ptr<SSLServerSocket> server =
  4268. ok_server_context->CreateSSLServerSocket(std::move(server_transport));
  4269. client_rv = client->Connect(client_callback.callback());
  4270. server_rv = server->Handshake(server_callback.callback());
  4271. ASSERT_THAT(client_callback.GetResult(client_rv), IsOk());
  4272. ASSERT_THAT(server_callback.GetResult(server_rv), IsOk());
  4273. // Run the tunneled SSL handshake on with expired_cert.pem. This should fail.
  4274. client = CreateSSLClientSocket(std::move(client),
  4275. HostPortPair("server.test", 443), SSLConfig());
  4276. server = expired_server_context->CreateSSLServerSocket(std::move(server));
  4277. client_rv = client->Connect(client_callback.callback());
  4278. server_rv = server->Handshake(server_callback.callback());
  4279. // The client should observe the bad certificate error.
  4280. EXPECT_THAT(client_callback.GetResult(client_rv),
  4281. IsError(ERR_CERT_DATE_INVALID));
  4282. SSLInfo ssl_info;
  4283. ASSERT_TRUE(client->GetSSLInfo(&ssl_info));
  4284. EXPECT_EQ(ssl_info.cert_status, expired_result.cert_status);
  4285. // TODO(https://crbug.com/912383): The server sees
  4286. // ERR_BAD_SSL_CLIENT_AUTH_CERT because its peer (the client) alerts it with
  4287. // bad_certificate. The alert-mapping code assumes it is running on a client,
  4288. // so it translates bad_certificate to ERR_BAD_SSL_CLIENT_AUTH_CERT, which
  4289. // shouldn't be the error for a bad server certificate.
  4290. EXPECT_THAT(server_callback.GetResult(server_rv),
  4291. IsError(ERR_BAD_SSL_CLIENT_AUTH_CERT));
  4292. }
  4293. TEST_F(SSLClientSocketTest, Tag) {
  4294. ASSERT_TRUE(
  4295. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, SSLServerConfig()));
  4296. auto transport = std::make_unique<TCPClientSocket>(
  4297. addr(), nullptr, nullptr, NetLog::Get(), NetLogSource());
  4298. auto tagging_sock =
  4299. std::make_unique<MockTaggingStreamSocket>(std::move(transport));
  4300. auto* tagging_sock_ptr = tagging_sock.get();
  4301. // |sock| takes ownership of |tagging_sock|, but keep a
  4302. // non-owning pointer to it.
  4303. std::unique_ptr<SSLClientSocket> sock(CreateSSLClientSocket(
  4304. std::move(tagging_sock), host_port_pair(), SSLConfig()));
  4305. EXPECT_EQ(tagging_sock_ptr->tag(), SocketTag());
  4306. #if BUILDFLAG(IS_ANDROID)
  4307. SocketTag tag(0x12345678, 0x87654321);
  4308. sock->ApplySocketTag(tag);
  4309. EXPECT_EQ(tagging_sock_ptr->tag(), tag);
  4310. #endif // BUILDFLAG(IS_ANDROID)
  4311. }
  4312. TEST_F(SSLClientSocketTest, ECH) {
  4313. base::test::ScopedFeatureList feature_list;
  4314. feature_list.InitAndEnableFeature(features::kEncryptedClientHello);
  4315. SSLServerConfig server_config;
  4316. SSLConfig client_config;
  4317. server_config.ech_keys = MakeTestEchKeys(
  4318. "public.example", /*max_name_len=*/64, &client_config.ech_config_list);
  4319. ASSERT_TRUE(server_config.ech_keys);
  4320. ASSERT_TRUE(
  4321. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  4322. // Connecting with the client should use ECH.
  4323. int rv;
  4324. ASSERT_TRUE(CreateAndConnectSSLClientSocket(client_config, &rv));
  4325. EXPECT_THAT(rv, IsOk());
  4326. SSLInfo ssl_info;
  4327. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  4328. EXPECT_EQ(SSLInfo::HANDSHAKE_FULL, ssl_info.handshake_type);
  4329. EXPECT_TRUE(ssl_info.encrypted_client_hello);
  4330. // TLS 1.3 causes the ticket to arrive later. Use the socket to ensure we have
  4331. // a ticket. This also populates the SSLInfo from the server.
  4332. EXPECT_THAT(MakeHTTPRequest(sock_.get(), "/ssl-info"), IsOk());
  4333. absl::optional<SSLInfo> server_ssl_info = LastSSLInfoFromServer();
  4334. ASSERT_TRUE(server_ssl_info);
  4335. EXPECT_TRUE(server_ssl_info->encrypted_client_hello);
  4336. // Reconnect. ECH should not interfere with resumption.
  4337. sock_.reset();
  4338. ASSERT_TRUE(CreateAndConnectSSLClientSocket(client_config, &rv));
  4339. EXPECT_THAT(rv, IsOk());
  4340. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  4341. EXPECT_EQ(SSLInfo::HANDSHAKE_RESUME, ssl_info.handshake_type);
  4342. EXPECT_TRUE(ssl_info.encrypted_client_hello);
  4343. // Check SSLInfo from the server.
  4344. EXPECT_THAT(MakeHTTPRequest(sock_.get(), "/ssl-info"), IsOk());
  4345. server_ssl_info = LastSSLInfoFromServer();
  4346. ASSERT_TRUE(server_ssl_info);
  4347. EXPECT_TRUE(server_ssl_info->encrypted_client_hello);
  4348. // Connecting without ECH should not report ECH was used.
  4349. client_config.ech_config_list.clear();
  4350. sock_.reset();
  4351. ASSERT_TRUE(CreateAndConnectSSLClientSocket(client_config, &rv));
  4352. EXPECT_THAT(rv, IsOk());
  4353. ASSERT_TRUE(sock_->GetSSLInfo(&ssl_info));
  4354. EXPECT_FALSE(ssl_info.encrypted_client_hello);
  4355. // Check SSLInfo from the server.
  4356. EXPECT_THAT(MakeHTTPRequest(sock_.get(), "/ssl-info"), IsOk());
  4357. server_ssl_info = LastSSLInfoFromServer();
  4358. ASSERT_TRUE(server_ssl_info);
  4359. EXPECT_FALSE(server_ssl_info->encrypted_client_hello);
  4360. }
  4361. // Test that, on key mismatch, the public name can be used to authenticate
  4362. // replacement keys.
  4363. TEST_F(SSLClientSocketTest, ECHWrongKeys) {
  4364. base::test::ScopedFeatureList feature_list;
  4365. feature_list.InitAndEnableFeature(features::kEncryptedClientHello);
  4366. static const char kPublicName[] = "public.example";
  4367. std::vector<uint8_t> ech_config_list1, ech_config_list2;
  4368. bssl::UniquePtr<SSL_ECH_KEYS> keys1 =
  4369. MakeTestEchKeys(kPublicName, /*max_name_len=*/64, &ech_config_list1);
  4370. ASSERT_TRUE(keys1);
  4371. bssl::UniquePtr<SSL_ECH_KEYS> keys2 =
  4372. MakeTestEchKeys(kPublicName, /*max_name_len=*/64, &ech_config_list2);
  4373. ASSERT_TRUE(keys2);
  4374. // Configure the client and server with different keys.
  4375. SSLServerConfig server_config;
  4376. server_config.ech_keys = std::move(keys1);
  4377. SSLConfig client_config;
  4378. client_config.ech_config_list = std::move(ech_config_list2);
  4379. ASSERT_TRUE(
  4380. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  4381. // Verify the fallback handshake verifies the certificate against the public
  4382. // name.
  4383. cert_verifier_->set_default_result(ERR_CERT_INVALID);
  4384. scoped_refptr<X509Certificate> server_cert =
  4385. embedded_test_server()->GetCertificate();
  4386. CertVerifyResult verify_result;
  4387. verify_result.verified_cert = server_cert;
  4388. cert_verifier_->AddResultForCertAndHost(server_cert, kPublicName,
  4389. verify_result, OK);
  4390. // Connecting with the client should report ECH was not negotiated.
  4391. int rv;
  4392. ASSERT_TRUE(CreateAndConnectSSLClientSocket(client_config, &rv));
  4393. EXPECT_THAT(rv, IsError(ERR_ECH_NOT_NEGOTIATED));
  4394. // The server's keys are available as retry keys.
  4395. EXPECT_EQ(ech_config_list1, sock_->GetECHRetryConfigs());
  4396. }
  4397. // Test that, if the server does not support ECH, it can securely report this
  4398. // via the public name. This allows recovery if the server needed to
  4399. // rollback ECH support.
  4400. TEST_F(SSLClientSocketTest, ECHSecurelyDisabled) {
  4401. base::test::ScopedFeatureList feature_list;
  4402. feature_list.InitAndEnableFeature(features::kEncryptedClientHello);
  4403. static const char kPublicName[] = "public.example";
  4404. std::vector<uint8_t> ech_config_list;
  4405. bssl::UniquePtr<SSL_ECH_KEYS> keys =
  4406. MakeTestEchKeys(kPublicName, /*max_name_len=*/64, &ech_config_list);
  4407. ASSERT_TRUE(keys);
  4408. // The server does not have keys configured.
  4409. ASSERT_TRUE(
  4410. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, SSLServerConfig()));
  4411. // However it can authenticate for kPublicName.
  4412. cert_verifier_->set_default_result(ERR_CERT_INVALID);
  4413. scoped_refptr<X509Certificate> server_cert =
  4414. embedded_test_server()->GetCertificate();
  4415. CertVerifyResult verify_result;
  4416. verify_result.verified_cert = server_cert;
  4417. cert_verifier_->AddResultForCertAndHost(server_cert, kPublicName,
  4418. verify_result, OK);
  4419. // Connecting with the client should report ECH was not negotiated.
  4420. SSLConfig client_config;
  4421. client_config.ech_config_list = std::move(ech_config_list);
  4422. int rv;
  4423. ASSERT_TRUE(CreateAndConnectSSLClientSocket(client_config, &rv));
  4424. EXPECT_THAT(rv, IsError(ERR_ECH_NOT_NEGOTIATED));
  4425. // The retry config is empty, meaning the server has securely reported that
  4426. // ECH is disabled
  4427. EXPECT_TRUE(sock_->GetECHRetryConfigs().empty());
  4428. }
  4429. // The same as the above, but testing that it also works in TLS 1.2, which
  4430. // otherwise does not support ECH.
  4431. TEST_F(SSLClientSocketTest, ECHSecurelyDisabledTLS12) {
  4432. base::test::ScopedFeatureList feature_list;
  4433. feature_list.InitAndEnableFeature(features::kEncryptedClientHello);
  4434. static const char kPublicName[] = "public.example";
  4435. std::vector<uint8_t> ech_config_list;
  4436. bssl::UniquePtr<SSL_ECH_KEYS> keys =
  4437. MakeTestEchKeys(kPublicName, /*max_name_len=*/64, &ech_config_list);
  4438. ASSERT_TRUE(keys);
  4439. // The server does not have keys configured.
  4440. SSLServerConfig server_config;
  4441. server_config.version_max = SSL_PROTOCOL_VERSION_TLS1_2;
  4442. ASSERT_TRUE(
  4443. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  4444. // However it can authenticate for kPublicName.
  4445. cert_verifier_->set_default_result(ERR_CERT_INVALID);
  4446. scoped_refptr<X509Certificate> server_cert =
  4447. embedded_test_server()->GetCertificate();
  4448. CertVerifyResult verify_result;
  4449. verify_result.verified_cert = server_cert;
  4450. cert_verifier_->AddResultForCertAndHost(server_cert, kPublicName,
  4451. verify_result, OK);
  4452. // Connecting with the client should report ECH was not negotiated.
  4453. SSLConfig client_config;
  4454. client_config.ech_config_list = std::move(ech_config_list);
  4455. int rv;
  4456. ASSERT_TRUE(CreateAndConnectSSLClientSocket(client_config, &rv));
  4457. EXPECT_THAT(rv, IsError(ERR_ECH_NOT_NEGOTIATED));
  4458. // The retry config is empty, meaning the server has securely reported that
  4459. // ECH is disabled
  4460. EXPECT_TRUE(sock_->GetECHRetryConfigs().empty());
  4461. }
  4462. // Test that the ECH fallback handshake rejects bad certificates.
  4463. TEST_F(SSLClientSocketTest, ECHFallbackBadCert) {
  4464. base::test::ScopedFeatureList feature_list;
  4465. feature_list.InitAndEnableFeature(features::kEncryptedClientHello);
  4466. static const char kPublicName[] = "public.example";
  4467. std::vector<uint8_t> ech_config_list1, ech_config_list2;
  4468. bssl::UniquePtr<SSL_ECH_KEYS> keys1 =
  4469. MakeTestEchKeys(kPublicName, /*max_name_len=*/64, &ech_config_list1);
  4470. ASSERT_TRUE(keys1);
  4471. bssl::UniquePtr<SSL_ECH_KEYS> keys2 =
  4472. MakeTestEchKeys(kPublicName, /*max_name_len=*/64, &ech_config_list2);
  4473. ASSERT_TRUE(keys2);
  4474. // Configure the client and server with different keys.
  4475. SSLServerConfig server_config;
  4476. server_config.ech_keys = std::move(keys1);
  4477. SSLConfig client_config;
  4478. client_config.ech_config_list = std::move(ech_config_list2);
  4479. ASSERT_TRUE(
  4480. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  4481. // Configure the client to reject the certificate for the public name (or any
  4482. // other name).
  4483. cert_verifier_->set_default_result(ERR_CERT_INVALID);
  4484. // Connecting with the client will fail with a fatal error.
  4485. int rv;
  4486. ASSERT_TRUE(CreateAndConnectSSLClientSocket(client_config, &rv));
  4487. EXPECT_THAT(rv, IsError(ERR_ECH_FALLBACK_CERTIFICATE_INVALID));
  4488. }
  4489. TEST_F(SSLClientSocketTest, InvalidECHConfigList) {
  4490. base::test::ScopedFeatureList feature_list;
  4491. feature_list.InitAndEnableFeature(features::kEncryptedClientHello);
  4492. ASSERT_TRUE(
  4493. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, SSLServerConfig()));
  4494. // If the ECHConfigList cannot be parsed at all, report an error to the
  4495. // caller.
  4496. SSLConfig client_config;
  4497. client_config.ech_config_list = {0x00};
  4498. int rv;
  4499. ASSERT_TRUE(CreateAndConnectSSLClientSocket(client_config, &rv));
  4500. EXPECT_THAT(rv, IsError(ERR_INVALID_ECH_CONFIG_LIST));
  4501. }
  4502. // Test that, if no ECHConfigList is available, the client sends ECH GREASE.
  4503. TEST_F(SSLClientSocketTest, ECHGreaseEnabled) {
  4504. base::test::ScopedFeatureList feature_list;
  4505. feature_list.InitAndEnableFeature(features::kEncryptedClientHello);
  4506. // Configure the server to expect an ECH extension.
  4507. bool ran_callback = false;
  4508. SSLServerConfig server_config;
  4509. server_config.client_hello_callback_for_testing =
  4510. base::BindLambdaForTesting([&](const SSL_CLIENT_HELLO* client_hello) {
  4511. const uint8_t* data;
  4512. size_t len;
  4513. EXPECT_TRUE(SSL_early_callback_ctx_extension_get(
  4514. client_hello, TLSEXT_TYPE_encrypted_client_hello, &data, &len));
  4515. ran_callback = true;
  4516. return true;
  4517. });
  4518. ASSERT_TRUE(
  4519. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  4520. int rv;
  4521. ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
  4522. EXPECT_THAT(rv, IsOk());
  4523. EXPECT_TRUE(ran_callback);
  4524. }
  4525. // Test that, if the feature flag is disabled, the client does not send ECH
  4526. // GREASE.
  4527. TEST_F(SSLClientSocketTest, ECHGreaseDisabled) {
  4528. base::test::ScopedFeatureList feature_list;
  4529. feature_list.InitAndDisableFeature(features::kEncryptedClientHello);
  4530. // Configure the server not to expect an ECH extension.
  4531. bool ran_callback = false;
  4532. SSLServerConfig server_config;
  4533. server_config.client_hello_callback_for_testing =
  4534. base::BindLambdaForTesting([&](const SSL_CLIENT_HELLO* client_hello) {
  4535. const uint8_t* data;
  4536. size_t len;
  4537. EXPECT_FALSE(SSL_early_callback_ctx_extension_get(
  4538. client_hello, TLSEXT_TYPE_encrypted_client_hello, &data, &len));
  4539. ran_callback = true;
  4540. return true;
  4541. });
  4542. ASSERT_TRUE(
  4543. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  4544. int rv;
  4545. ASSERT_TRUE(CreateAndConnectSSLClientSocket(SSLConfig(), &rv));
  4546. EXPECT_THAT(rv, IsOk());
  4547. EXPECT_TRUE(ran_callback);
  4548. }
  4549. struct SSLHandshakeDetailsParams {
  4550. bool alpn;
  4551. bool early_data;
  4552. uint16_t version;
  4553. SSLHandshakeDetails expected_initial;
  4554. SSLHandshakeDetails expected_resume;
  4555. };
  4556. const SSLHandshakeDetailsParams kSSLHandshakeDetailsParams[] = {
  4557. // TLS 1.0 and 1.1 never do False Start.
  4558. {false /* no ALPN */, false /* no early data */, SSL_PROTOCOL_VERSION_TLS1,
  4559. SSLHandshakeDetails::kTLS12Full, SSLHandshakeDetails::kTLS12Resume},
  4560. {false /* no ALPN */, false /* no early data */,
  4561. SSL_PROTOCOL_VERSION_TLS1_1, SSLHandshakeDetails::kTLS12Full,
  4562. SSLHandshakeDetails::kTLS12Resume},
  4563. // TLS 1.2 does False Start if ALPN is enabled.
  4564. {false /* no ALPN */, false /* no early data */,
  4565. SSL_PROTOCOL_VERSION_TLS1_2, SSLHandshakeDetails::kTLS12Full,
  4566. SSLHandshakeDetails::kTLS12Resume},
  4567. {true /* ALPN */, false /* no early data */, SSL_PROTOCOL_VERSION_TLS1_2,
  4568. SSLHandshakeDetails::kTLS12FalseStart, SSLHandshakeDetails::kTLS12Resume},
  4569. // TLS 1.3 supports full handshakes, resumption, and 0-RTT.
  4570. {false /* no ALPN */, false /* no early data */,
  4571. SSL_PROTOCOL_VERSION_TLS1_3, SSLHandshakeDetails::kTLS13Full,
  4572. SSLHandshakeDetails::kTLS13Resume},
  4573. {false /* no ALPN */, true /* early data */, SSL_PROTOCOL_VERSION_TLS1_3,
  4574. SSLHandshakeDetails::kTLS13Full, SSLHandshakeDetails::kTLS13Early},
  4575. };
  4576. class SSLHandshakeDetailsTest
  4577. : public SSLClientSocketTest,
  4578. public ::testing::WithParamInterface<SSLHandshakeDetailsParams> {};
  4579. INSTANTIATE_TEST_SUITE_P(All,
  4580. SSLHandshakeDetailsTest,
  4581. ValuesIn(kSSLHandshakeDetailsParams));
  4582. TEST_P(SSLHandshakeDetailsTest, Metrics) {
  4583. // Enable all test features in the server.
  4584. SSLServerConfig server_config;
  4585. server_config.version_min = SSL_PROTOCOL_VERSION_TLS1;
  4586. server_config.version_max = SSL_PROTOCOL_VERSION_TLS1_3;
  4587. server_config.early_data_enabled = true;
  4588. server_config.alpn_protos = {kProtoHTTP11};
  4589. ASSERT_TRUE(
  4590. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  4591. SSLContextConfig client_context_config;
  4592. client_context_config.version_min = GetParam().version;
  4593. client_context_config.version_max = GetParam().version;
  4594. ssl_config_service_->UpdateSSLConfigAndNotify(client_context_config);
  4595. SSLConfig client_config;
  4596. client_config.version_min_override = GetParam().version;
  4597. client_config.version_max_override = GetParam().version;
  4598. client_config.early_data_enabled = GetParam().early_data;
  4599. if (GetParam().alpn) {
  4600. client_config.alpn_protos = {kProtoHTTP11};
  4601. }
  4602. SSLVersion version;
  4603. switch (GetParam().version) {
  4604. case SSL_PROTOCOL_VERSION_TLS1:
  4605. version = SSL_CONNECTION_VERSION_TLS1;
  4606. break;
  4607. case SSL_PROTOCOL_VERSION_TLS1_1:
  4608. version = SSL_CONNECTION_VERSION_TLS1_1;
  4609. break;
  4610. case SSL_PROTOCOL_VERSION_TLS1_2:
  4611. version = SSL_CONNECTION_VERSION_TLS1_2;
  4612. break;
  4613. case SSL_PROTOCOL_VERSION_TLS1_3:
  4614. version = SSL_CONNECTION_VERSION_TLS1_3;
  4615. break;
  4616. default:
  4617. FAIL() << GetParam().version;
  4618. }
  4619. // Make the initial connection.
  4620. {
  4621. base::HistogramTester histograms;
  4622. int rv;
  4623. ASSERT_TRUE(CreateAndConnectSSLClientSocket(client_config, &rv));
  4624. EXPECT_THAT(rv, IsOk());
  4625. // Sanity-check the socket matches the test parameters.
  4626. SSLInfo info;
  4627. ASSERT_TRUE(sock_->GetSSLInfo(&info));
  4628. EXPECT_EQ(version, SSLConnectionStatusToVersion(info.connection_status));
  4629. EXPECT_EQ(SSLInfo::HANDSHAKE_FULL, info.handshake_type);
  4630. EXPECT_EQ(GetParam().alpn, sock_->WasAlpnNegotiated());
  4631. histograms.ExpectUniqueSample("Net.SSLHandshakeDetails",
  4632. GetParam().expected_initial, 1);
  4633. // TLS 1.2 with False Start and TLS 1.3 cause the ticket to arrive later, so
  4634. // use the socket to ensure the session ticket has been picked up.
  4635. EXPECT_THAT(MakeHTTPRequest(sock_.get()), IsOk());
  4636. }
  4637. // Make a resumption connection.
  4638. {
  4639. base::HistogramTester histograms;
  4640. int rv;
  4641. ASSERT_TRUE(CreateAndConnectSSLClientSocket(client_config, &rv));
  4642. EXPECT_THAT(rv, IsOk());
  4643. // Sanity-check the socket matches the test parameters.
  4644. SSLInfo info;
  4645. ASSERT_TRUE(sock_->GetSSLInfo(&info));
  4646. EXPECT_EQ(version, SSLConnectionStatusToVersion(info.connection_status));
  4647. EXPECT_EQ(SSLInfo::HANDSHAKE_RESUME, info.handshake_type);
  4648. EXPECT_EQ(GetParam().alpn, sock_->WasAlpnNegotiated());
  4649. histograms.ExpectUniqueSample("Net.SSLHandshakeDetails",
  4650. GetParam().expected_resume, 1);
  4651. }
  4652. }
  4653. TEST_F(SSLClientSocketZeroRTTTest, EarlyDataReasonNewSession) {
  4654. const char kReasonHistogram[] = "Net.SSLHandshakeEarlyDataReason";
  4655. ASSERT_TRUE(StartServer());
  4656. base::HistogramTester histograms;
  4657. ASSERT_TRUE(RunInitialConnection());
  4658. histograms.ExpectUniqueSample(kReasonHistogram,
  4659. ssl_early_data_no_session_offered, 1);
  4660. }
  4661. // Test 0-RTT logging when the server declines to resume a connection.
  4662. TEST_F(SSLClientSocketZeroRTTTest, EarlyDataReasonNoResume) {
  4663. const char kReasonHistogram[] = "Net.SSLHandshakeEarlyDataReason";
  4664. ASSERT_TRUE(StartServer());
  4665. ASSERT_TRUE(RunInitialConnection());
  4666. SSLServerConfig server_config;
  4667. server_config.early_data_enabled = false;
  4668. server_config.version_max = SSL_PROTOCOL_VERSION_TLS1_3;
  4669. SetServerConfig(server_config);
  4670. base::HistogramTester histograms;
  4671. // 0-RTT Connection
  4672. FakeBlockingStreamSocket* socket = MakeClient(true);
  4673. socket->BlockReadResult();
  4674. ASSERT_THAT(Connect(), IsOk());
  4675. constexpr base::StringPiece kRequest = "GET /zerortt HTTP/1.0\r\n\r\n";
  4676. EXPECT_EQ(static_cast<int>(kRequest.size()), WriteAndWait(kRequest));
  4677. socket->UnblockReadResult();
  4678. // Expect early data to be rejected.
  4679. scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(4096);
  4680. int rv = ReadAndWait(buf.get(), 4096);
  4681. EXPECT_EQ(ERR_EARLY_DATA_REJECTED, rv);
  4682. histograms.ExpectUniqueSample(kReasonHistogram,
  4683. ssl_early_data_session_not_resumed, 1);
  4684. }
  4685. // Test 0-RTT logging in the standard ConfirmHandshake-after-acceptance case.
  4686. TEST_F(SSLClientSocketZeroRTTTest, EarlyDataReasonZeroRTT) {
  4687. const char kReasonHistogram[] = "Net.SSLHandshakeEarlyDataReason";
  4688. ASSERT_TRUE(StartServer());
  4689. ASSERT_TRUE(RunInitialConnection());
  4690. // 0-RTT Connection
  4691. base::HistogramTester histograms;
  4692. MakeClient(true);
  4693. ASSERT_THAT(Connect(), IsOk());
  4694. TestCompletionCallback callback;
  4695. ASSERT_THAT(
  4696. callback.GetResult(ssl_socket()->ConfirmHandshake(callback.callback())),
  4697. IsOk());
  4698. base::RunLoop().RunUntilIdle();
  4699. histograms.ExpectUniqueSample(kReasonHistogram, ssl_early_data_accepted, 1);
  4700. }
  4701. // Check that we're correctly logging 0-rtt success when the handshake
  4702. // concludes during a Read.
  4703. TEST_F(SSLClientSocketZeroRTTTest, EarlyDataReasonReadServerHello) {
  4704. const char kReasonHistogram[] = "Net.SSLHandshakeEarlyDataReason";
  4705. ASSERT_TRUE(StartServer());
  4706. ASSERT_TRUE(RunInitialConnection());
  4707. // 0-RTT Connection
  4708. base::HistogramTester histograms;
  4709. MakeClient(true);
  4710. ASSERT_THAT(Connect(), IsOk());
  4711. constexpr base::StringPiece kRequest = "GET /zerortt HTTP/1.0\r\n\r\n";
  4712. EXPECT_EQ(static_cast<int>(kRequest.size()), WriteAndWait(kRequest));
  4713. scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(4096);
  4714. int size = ReadAndWait(buf.get(), 4096);
  4715. EXPECT_GT(size, 0);
  4716. EXPECT_EQ('1', buf->data()[size - 1]);
  4717. // 0-RTT metrics are logged on a PostTask, so if Read returns synchronously,
  4718. // it is possible the metrics haven't been picked up yet.
  4719. base::RunLoop().RunUntilIdle();
  4720. SSLInfo ssl_info;
  4721. ASSERT_TRUE(GetSSLInfo(&ssl_info));
  4722. EXPECT_EQ(SSLInfo::HANDSHAKE_RESUME, ssl_info.handshake_type);
  4723. histograms.ExpectUniqueSample(kReasonHistogram, ssl_early_data_accepted, 1);
  4724. }
  4725. TEST_F(SSLClientSocketTest, VersionMaxOverride) {
  4726. SSLServerConfig server_config;
  4727. server_config.version_max = SSL_PROTOCOL_VERSION_TLS1_3;
  4728. ASSERT_TRUE(
  4729. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  4730. // Connecting normally uses the global configuration.
  4731. SSLConfig config;
  4732. int rv;
  4733. ASSERT_TRUE(CreateAndConnectSSLClientSocket(config, &rv));
  4734. EXPECT_THAT(rv, IsOk());
  4735. SSLInfo info;
  4736. ASSERT_TRUE(sock_->GetSSLInfo(&info));
  4737. EXPECT_EQ(SSL_CONNECTION_VERSION_TLS1_3,
  4738. SSLConnectionStatusToVersion(info.connection_status));
  4739. // Individual sockets may override the maximum version.
  4740. config.version_max_override = SSL_PROTOCOL_VERSION_TLS1_2;
  4741. ASSERT_TRUE(CreateAndConnectSSLClientSocket(config, &rv));
  4742. EXPECT_THAT(rv, IsOk());
  4743. ASSERT_TRUE(sock_->GetSSLInfo(&info));
  4744. EXPECT_EQ(SSL_CONNECTION_VERSION_TLS1_2,
  4745. SSLConnectionStatusToVersion(info.connection_status));
  4746. }
  4747. TEST_F(SSLClientSocketTest, VersionMinOverride) {
  4748. SSLServerConfig server_config;
  4749. server_config.version_max = SSL_PROTOCOL_VERSION_TLS1_2;
  4750. ASSERT_TRUE(
  4751. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  4752. // Connecting normally uses the global configuration.
  4753. SSLConfig config;
  4754. int rv;
  4755. ASSERT_TRUE(CreateAndConnectSSLClientSocket(config, &rv));
  4756. EXPECT_THAT(rv, IsOk());
  4757. SSLInfo info;
  4758. ASSERT_TRUE(sock_->GetSSLInfo(&info));
  4759. EXPECT_EQ(SSL_CONNECTION_VERSION_TLS1_2,
  4760. SSLConnectionStatusToVersion(info.connection_status));
  4761. // Individual sockets may also override the minimum version.
  4762. config.version_min_override = SSL_PROTOCOL_VERSION_TLS1_3;
  4763. config.version_max_override = SSL_PROTOCOL_VERSION_TLS1_3;
  4764. ASSERT_TRUE(CreateAndConnectSSLClientSocket(config, &rv));
  4765. EXPECT_THAT(rv, IsError(ERR_SSL_VERSION_OR_CIPHER_MISMATCH));
  4766. }
  4767. // Basic test of CancelReadIfReady works.
  4768. TEST_F(SSLClientSocketTest, CancelReadIfReady) {
  4769. ASSERT_TRUE(
  4770. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, SSLServerConfig()));
  4771. // Connect with a FakeBlockingStreamSocket.
  4772. auto real_transport = std::make_unique<TCPClientSocket>(
  4773. addr(), nullptr, nullptr, nullptr, NetLogSource());
  4774. auto transport =
  4775. std::make_unique<FakeBlockingStreamSocket>(std::move(real_transport));
  4776. FakeBlockingStreamSocket* raw_transport = transport.get();
  4777. TestCompletionCallback callback;
  4778. ASSERT_THAT(callback.GetResult(transport->Connect(callback.callback())),
  4779. IsOk());
  4780. // Complete the handshake. Disable the post-handshake peek so that, after the
  4781. // handshake, there are no pending reads on the transport.
  4782. SSLConfig config;
  4783. config.disable_post_handshake_peek_for_testing = true;
  4784. auto sock =
  4785. CreateSSLClientSocket(std::move(transport), host_port_pair(), config);
  4786. ASSERT_THAT(callback.GetResult(sock->Connect(callback.callback())), IsOk());
  4787. // Block the socket and wait for some data to arrive from the server.
  4788. raw_transport->BlockReadResult();
  4789. auto write_buf =
  4790. base::MakeRefCounted<StringIOBuffer>("GET / HTTP/1.0\r\n\r\n");
  4791. ASSERT_EQ(callback.GetResult(sock->Write(write_buf.get(), write_buf->size(),
  4792. callback.callback(),
  4793. TRAFFIC_ANNOTATION_FOR_TESTS)),
  4794. write_buf->size());
  4795. // ReadIfReady() should not read anything because the socket is blocked.
  4796. bool callback_called = false;
  4797. auto read_buf = base::MakeRefCounted<IOBuffer>(100);
  4798. int rv = sock->ReadIfReady(
  4799. read_buf.get(), 100,
  4800. base::BindLambdaForTesting([&](int rv) { callback_called = true; }));
  4801. ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
  4802. // Cancel ReadIfReady() and unblock the socket.
  4803. ASSERT_THAT(sock->CancelReadIfReady(), IsOk());
  4804. raw_transport->WaitForReadResult();
  4805. raw_transport->UnblockReadResult();
  4806. base::RunLoop().RunUntilIdle();
  4807. // Although data is now available, the callback should not have been called.
  4808. EXPECT_FALSE(callback_called);
  4809. // Future reads on the socket should still work. The data should be
  4810. // synchronously available.
  4811. EXPECT_GT(
  4812. callback.GetResult(sock->Read(read_buf.get(), 100, callback.callback())),
  4813. 0);
  4814. }
  4815. // Test that the server_name extension (SNI) is sent on DNS names, and not IP
  4816. // literals.
  4817. TEST_F(SSLClientSocketTest, ServerName) {
  4818. absl::optional<std::string> got_server_name;
  4819. bool ran_callback = false;
  4820. auto reset_callback_state = [&] {
  4821. got_server_name = absl::nullopt;
  4822. ran_callback = false;
  4823. };
  4824. // Start a server which records the server name.
  4825. SSLServerConfig server_config;
  4826. server_config.client_hello_callback_for_testing =
  4827. base::BindLambdaForTesting([&](const SSL_CLIENT_HELLO* client_hello) {
  4828. const char* server_name =
  4829. SSL_get_servername(client_hello->ssl, TLSEXT_NAMETYPE_host_name);
  4830. if (server_name) {
  4831. got_server_name = server_name;
  4832. } else {
  4833. got_server_name = absl::nullopt;
  4834. }
  4835. ran_callback = true;
  4836. return true;
  4837. });
  4838. ASSERT_TRUE(
  4839. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  4840. // The client should send the server_name extension for DNS names.
  4841. uint16_t port = host_port_pair().port();
  4842. int rv;
  4843. ASSERT_TRUE(CreateAndConnectSSLClientSocketWithHost(
  4844. SSLConfig(), HostPortPair("example.com", port), &rv));
  4845. ASSERT_THAT(rv, IsOk());
  4846. EXPECT_TRUE(ran_callback);
  4847. EXPECT_EQ(got_server_name, "example.com");
  4848. // The client should not send the server_name extension for IPv4 and IPv6
  4849. // literals. See https://crbug.com/500981.
  4850. reset_callback_state();
  4851. ASSERT_TRUE(CreateAndConnectSSLClientSocketWithHost(
  4852. SSLConfig(), HostPortPair("1.2.3.4", port), &rv));
  4853. ASSERT_THAT(rv, IsOk());
  4854. EXPECT_TRUE(ran_callback);
  4855. EXPECT_EQ(got_server_name, absl::nullopt);
  4856. reset_callback_state();
  4857. ASSERT_TRUE(CreateAndConnectSSLClientSocketWithHost(
  4858. SSLConfig(), HostPortPair("::1", port), &rv));
  4859. ASSERT_THAT(rv, IsOk());
  4860. EXPECT_TRUE(ran_callback);
  4861. EXPECT_EQ(got_server_name, absl::nullopt);
  4862. reset_callback_state();
  4863. ASSERT_TRUE(CreateAndConnectSSLClientSocketWithHost(
  4864. SSLConfig(), HostPortPair("2001:db8::42", port), &rv));
  4865. ASSERT_THAT(rv, IsOk());
  4866. EXPECT_TRUE(ran_callback);
  4867. EXPECT_EQ(got_server_name, absl::nullopt);
  4868. }
  4869. class SSLClientSocketAlpsTest
  4870. : public SSLClientSocketTest,
  4871. public ::testing::WithParamInterface<std::tuple<bool, bool>> {
  4872. public:
  4873. SSLClientSocketAlpsTest()
  4874. : client_alps_enabled_(std::get<0>(GetParam())),
  4875. server_alps_enabled_(std::get<1>(GetParam())) {}
  4876. ~SSLClientSocketAlpsTest() override = default;
  4877. const bool client_alps_enabled_;
  4878. const bool server_alps_enabled_;
  4879. };
  4880. INSTANTIATE_TEST_SUITE_P(All, SSLClientSocketAlpsTest, Combine(Bool(), Bool()));
  4881. TEST_P(SSLClientSocketAlpsTest, Alps) {
  4882. const std::string server_data = "server sends some test data";
  4883. const std::string client_data = "client also sends some data";
  4884. SSLServerConfig server_config;
  4885. server_config.alpn_protos = {kProtoHTTP2};
  4886. if (server_alps_enabled_) {
  4887. server_config.application_settings[kProtoHTTP2] =
  4888. std::vector<uint8_t>(server_data.begin(), server_data.end());
  4889. }
  4890. ASSERT_TRUE(
  4891. StartEmbeddedTestServer(EmbeddedTestServer::CERT_OK, server_config));
  4892. SSLConfig client_config;
  4893. client_config.alpn_protos = {kProtoHTTP2};
  4894. if (client_alps_enabled_) {
  4895. client_config.application_settings[kProtoHTTP2] =
  4896. std::vector<uint8_t>(client_data.begin(), client_data.end());
  4897. }
  4898. int rv;
  4899. ASSERT_TRUE(CreateAndConnectSSLClientSocket(client_config, &rv));
  4900. EXPECT_THAT(rv, IsOk());
  4901. SSLInfo info;
  4902. ASSERT_TRUE(sock_->GetSSLInfo(&info));
  4903. EXPECT_EQ(SSL_CONNECTION_VERSION_TLS1_3,
  4904. SSLConnectionStatusToVersion(info.connection_status));
  4905. EXPECT_EQ(SSLInfo::HANDSHAKE_FULL, info.handshake_type);
  4906. EXPECT_EQ(true, sock_->WasAlpnNegotiated());
  4907. EXPECT_EQ(kProtoHTTP2, sock_->GetNegotiatedProtocol());
  4908. // ALPS is negotiated only if ALPS is enabled both on client and server.
  4909. const auto alps_data_received_by_client = sock_->GetPeerApplicationSettings();
  4910. if (client_alps_enabled_ && server_alps_enabled_) {
  4911. ASSERT_TRUE(alps_data_received_by_client.has_value());
  4912. EXPECT_EQ(server_data, alps_data_received_by_client.value());
  4913. } else {
  4914. EXPECT_FALSE(alps_data_received_by_client.has_value());
  4915. }
  4916. }
  4917. } // namespace net