TLS નિયંત્રણ ચેનલની અંદર ચાલે છે, આખા ટનલમાં નહીં

VPN વર્ણનમાં TLS શબ્દ જોઈને એવું તારણ કાઢવું કે વેબ પ્રોક્સી આ ટ્રાફિક સમજશે, એ સામાન્ય ટૂંકો રસ્તો છે. આ પ્રોટોકોલની અંદર સહભાગીઓ પોતાના પેકેટની આપલે કરે છે, અને TLS તે આપલેની અંદર એક ચેનલના ભાગ રૂપે ચાલે છે. વપરાશકર્તાને મહત્ત્વનો પેલોડ અલગ સંદેશ ફોર્મેટમાં જાય છે, તેથી બંને ક્યારેય સામાન્ય HTTPS સત્ર સાથે મેળ ખાતા નથી.

લિફાફો પહેલા આવે છે

દરેક ટનલ પેકેટ પ્રોટોકોલના પોતાના હેડરથી શરૂ થાય છે: સંદેશ પ્રકાર, કી ઓળખકર્તા અને બાઈટ-સ્ટ્રીમ પરિવહન પર લંબાઈ પૂર્વસર્ગ જે પેકેટ ક્યાં પૂરું થાય છે તે દર્શાવે છે. જે વાચક તે લિફાફાનું વિશ્લેષણ કરતો નથી તે જાણી શકતો નથી કે આગળનું ક્ષેત્ર ક્યાં શરૂ થાય છે.

outer transport (UDP datagram or TCP stream)
  -> OpenVPN header (opcode, key id, length where needed)
    -> control message (reliability wrapper, TLS exchange)
    -> data message (protected inner packet)

તે સ્કેચ નકશો છે, બાઈટ કોષ્ટક નહીં, કારણ કે ચોક્કસ ક્ષેત્રો સંદેશ પ્રકાર પર આધાર રાખે છે, જોકે પહેલું ઓક્ટેટ હંમેશા ઓપકોડ અને કી ઓળખકર્તાને સાથે પેક કરે છે. પોર્ટ નંબર પરથી સંદેશ પ્રકારનો અંદાજ લગાવવો એ જ રીતે ડિકોડર જે જુએ છે તેને ખોટું નામ આપે છે. નિદાન માટે ક્રમ મહત્ત્વનો છે: પરિવહન, પછી પ્રોટોકોલ લિફાફો, પછી બે પ્રકારના કામમાંથી એક. આગળ શું આવે તે વિશે અભિપ્રાય બનાવતા પહેલા લિફાફો વાંચો. ખોટી જગ્યાએ શરૂ કરતો ડિકોડર આત્મવિશ્વાસપૂર્ણ નિરર્થકતા ઉત્પન્ન કરે છે.

વિશ્વસનીયતા સ્તર પ્રોટોકોલનું જ છે

નિયંત્રણ સંદેશોને ક્રમબદ્ધ, સ્વીકૃત વિતરણની જરૂર હોય છે, અને પ્રોટોકોલ તે પોતે સ્વીકૃતિ અને પુનઃપ્રેષણ દ્વારા પૂરું પાડે છે. સ્વીકૃતિ પોતાના સંદેશ તરીકે આવી શકે છે અથવા બીજા નિયંત્રણ સંદેશ સાથે મુસાફરી કરી શકે છે, જે એક સ્વચ્છ આપલેની અપેક્ષા રાખનારને ટ્રેસ અનિયમિત લાગે છે.

ફાયદો એ છે કે બાહ્ય પરિવહન UDP હોય ત્યારે પણ TLS હેન્ડશેકને વિશ્વસનીય વાહક મળે છે. કિંમત એ છે કે એક ડેટાગ્રામ તે વાતચીતનો ફક્ત એક ભાગ ધરાવી શકે છે, તેથી તેને સ્વતંત્ર TLS રેકોર્ડ તરીકે ગણવાથી નિરર્થકતા ઉત્પન્ન થાય છે. પુનઃજોડાણ પ્રોટોકોલ સ્તરે થવું જોઈએ. તેથી જ પકડાયેલું પેકેટ ભાગ્યે જ સંપૂર્ણ હેન્ડશેક પગલા જેવું દેખાય છે.

બાહ્ય પરિવહનને TCPમાં બદલવાથી આ સ્તર દૂર થતું નથી. વિશ્વસનીય પરિવહન એટલે પ્રોટોકોલ સ્તરે ઓછું પુનઃપ્રેષણ, એ નહીં કે ફ્રેમિંગ અદૃશ્ય થાય અથવા ટ્રાફિક HTTP બની જાય.

ડેટા પેકેટ અલગ ફોર્મેટ વાપરે છે

