ஜாவாவில் பாதுகாப்பு: சிறந்த நடைமுறைகள்

சேவையக பயன்பாடுகளில் மிக முக்கியமான அளவீடுகளில் ஒன்று பாதுகாப்பு. இது ஒரு வகையான செயல்படாத தேவை . பாதுகாப்பு பல கூறுகளை உள்ளடக்கியது. நிச்சயமாக, அறியப்பட்ட அனைத்து பாதுகாப்புக் கோட்பாடுகள் மற்றும் பாதுகாப்பு நடவடிக்கைகளை முழுமையாக உள்ளடக்குவதற்கு ஒன்றுக்கு மேற்பட்ட கட்டுரைகள் தேவைப்படும், எனவே நாங்கள் மிக முக்கியமானவற்றைப் பற்றி பேசுவோம். இந்த தலைப்பில் நன்கு அறிந்த ஒரு நபர் அனைத்து தொடர்புடைய செயல்முறைகளையும் அமைக்கலாம், புதிய பாதுகாப்பு துளைகளை உருவாக்குவதைத் தவிர்க்கலாம், மேலும் எந்த அணியிலும் தேவைப்படும். நிச்சயமாக, இந்த நடைமுறைகளைப் பின்பற்றினால், உங்கள் விண்ணப்பம் 100% பாதுகாப்பாக இருக்கும் என்று நீங்கள் நினைக்கக் கூடாது. இல்லை! ஆனால் அது நிச்சயமாக அவர்களுடன் மிகவும் பாதுகாப்பாக இருக்கும். போகலாம்.

1. ஜாவா மொழியின் மட்டத்தில் பாதுகாப்பை வழங்கவும்

முதலில், ஜாவாவில் பாதுகாப்பு மொழியின் திறன்களின் மட்டத்தில் தொடங்குகிறது. அணுகல் மாற்றிகள் இல்லை என்றால் என்ன செய்வோம்? அராஜகம் தவிர வேறொன்றும் இருக்காது. நிரலாக்க மொழியானது பாதுகாப்பான குறியீட்டை எழுத உதவுகிறது மற்றும் பல மறைமுகமான பாதுகாப்பு அம்சங்களையும் பயன்படுத்துகிறது:

1. வலுவான தட்டச்சு. ஜாவா ஒரு நிலையான தட்டச்சு மொழி. இது இயக்க நேரத்தில் வகை தொடர்பான பிழைகளைப் பிடிக்க உதவுகிறது.
2. அணுகல் மாற்றிகள். இவை தேவைக்கேற்ப வகுப்புகள், முறைகள் மற்றும் புலங்களுக்கான அணுகலைத் தனிப்பயனாக்க அனுமதிக்கின்றன.
3. தானியங்கி நினைவக மேலாண்மை. இதற்காக, ஜாவா டெவலப்பர்களிடம் குப்பை சேகரிப்பான் உள்ளது, இது எல்லாவற்றையும் கைமுறையாக உள்ளமைப்பதில் இருந்து நம்மை விடுவிக்கிறது. ஆம், சில நேரங்களில் பிரச்சினைகள் எழுகின்றன.
4. பைட்கோட் சரிபார்ப்பு : ஜாவா பைட்கோடாக தொகுக்கப்படுகிறது, இது இயக்கப்படுவதற்கு முன் இயக்க நேரத்தால் சரிபார்க்கப்படுகிறது.

கூடுதலாக, ஆரக்கிளின் பாதுகாப்பு பரிந்துரைகள் உள்ளன . நிச்சயமாக, இது உயர்ந்த மொழியில் எழுதப்படவில்லை, அதைப் படிக்கும்போது நீங்கள் பல முறை தூங்கலாம், ஆனால் அது மதிப்புக்குரியது. குறிப்பாக, ஜாவா SEக்கான பாதுகாப்பான குறியீட்டு வழிகாட்டுதல்கள் என்ற ஆவணம் முக்கியமானது. பாதுகாப்பான குறியீட்டை எவ்வாறு எழுதுவது என்பது குறித்த ஆலோசனைகளை இது வழங்குகிறது. இந்த ஆவணம் ஒரு பெரிய அளவு மிகவும் பயனுள்ள தகவல்களை வழங்குகிறது. வாய்ப்பு இருந்தால் கண்டிப்பாக படிக்க வேண்டும். இந்த விஷயத்தில் உங்கள் ஆர்வத்தைத் தூண்டுவதற்கு, இங்கே சில சுவாரஸ்யமான குறிப்புகள் உள்ளன:

