శుభ మధ్యాహ్నం! ఈ అంశంపై నా అనుభవాన్ని పంచుకోవాలనుకుంటున్నాను.
రుటోకెన్ అనేది ప్రామాణీకరణ, డేటా భద్రత మరియు ఎలక్ట్రానిక్ సంతకాల కోసం ఒక హార్డ్వేర్ మరియు సాఫ్ట్వేర్ పరిష్కారం. ఇది ప్రాథమికంగా ఒక ఫ్లాష్ డ్రైవ్, ఇది వినియోగదారు సిస్టమ్లోకి లాగిన్ అవ్వడానికి ఉపయోగించే ప్రామాణీకరణ డేటాను నిల్వ చేయగలదు.
ఈ ఉదాహరణలో, రుటోకెన్ EDS 2.0 ఉపయోగించబడింది.
ఈ రుటోకెన్తో పని చేయడానికి మీకు అవసరం.
విండోస్ కోసం, కేవలం ఒక డ్రైవర్ను ఇన్స్టాల్ చేయడం ద్వారా, మీ రుటోకెన్ను OS గుర్తించడానికి మరియు దానితో పని చేయడానికి అవసరమైనవన్నీ ఇన్స్టాల్ చేయబడతాయని నిర్ధారించుకోవచ్చు.
రుటోకెన్తో సంభాషించడానికి వివిధ మార్గాలు ఉన్నాయి. మీరు దానిని అప్లికేషన్ యొక్క సర్వర్ వైపు నుండి లేదా నేరుగా క్లయింట్ వైపు నుండి యాక్సెస్ చేయవచ్చు. ఈ ఉదాహరణ అప్లికేషన్ యొక్క క్లయింట్ వైపు నుండి రుటోకెన్తో సంభాషించడంపై దృష్టి పెడుతుంది.
అప్లికేషన్ యొక్క క్లయింట్ భాగం రుటోకెన్ ప్లగిన్ ద్వారా రుటోకెన్తో సంకర్షణ చెందుతుంది. ఇది ప్రతి బ్రౌజర్లో విడిగా ఇన్స్టాల్ చేయబడే ఒక ప్రోగ్రామ్. విండోస్ కోసం, ప్లగిన్ను డౌన్లోడ్ చేసి, ఇన్స్టాల్ చేస్తే సరిపోతుంది. .
అంతే, ఇప్పుడు మనం అప్లికేషన్ యొక్క క్లయింట్ వైపు నుండి రుటోకెన్తో ఇంటరాక్ట్ అవ్వవచ్చు.
ఈ ఉదాహరణ ఛాలెంజ్-రెస్పాన్స్ స్కీమ్ను ఉపయోగించి సిస్టమ్లో యూజర్ ఆథరైజేషన్ అల్గారిథంను అమలు చేసే ఆలోచనను పరిశీలిస్తుంది.
ఈ ఆలోచన యొక్క సారాంశం ఇది:
- క్లయింట్ సర్వర్కు అధికార అభ్యర్థనను పంపుతుంది.
- క్లయింట్ నుండి వచ్చిన అభ్యర్థనకు ప్రతిస్పందనగా, సర్వర్ ఒక యాదృచ్ఛిక స్ట్రింగ్ను పంపుతుంది.
- క్లయింట్ ఈ స్ట్రింగ్ను యాదృచ్ఛిక 32 బిట్లతో నింపుతుంది.
- క్లయింట్ అందుకున్న స్ట్రింగ్పై తన సర్టిఫికేట్తో సంతకం చేస్తుంది.
- క్లయింట్ స్వీకరించిన ఎన్కోడ్ చేసిన సందేశాన్ని సర్వర్కు పంపుతుంది.
- అసలైన, గుప్తీకరించని సందేశాన్ని స్వీకరించడం ద్వారా సర్వర్ సంతకాన్ని ధృవీకరిస్తుంది.
- సర్వర్ స్వీకరించిన గుప్తీకరించని సందేశం నుండి చివరి 32 బిట్లను తొలగిస్తుంది.
- సర్వర్, అందుకున్న ఫలితాన్ని, ఆథరైజేషన్ కోరినప్పుడు పంపిన సందేశంతో పోలుస్తుంది.
- సందేశాలు ఒకేలా ఉంటే, ఆమోదం విజయవంతమైనట్లుగా పరిగణించబడుతుంది.
పై అల్గోరిథంలో సర్టిఫికేట్ అనే భావన ఇమిడి ఉంది. ఈ ఉదాహరణకు క్రిప్టోగ్రాఫిక్ సిద్ధాంతంపై కొంత అవగాహన అవసరం. దీనికి సంబంధించిన లింక్ హబ్రర్లో ఉంది. .
ఈ ఉదాహరణలో, మనం అసమరూప ఎన్క్రిప్షన్ అల్గారిథమ్లను ఉపయోగిస్తాము. అసమరూప అల్గారిథమ్లను అమలు చేయడానికి ఒక కీ జత మరియు ఒక సర్టిఫికేట్ అవసరం.
ఒక కీ జతలో రెండు భాగాలు ఉంటాయి: ఒక ప్రైవేట్ కీ మరియు ఒక పబ్లిక్ కీ. దాని పేరు సూచించినట్లుగానే, ప్రైవేట్ కీని రహస్యంగా ఉంచుతారు. సమాచారాన్ని డీక్రిప్ట్ చేయడానికి మనం దీనిని ఉపయోగిస్తాము. పబ్లిక్ కీని ఎవరితోనైనా పంచుకోవచ్చు. ఈ కీని డేటాను ఎన్క్రిప్ట్ చేయడానికి ఉపయోగిస్తారు. అందువల్ల, పబ్లిక్ కీని ఉపయోగించి ఎవరైనా డేటాను ఎన్క్రిప్ట్ చేయవచ్చు, కానీ ప్రైవేట్ కీ యజమాని మాత్రమే దానిని డీక్రిప్ట్ చేయగలరు.
సర్టిఫికెట్ అనేది ఒక ఎలక్ట్రానిక్ పత్రం, ఇందులో ఆ సర్టిఫికెట్ను కలిగి ఉన్న వినియోగదారుడి సమాచారంతో పాటు ఒక పబ్లిక్ కీ కూడా ఉంటుంది. సర్టిఫికెట్ సహాయంతో, వినియోగదారుడు ఏదైనా డేటాపై సంతకం చేసి దానిని ఒక సర్వర్కు పంపవచ్చు. ఆ సర్వర్ సంతకాన్ని ధృవీకరించి, డేటాను డీక్రిప్ట్ చేయగలదు.
ఒక సందేశానికి సర్టిఫికేట్తో సరిగ్గా సంతకం చేయాలంటే, దానిని సరైన పద్ధతిలో సృష్టించాలి. దీనికోసం, ముందుగా రుటోకెన్లో ఒక కీ పెయిర్ను సృష్టించి, ఆ తర్వాత ఈ కీ పెయిర్ యొక్క పబ్లిక్ కీకి ఒక సర్టిఫికేట్ను జతచేయాలి. ఇది చాలా కీలకం: ఆ సర్టిఫికేట్కు, రుటోకెన్లో నిల్వ ఉన్న పబ్లిక్ కీకి ఉన్న పబ్లిక్ కీయే తప్పనిసరిగా ఉండాలి. ఒకవేళ మనం కీ పెయిర్ను, సర్టిఫికేట్ను నేరుగా అప్లికేషన్ యొక్క క్లయింట్ సైడ్లో సృష్టిస్తే, ఎన్క్రిప్ట్ చేయబడిన సందేశాన్ని సర్వర్ ఎలా డీక్రిప్ట్ చేయగలుగుతుంది? ఎందుకంటే, దానికి కీ పెయిర్ గురించి గానీ, సర్టిఫికేట్ గురించి గానీ ఏమీ తెలియదు.
మీరు ఈ అంశాన్ని మరింత లోతుగా పరిశీలిస్తే, ఆన్లైన్లో కొన్ని ఆసక్తికరమైన సమాచారాన్ని కనుగొనవచ్చు. మనం విశ్వసించగలమని భావించే కొన్ని సర్టిఫికేషన్ అథారిటీలు (CAలు) ఉన్నాయి. ఈ CAలు వినియోగదారులకు సర్టిఫికేట్లను జారీ చేయగలవు మరియు ఈ సర్టిఫికేట్లను తమ సర్వర్లో ఇన్స్టాల్ చేస్తాయి. అప్పుడు, ఒక క్లయింట్ ఈ సర్వర్ను యాక్సెస్ చేసినప్పుడు, వారు ఈ సర్టిఫికేట్ను చూసి, అది CA ద్వారా జారీ చేయబడిందని తెలుసుకుంటారు, అంటే ఆ సర్వర్ను విశ్వసించవచ్చని అర్థం. అన్నింటినీ సరిగ్గా ఎలా సెటప్ చేయాలో అనే దాని గురించి కూడా ఆన్లైన్లో చాలా సమాచారం ఉంది. .
మన సమస్య విషయానికి వస్తే, పరిష్కారం స్పష్టంగానే కనిపిస్తుంది. మనం ఏదో ఒక విధంగా మన స్వంత సర్టిఫికేషన్ అథారిటీని ఏర్పాటు చేసుకోవాలి. కానీ దానికి ముందు, ఒక వినియోగదారుడి గురించి (ఉదాహరణకు, వారి మొదటి పేరు, ఇంటిపేరు మొదలైనవి) ఏమీ తెలియని ఆ సర్టిఫికేషన్ అథారిటీ, ఏ ప్రాతిపదికన వారికి సర్టిఫికేట్ జారీ చేయాలో మనం కనుక్కోవాలి. దీనినే 'సర్టిఫికెట్ రిక్వెస్ట్' అని అంటారు. ఈ ప్రమాణం గురించిన మరింత సమాచారాన్ని, ఉదాహరణకు వికీపీడియాలో మీరు కనుగొనవచ్చు.
మేము వెర్షన్ 1.7 - PKCS#10ని ఉపయోగిస్తాము.
రుటోకెన్లో సర్టిఫికేట్ను రూపొందించడానికి అల్గోరిథంను వివరిద్దాం (అసలు మూలం - ):
- క్లయింట్లో, మేము ఒక కీ జతను సృష్టించి దానిని రుటోకెన్లో సేవ్ చేస్తాము (సేవ్ చేయడం స్వయంచాలకంగా జరుగుతుంది).
- క్లయింట్లో, మేము ఒక సర్టిఫికేట్ అభ్యర్థనను సృష్టిస్తాము.
- క్లయింట్ నుండి మేము ఈ అభ్యర్థనను సర్వర్కు పంపుతాము.
- సర్వర్లో సర్టిఫికేట్ అభ్యర్థన అందిన తర్వాత, మేము మా సర్టిఫికేషన్ అథారిటీ ద్వారా సర్టిఫికేట్ను జారీ చేస్తాము.
- మేము ఈ సర్టిఫికేట్ను క్లయింట్కు పంపుతాము.
- మేము రుటోకెన్ సర్టిఫికేట్ను క్లయింట్లో భద్రపరుస్తాము.
- మొదటి దశలో సృష్టించబడిన కీ జతకు సర్టిఫికేట్ను అనుసంధానించాలి.
సర్వర్ స్వయంగా క్లయింట్కు సర్టిఫికేట్ను జారీ చేసింది కాబట్టి, అది క్లయింట్ సంతకాన్ని ఎలా డీక్రిప్ట్ చేయగలదో ఇప్పుడు స్పష్టమవుతుంది.
తదుపరి విభాగంలో, ఓపెన్ సోర్స్, పూర్తిస్థాయి క్రిప్టోగ్రాఫిక్ లైబ్రరీ అయిన openSSLను ఉపయోగించి మీ స్వంత సర్టిఫికేట్ అథారిటీ (CA)ని ఎలా ఏర్పాటు చేసుకోవాలో వివరంగా చూద్దాం.
మూలం: www.habr.com