સત્ર અસ્તિત્વમાં હોય ત્યારે ઉપયોગી પેલોડ ડેટા સંદેશ તરીકે આવે છે જે આંતરિક IP પેકેટ અથવા Ethernet ફ્રેમ ધરાવે છે. તે પોતાની કી અને પોતાની પ્રક્રિયાથી સુરક્ષિત હોય છે, અને TLS લાઇબ્રેરી સ્વીકારે તેવા કોઈપણ અર્થમાં તે TLS એપ્લિકેશન રેકોર્ડ નથી.

તે વિભાજન રૂપરેખામાં દેખાય છે: નિયંત્રણ ચેનલ અને ડેટા ચેનલની અલગ સાઇફર સેટિંગ્સ હોય છે, તેથી એકનું નામ લેતી લોગ લાઇન બીજા વિશે કંઈ કહેતી નથી. મજબૂત નિયંત્રણ સાઇફરને મજબૂત ડેટા સાઇફરના પુરાવા તરીકે વાંચવો સામાન્ય અહેવાલ ભૂલ છે.

સંબંધિત ખોટી માન્યતાને પણ સમજૂતીની બહાર રાખો. TLS એ સપ્રમાણ ડેટા ચેનલની બાજુમાં બેઠેલી જાહેર કી ચેનલ નથી, કારણ કે કી સ્થાપિત થયા પછી TLS પોતે તેના રેકોર્ડને સપ્રમાણ રીતે સુરક્ષિત કરે છે. સાચો ભેદ ભૂમિકા અને પેકેટ ફોર્મેટ છે, દરેક પક્ષ કયા પ્રકારની ક્રિપ્ટોગ્રાફી વાપરે છે તે નહીં.

HTTPS પ્રોક્સી કેમ મદદ કરી શકતું નથી

જે પ્રોક્સી TLS સમાપ્ત કરે છે તે TLS રેકોર્ડ સ્ટ્રીમ અને પછી તેની અંદર એપ્લિકેશન પ્રોટોકોલની અપેક્ષા રાખે છે. આ પ્રોટોકોલની નિયંત્રણ ચેનલ પોતાના ફ્રેમિંગની અંદર, આસપાસ વિશ્વસનીયતા સ્તર સાથે વહન કરવામાં આવે છે, તેથી સમાપ્ત કરતું પ્રોક્સી તે ફ્રેમિંગને ભ્રષ્ટ ઇનપુટ તરીકે વાંચે છે.

જે પારદર્શક ફોરવર્ડર બાઇટ અથવા ડેટાગ્રામને અર્થઘટન કર્યા વિના પસાર કરે છે તે કામ કરી શકે છે, જો તે સ્ટ્રીમને ફરીથી લખે નહીં અથવા પુનઃજોડે નહીં. કોઈપણ મધ્યસ્થ વિશે પૂછવાનો પ્રશ્ન એ છે કે તે વાસ્તવિક પરિવહન અને ફ્રેમિંગ પસાર કરે છે કે નહીં, તે ક્યાંક TLS સપોર્ટ કરે છે કે નહીં તે નહીં. પ્રોક્સી નિયમો પર સાંજ પસાર કરતા પહેલા આ પૂછો. અહીંના મોટા ભાગના નિષ્ફળતા સ્થાપત્યલક્ષી છે, ખૂટતી સેટિંગ નહીં.

ટ્રેસને યોગ્ય રીતે વાંચવી

પહેલા નિયંત્રણ આપલે, પછી ઘણી મોટી સંખ્યામાં ડેટા સંદેશોની અપેક્ષા રાખો, બંને એક પરિવહન વહેંચે છે. જો નિયંત્રણ તબક્કો પૂરો થાય અને ડેટા તબક્કો અટકે, તો ખામી હેન્ડશેકની નહીં, કી, રૂટિંગ અથવા ડેટા માર્ગની ફિલ્ટરિંગની છે. થોડા ડેટા સંદેશા પકડો અને તપાસો કે તેઓ ક્લાયન્ટ છોડે છે કે નહીં. તે એક અવલોકન શોધને અડધી કરે છે.

ઐતિહાસિક કી-પદ્ધતિ વર્ણનો પ્રોટોકોલ દસ્તાવેજીકરણમાં એ અર્થ નથી કે આપેલ આવૃત્તિ હજી પણ દરેક જૂનું ફોર્મેટ સપોર્ટ કરે છે. તમે ચલાવો છો તે આવૃત્તિ તપાસો, પછી વસ્તુઓ પહેલા કેવી રીતે કામ કરતી હતી તે વર્ણવતા ફકરા પર અપેક્ષા બાંધો.