1. பாதுகாப்பு-உணர்திறன் வகுப்புகளைத் வரிசைப்படுத்துவதைத் தவிர்க்கவும். வரிசையாக்கம் என்பது வரிசைப்படுத்தப்பட்ட கோப்பில் உள்ள வகுப்பு இடைமுகத்தை அம்பலப்படுத்துகிறது, வரிசைப்படுத்தப்பட்ட தரவைக் குறிப்பிடவில்லை.
2. தரவுக்கான மாறக்கூடிய வகுப்புகளைத் தவிர்க்க முயற்சிக்கவும். இது மாறாத வகுப்புகளின் அனைத்து நன்மைகளையும் வழங்குகிறது (எ.கா. நூல் பாதுகாப்பு). உங்களிடம் மாறக்கூடிய பொருள் இருந்தால், அது எதிர்பாராத நடத்தைக்கு வழிவகுக்கும்.
3. திரும்பிய மாறக்கூடிய பொருட்களின் நகல்களை உருவாக்கவும். ஒரு முறையானது உள் மாறக்கூடிய பொருளுக்கு ஒரு குறிப்பை வழங்கினால், கிளையன்ட் குறியீடு பொருளின் உள் நிலையை மாற்றும்.
4. மற்றும் பல…

அடிப்படையில், ஜாவா எஸ்இக்கான பாதுகாப்பான குறியீட்டு வழிகாட்டுதல்கள் என்பது ஜாவா குறியீட்டை எவ்வாறு சரியாகவும் பாதுகாப்பாகவும் எழுதுவது என்பதற்கான உதவிக்குறிப்புகள் மற்றும் தந்திரங்களின் தொகுப்பாகும்.

2. SQL ஊசி பாதிப்புகளை அகற்றவும்

இது ஒரு சிறப்பு வகை பாதிப்பு. இது மிகவும் பிரபலமானது மற்றும் மிகவும் பொதுவான பாதிப்புகளில் ஒன்றாகும் என்பதால் இது சிறப்பு வாய்ந்தது. கணினி பாதுகாப்பில் நீங்கள் ஒருபோதும் ஆர்வம் காட்டவில்லை என்றால், அதைப் பற்றி உங்களுக்குத் தெரியாது. SQL ஊசி என்றால் என்ன? இது ஒரு தரவுத்தள தாக்குதலாகும், இது எதிர்பார்க்கப்படாத இடத்தில் கூடுதல் SQL குறியீட்டை உட்செலுத்துவதை உள்ளடக்கியது. தரவுத்தளத்தை வினவுவதற்கு ஒருவித அளவுருவை ஏற்றுக்கொள்ளும் ஒரு முறை எங்களிடம் உள்ளது என்று வைத்துக்கொள்வோம். உதாரணமாக, ஒரு பயனர்பெயர். பாதிக்கப்படக்கூடிய குறியீடு இப்படி இருக்கும்:

// This method retrieves from the database all users with a certain name
public List findByFirstName(String firstName) throws SQLException {
   // Connect to the database
   Connection connection = DriverManager.getConnection(DB_URL, USER, PASS);
  
   // Compose a SQL database query with our firstName
   String query = "SELECT * FROM USERS WHERE firstName = " + firstName;
  
   // Execute the query
   Statement statement = connection.createStatement();
   ResultSet result = statement.executeQuery(query);

   // Use mapToUsers to convert the ResultSet into a collection of users.
   return mapToUsers(result);
}

private List mapToUsers(ResultSet resultSet) {
   // Converts to a collection of users
}

இந்த எடுத்துக்காட்டில், ஒரு SQL வினவல் ஒரு தனி வரியில் முன்கூட்டியே தயாரிக்கப்படுகிறது. சரி என்ன பிரச்சனை? ஒருவேளை பிரச்சனை என்னவென்றால், String.format ஐப் பயன்படுத்துவது நன்றாக இருக்கும் ? இல்லை? சரி, அப்புறம் என்ன? ஒரு சோதனையாளரின் காலணியில் நம்மை வைத்துக்கொண்டு, முதல்பெயரின் மதிப்பாக எதை அனுப்பலாம் என்பதைப் பற்றி சிந்திப்போம் . உதாரணத்திற்கு:

1. நாம் எதிர்பார்த்ததை அனுப்பலாம் — ஒரு பயனர் பெயர். பின்னர் தரவுத்தளம் அந்த பெயரைக் கொண்ட அனைத்து பயனர்களையும் திருப்பித் தரும்.
2. நாம் ஒரு வெற்று சரத்தை அனுப்பலாம். பின்னர் அனைத்து பயனர்களும் திருப்பி அனுப்பப்படுவார்கள்.
3. ஆனால் நாம் பின்வருவனவற்றையும் அனுப்பலாம்: "'; டிராப் டேபிள் பயனர்கள்;". இங்கே நமக்கு இப்போது huuuuuuge சிக்கல்கள் உள்ளன. இந்த வினவல் தரவுத்தளத்திலிருந்து ஒரு அட்டவணையை நீக்கும். அனைத்து தரவுகளுடன். அவை அனைத்தும்.

இதனால் ஏற்படும் பிரச்சனைகளை உங்களால் கற்பனை செய்ய முடியுமா? அதையும் தாண்டி என்ன வேண்டுமானாலும் எழுதலாம். நீங்கள் அனைத்து பயனர்களின் பெயர்களையும் மாற்றலாம். நீங்கள் அவர்களின் முகவரிகளை நீக்கலாம். நாசவேலைக்கான நோக்கம் மிகப்பெரியது. இதைத் தவிர்க்க, நீங்கள் ஆயத்த வினவலை உட்செலுத்துவதைத் தடுக்க வேண்டும், அதற்குப் பதிலாக அளவுருக்களைப் பயன்படுத்தி வினவலை உருவாக்கவும். தரவுத்தள வினவல்களை உருவாக்குவதற்கான ஒரே வழி இதுதான். இதன் மூலம் இந்த பாதிப்பை நீக்க முடியும். உதாரணத்திற்கு:

// This method retrieves from the database all users with a certain name
public List findByFirstName(String firstName) throws SQLException {
   // Connect to the database
   Connection connection = DriverManager.getConnection(DB_URL, USER, PASS);

   // Create a parameterized query.
   String query = "SELECT * FROM USERS WHERE firstName = ?";

   // Create a prepared statement with the parameterized query
   PreparedStatement statement = connection.prepareStatement(query);
  
   // Pass the parameter's value
   statement.setString(1, firstName);

   // Execute the query
   ResultSet result = statement.executeQuery(query);

   // Use mapToUsers to convert the ResultSet into a collection of users.
   return mapToUsers(result);
}

private List mapToUsers(ResultSet resultSet) {
   // Converts to a collection of users
}

இதன் மூலம் பாதிப்பு தவிர்க்கப்படுகிறது. இந்தக் கட்டுரையில் ஆழமாகச் செல்ல விரும்புவோருக்கு, இதோ ஒரு சிறந்த உதாரணம் . இந்த பாதிப்பை நீங்கள் புரிந்துகொண்டால் உங்களுக்கு எப்படி தெரியும்? கீழே உள்ள நகைச்சுவையில் உங்களுக்கு நகைச்சுவை கிடைத்தால், இந்த பாதிப்பு என்ன என்பதைப் பற்றிய தெளிவான புரிதல் உங்களுக்கு இருக்கலாம் :D

3. சார்புகளை ஸ்கேன் செய்து புதுப்பிக்கவும்

அதற்கு என்ன பொருள்? சார்பு என்றால் என்ன என்று உங்களுக்குத் தெரியாவிட்டால், நான் விளக்குகிறேன். சார்பு என்பது ஒரு JAR காப்பகமாகும், இது மற்றொருவரின் தீர்வை மீண்டும் பயன்படுத்துவதற்காக தானியங்கு உருவாக்க அமைப்புகளை (Maven, Gradle, Ant) பயன்படுத்தி திட்டத்துடன் இணைக்கப்பட்ட குறியீட்டைக் கொண்டது. எடுத்துக்காட்டாக, ப்ராஜெக்ட் லோம்போக் , இது இயக்க நேரத்தில் எங்களுக்காக பெறுபவர்கள், செட்டர்கள் போன்றவற்றை உருவாக்குகிறது. பெரிய பயன்பாடுகள் நிறைய மற்றும் நிறைய சார்புகளைக் கொண்டிருக்கலாம். சில மாறக்கூடியவை (அதாவது, ஒவ்வொரு சார்புக்கும் அதன் சொந்த சார்புகள் இருக்கலாம், மற்றும் பல). இதன் விளைவாக, தாக்குபவர்கள் அதிகளவில் ஓப்பன் சோர்ஸ் சார்புகளில் கவனம் செலுத்துகின்றனர், ஏனெனில் அவை தொடர்ந்து பயன்படுத்தப்படுகின்றன மற்றும் பல வாடிக்கையாளர்களுக்கு அவற்றின் காரணமாக சிக்கல்கள் ஏற்படலாம். முழு சார்பு மரத்திலும் அறியப்பட்ட பாதிப்புகள் எதுவும் இல்லை என்பதை உறுதிப்படுத்துவது முக்கியம் (ஆம், இது ஒரு மரம் போல் தெரிகிறது). இதற்கு பல வழிகள் உள்ளன.

சார்பு கண்காணிப்புக்கு Snyk ஐப் பயன்படுத்தவும்

Snyk அனைத்து திட்ட சார்புகளையும் சரிபார்த்து, அறியப்பட்ட பாதிப்புகளைக் கொடியிடுகிறது. நீங்கள் Snyk இல் பதிவு செய்யலாம் மற்றும் GitHub வழியாக உங்கள் திட்டங்களை இறக்குமதி செய்யலாம். மேலும், மேலே உள்ள படத்தில் இருந்து நீங்கள் பார்ப்பது போல், புதிய பதிப்பில் பாதிப்பு சரி செய்யப்பட்டால், Snyk சரிசெய்து இழுக்கும் கோரிக்கையை உருவாக்கும். திறந்த மூல திட்டங்களுக்கு நீங்கள் இதை இலவசமாகப் பயன்படுத்தலாம். திட்டப்பணிகள் சீரான இடைவெளியில் ஸ்கேன் செய்யப்படுகின்றன, எ.கா. வாரம் ஒருமுறை, மாதம் ஒருமுறை. எனது அனைத்து பொது களஞ்சியங்களையும் Snyk ஸ்கேனில் பதிவு செய்து சேர்த்தேன் (இதில் ஆபத்தான எதுவும் இல்லை, ஏனெனில் அவை ஏற்கனவே அனைவருக்கும் பொதுவானவை). Snyk ஸ்கேன் முடிவைக் காட்டியது: சிறிது நேரத்திற்குப் பிறகு, சார்புகளைப் புதுப்பிக்க வேண்டிய திட்டங்களில் Snyk-bot பல இழுத்தல் கோரிக்கைகளைத் தயாரித்தது: மேலும்:பாதிப்புகளைக் கண்டறிவதற்கும் புதிய பதிப்புகளுக்கான புதுப்பிப்புகளைக் கண்காணிப்பதற்கும் இது ஒரு சிறந்த கருவியாகும்.

GitHub பாதுகாப்பு ஆய்வகத்தைப் பயன்படுத்தவும்

GitHub இல் பணிபுரியும் எவரும் அதன் உள்ளமைக்கப்பட்ட கருவிகளைப் பயன்படுத்திக் கொள்ளலாம். கிட்ஹப் பாதுகாப்பு ஆய்வகத்தை அறிவித்தல் என்ற தலைப்பில் அவர்களின் வலைப்பதிவு இடுகையில் இந்த அணுகுமுறையைப் பற்றி மேலும் படிக்கலாம் . இந்த கருவி, நிச்சயமாக, Snyk ஐ விட எளிமையானது, ஆனால் நீங்கள் நிச்சயமாக அதை புறக்கணிக்கக்கூடாது. மேலும், அறியப்பட்ட பாதிப்புகளின் எண்ணிக்கை மட்டுமே அதிகரிக்கும், எனவே Snyk மற்றும் GitHub பாதுகாப்பு ஆய்வகம் தொடர்ந்து விரிவடைந்து மேம்படுத்தப்படும்.

Sonatype DepShield ஐ இயக்கவும்

உங்கள் களஞ்சியங்களைச் சேமிக்க நீங்கள் GitHub ஐப் பயன்படுத்தினால், MarketPlace இல் உள்ள பயன்பாடுகளில் ஒன்றான Sonatype DepShield ஐ உங்கள் திட்டங்களில் சேர்க்கலாம். சார்புகளுக்கான திட்டங்களை ஸ்கேன் செய்யவும் இது பயன்படுத்தப்படலாம். மேலும், ஏதாவது ஒன்றைக் கண்டறிந்தால், கீழே காட்டப்பட்டுள்ளபடி பொருத்தமான விளக்கத்துடன் GitHub சிக்கல் உருவாக்கப்படும்:

4. ரகசியத் தரவை கவனமாகக் கையாளவும்

நாம் மாற்றாக "உணர்திறன் தரவு" என்ற சொற்றொடரைப் பயன்படுத்தலாம். வாடிக்கையாளரின் தனிப்பட்ட தகவல், கிரெடிட் கார்டு எண்கள் மற்றும் பிற முக்கியத் தகவல்களைக் கசியவிடுவது ஈடுசெய்ய முடியாத தீங்குகளை ஏற்படுத்தும். முதலில், உங்கள் பயன்பாட்டின் வடிவமைப்பை உன்னிப்பாகப் பார்த்து, உங்களுக்கு உண்மையிலேயே இந்தத் தரவு அல்லது அந்தத் தரவு தேவையா என்பதைத் தீர்மானிக்கவும். ஒருவேளை உங்களிடம் உள்ள சில தரவு உண்மையில் உங்களுக்குத் தேவையில்லை - வராத மற்றும் வர வாய்ப்பில்லாத எதிர்காலத்திற்காக சேர்க்கப்பட்ட தரவு. கூடுதலாக, நீங்கள் பலர் கவனக்குறைவாக அத்தகைய தரவை பதிவு செய்வதன் மூலம் கசிய விடுகிறீர்கள். உங்கள் பதிவுகளில் முக்கியமான தரவு நுழைவதைத் தடுப்பதற்கான எளிதான வழி, டொமைன் நிறுவனங்களின் (பயனர், மாணவர், ஆசிரியர் போன்றவை) toString() முறைகளை ஸ்க்ரப் செய்வதாகும். இது தற்செயலாக ரகசிய புலங்களை வெளியிடுவதைத் தடுக்கும். toString()ஐ உருவாக்க நீங்கள் Lombok ஐப் பயன்படுத்தினால்முறை, toString() முறையின் வெளியீட்டில் புலம் பயன்படுத்தப்படுவதைத் தடுக்க @ToString.Exclude சிறுகுறிப்பைப் பயன்படுத்தலாம் . மேலும், வெளி உலகத்திற்கு தரவுகளை அனுப்பும் போது மிகவும் கவனமாக இருக்க வேண்டும். எல்லா பயனர்களின் பெயர்களையும் காட்டும் HTTP எண்ட்பாயிண்ட் எங்களிடம் உள்ளது என்று வைத்துக்கொள்வோம். பயனரின் தனிப்பட்ட அக ஐடியைக் காட்ட வேண்டிய அவசியமில்லை. ஏன்? ஏனெனில், தாக்குபவர், பயனரைப் பற்றிய மற்ற, மிக முக்கியமான தகவல்களைப் பெற இதைப் பயன்படுத்தலாம். எடுத்துக்காட்டாக, POJO ஐ JSON க்கு/இலிருந்து சீரியல்/டீரியலைஸ் செய்ய ஜாக்சனைப் பயன்படுத்தினால் , நீங்கள் @JsonIgnore மற்றும் @JsonIgnoreProperties ஐப் பயன்படுத்தலாம்.குறிப்பிட்ட புலங்களின் வரிசைப்படுத்தல்/விலகல்மயமாக்கலைத் தடுப்பதற்கான சிறுகுறிப்புகள். பொதுவாக, நீங்கள் வெவ்வேறு இடங்களில் வெவ்வேறு POJO வகுப்புகளைப் பயன்படுத்த வேண்டும். அதற்கு என்ன பொருள்?

1. தரவுத்தளத்துடன் பணிபுரியும் போது, ​​ஒரு வகை POJO (ஒரு நிறுவனம்) பயன்படுத்தவும்.
2. வணிக தர்க்கத்துடன் பணிபுரியும் போது, ​​ஒரு நிறுவனத்தை ஒரு மாதிரியாக மாற்றவும்.
3. வெளி உலகத்துடன் பணிபுரியும் போது மற்றும் HTTP கோரிக்கைகளை அனுப்பும் போது, ​​வெவ்வேறு நிறுவனங்களை (DTOக்கள்) பயன்படுத்தவும்.

இதன் மூலம் வெளியில் இருந்து எந்த புலங்கள் தெரியும் மற்றும் எது இருக்காது என்பதை நீங்கள் தெளிவாக வரையறுக்கலாம்.

வலுவான குறியாக்கம் மற்றும் ஹாஷிங் அல்காரிதம்களைப் பயன்படுத்தவும்

வாடிக்கையாளர்களின் ரகசியத் தகவல்கள் பாதுகாப்பாகச் சேமிக்கப்பட வேண்டும். இதைச் செய்ய, நாம் குறியாக்கத்தைப் பயன்படுத்த வேண்டும். பணியைப் பொறுத்து, எந்த வகையான குறியாக்கத்தைப் பயன்படுத்த வேண்டும் என்பதை நீங்கள் தீர்மானிக்க வேண்டும். கூடுதலாக, வலுவான குறியாக்கம் அதிக நேரம் எடுக்கும், எனவே மீண்டும் அதன் தேவை எவ்வளவு நேரம் செலவழிக்கிறது என்பதை நீங்கள் கருத்தில் கொள்ள வேண்டும். நிச்சயமாக, நீங்கள் ஒரு குறியாக்க அல்காரிதத்தை நீங்களே எழுதலாம். ஆனால் இது தேவையற்றது. இந்த பகுதியில் இருக்கும் தீர்வுகளை நீங்கள் பயன்படுத்தலாம். எடுத்துக்காட்டாக, Google Tink :

<!-- https://mvnrepository.com/artifact/com.google.crypto.tink/tink -->
<dependency>
   <groupid>com.google.crypto.tink</groupid>
   <artifactid>tink</artifactid>
   <version>1.3.0</version>
</dependency>

குறியாக்கம் மற்றும் மறைகுறியாக்கம் சம்பந்தப்பட்ட இந்த எடுத்துக்காட்டைப் பயன்படுத்தி என்ன செய்வது என்று பார்ப்போம்:

private static void encryptDecryptExample() {
   AeadConfig.register();
   KeysetHandle handle = KeysetHandle.generateNew(AeadKeyTemplates.AES128_CTR_HMAC_SHA256);

   String plaintext = "Elvis lives!";
   String aad = "Buddy Holly";

   Aead aead = handle.getPrimitive(Aead.class);
   byte[] encrypted = aead.encrypt(plaintext.getBytes(), aad.getBytes());
   String encryptedString = Base64.getEncoder().encodeToString(encrypted);
   System.out.println(encryptedString);

   byte[] decrypted = aead.decrypt(Base64.getDecoder().decode(encrypted), aad.getBytes());
   System.out.println(new String(decrypted));
}

கடவுச்சொற்களை குறியாக்குதல்

இந்த பணிக்கு, சமச்சீரற்ற குறியாக்கத்தைப் பயன்படுத்துவது பாதுகாப்பானது. ஏன்? ஏனெனில் பயன்பாடு உண்மையில் கடவுச்சொற்களை மறைகுறியாக்க தேவையில்லை. இதுவே நிலையான அணுகுமுறை. உண்மையில், ஒரு பயனர் கடவுச்சொல்லை உள்ளிடும்போது, ​​கணினி அதை குறியாக்கம் செய்து கடவுச்சொல் கடையில் உள்ளவற்றுடன் ஒப்பிடுகிறது. அதே குறியாக்க செயல்முறை செய்யப்படுகிறது, எனவே அவை பொருந்தும் என்று எதிர்பார்க்கலாம், சரியான கடவுச்சொல் உள்ளிடப்பட்டால், நிச்சயமாக :) BCrypt மற்றும் SCrypt இங்கே பொருத்தமானவை. இரண்டும் ஒருவழிச் செயல்பாடுகள் (கிரிப்டோகிராஃபிக் ஹாஷ்கள்) நீண்ட நேரம் எடுக்கும் கணக்கீட்டுரீதியாக சிக்கலான அல்காரிதம்கள். இதுவே நமக்குத் தேவை, ஏனென்றால் நேரடிக் கணக்கீடுகள் என்றென்றும் எடுக்கும் (நன்றாக, நீண்ட, நீண்ட நேரம்). ஸ்பிரிங் செக்யூரிட்டி முழு அளவிலான அல்காரிதம்களை ஆதரிக்கிறது. நாம் SCryptPasswordEncoder மற்றும் BCryptPasswordEncoder ஐப் பயன்படுத்தலாம். தற்போது வலுவான என்க்ரிப்ஷன் அல்காரிதம் என கருதப்படுவது அடுத்த ஆண்டு பலவீனமாக கருதப்படலாம். இதன் விளைவாக, நாங்கள் பயன்படுத்தும் அல்காரிதம்களை தவறாமல் சரிபார்த்து, தேவைக்கேற்ப, குறியாக்க அல்காரிதம்களைக் கொண்ட நூலகங்களைப் புதுப்பிக்க வேண்டும் என்று முடிவு செய்கிறோம்.

ஒரு முடிவுக்கு பதிலாக

இன்று நாம் பாதுகாப்பைப் பற்றி பேசினோம், இயற்கையாகவே, நிறைய விஷயங்கள் திரைக்குப் பின்னால் விடப்பட்டன. நான் உங்களுக்காக ஒரு புதிய உலகத்திற்கான கதவைத் திறந்தேன், அதன் சொந்த வாழ்க்கையைக் கொண்ட ஒரு உலகம். பாதுகாப்பு என்பது அரசியலைப் போன்றது: நீங்கள் அரசியலில் ஈடுபடவில்லை என்றால், அரசியல் உங்களுடன் மும்முரமாக இருக்கும். GitHub கணக்கில் என்னைப் பின்தொடருமாறு நான் பாரம்பரியமாக பரிந்துரைக்கிறேன் . நான் படித்துக் கொண்டிருக்கும் மற்றும் வேலையில் விண்ணப்பிக்கும் பல்வேறு தொழில்நுட்பங்களை உள்ளடக்கிய எனது படைப்புகளை அங்கு பதிவிடுகிறேன்.

பயனுள்ள இணைப்புகள்

1. குரு99: SQL ஊசி பயிற்சி
2. ஆரக்கிள்: ஜாவா பாதுகாப்பு வள மையம்
3. ஆரக்கிள்: ஜாவா எஸ்இக்கான பாதுகாப்பான குறியீட்டு வழிகாட்டுதல்கள்
4. Baeldung: ஜாவா பாதுகாப்பின் அடிப்படைகள்
5. நடுத்தரம்: உங்கள் ஜாவா பாதுகாப்பை மேம்படுத்த 10 உதவிக்குறிப்புகள்
6. Snyk: 10 ஜாவா பாதுகாப்பு சிறந்த நடைமுறைகள்
7. கிட்ஹப்: கிட்ஹப் பாதுகாப்பு ஆய்வகத்தை அறிவிக்கிறது: உலகின் குறியீட்டை ஒன்றாகப் பாதுகாத்தல்