இயல்புநிலை அமைப்பு உரை JSON தொடராக்கத்தில் உள்ள மறைமுக அபாயங்கள்
System.Text.Json நூலகம் பெரும்பாலான நவீன .NET பயன்பாடுகளுக்கு இயல்புநிலையாகிவிட்டது. இது திறமையானது, குறைந்த வளங்களைப் பயன்படுத்தக்கூடியது, மற்றும் ASP.NET Core உடன் ஆழமாக ஒருங்கிணைக்கப்பட்டுள்ளது. ஆனால், இதை எளிமையாக்கும் அதே இயல்புநிலைகள், மறைமுகமான பாதுகாப்பு அபாயங்களையும் அறிமுகப்படுத்துகின்றன. இயல்பாக, System.Text.Json சீரியலைசேஷன், டோக்கன்கள் அல்லது உள் அடையாளங்காட்டிகள் போன்ற முக்கியமான தரவுகளைக் கொண்டிருக்கும் பொதுவான பண்புகள் உட்பட, அனைத்து பொதுவான பண்புகளையும் தானாகவே சீரியலைஸ் செய்கிறது. டெவலப்பர்கள் பெரும்பாலும் வேகத்திற்காக இந்த இயல்புநிலைகளைச் சார்ந்திருக்கிறார்கள், ஆனால் அவை API பதில்களில் (jsonserializer) இரகசியத் தகவல்களை வெளிப்படுத்தக்கூடும் என்பதைக் கவனிக்கத் தவறுகிறார்கள்.
⚠️இது கல்வி நோக்கங்களுக்காக மட்டுமேயான, பாதுகாப்பற்ற எடுத்துக்காட்டு. உற்பத்திப் பணிகளில் பயன்படுத்த வேண்டாம்.
public class UserProfile { public string UserName { get; set; } public string Email { get; set; } public string SessionToken { get; set; } // Sensitive field } var json = JsonSerializer.Serialize(userProfile); Console.WriteLine(json); // Output: {"UserName":"alex","Email":"alex@example.com","SessionToken":"eyJhbGciOi..."} இந்த jsonserializer நடத்தை வெளிப்படுத்துகிறது செஷன் டோக்கன் ஏனெனில் அனைத்து பொதுப் பண்புகளும் தானாகவே வரிசைப்படுத்தப்படுகின்றன.
பாதுகாப்பான பதிப்பு:
public class UserProfile { public string UserName { get; set; } public string Email { get; set; } [JsonIgnore] // Prevent serialization of sensitive fields public string SessionToken { get; set; } } கல்விசார் குறிப்பு: எப்போதும் பயன்படுத்துங்கள் [JsonIgnore] முக்கியமான பண்புகளுக்கு, அல்லது வரிசைப்படுத்தலுக்காக உத்தேசிக்கப்பட்ட புலங்களை மட்டும் கொண்ட தனி DTO-க்களை வடிவமைக்கவும்.
எச்சரிக்கையின்றி JsonSerializer எவ்வாறு பாதிப்பை அதிகரிக்கிறது
System.Text.Json-இல் உள்ள JsonSerializer மேலோட்டமான செயல்பாட்டுடன் நின்றுவிடுவதில்லை. அது உள்ளமைக்கப்பட்ட பொருள்கள், தொகுப்புகள் மற்றும் enum மதிப்புகள் வழியாக மீள்சுழற்சி முறையில் பயணித்து, தன்னால் அணுக முடிந்த அனைத்தையும் வரிசைப்படுத்துகிறது. வெளிப்படையான விலக்கு இல்லாமல், இது எளிதில் உள்ளமைந்த தரவுக் கசிவுகளுக்கு வழிவகுக்கும், குறிப்பாக உள்ளகப் பொருள்கள் டோக்கன்கள், அடையாளங்காட்டிகள் அல்லது அமர்வுத் திறவுகோல்களைக் கொண்டிருக்கும்போது.
⚠️இது கல்வி நோக்கங்களுக்காக மட்டுமேயான, பாதுகாப்பற்ற எடுத்துக்காட்டு. உற்பத்திப் பணிகளில் பயன்படுத்த வேண்டாம்.
public class AuthData { public string AccessToken { get; set; } // Sensitive } public class ApiResponse { public string Message { get; set; } public AuthData AuthInfo { get; set; } // Nested object } var json = JsonSerializer.Serialize(new ApiResponse { Message = "OK", AuthInfo = new AuthData { AccessToken = "abc123" } }); Console.WriteLine(json); // Output: {"Message":"OK","AuthInfo":{"AccessToken":"abc123"}} உள்ளமைக்கப்பட்ட பொருள், கணினி உரை ஜேசன் தொடராக்கத்தில் முக்கியமானவற்றை உள்ளடக்குமாறு செய்கிறது. அணுகல் டோக்கன் தானாக.
பாதுகாப்பான பதிப்பு:
public class AuthData { [JsonIgnore] // Prevent exposure of sensitive tokens public string AccessToken { get; set; } } public class ApiResponse { public string Message { get; set; } public AuthData AuthInfo { get; set; } } var options = new JsonSerializerOptions { DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingDefault, WriteIndented = false }; var json = JsonSerializer.Serialize(apiResponse, options); கல்விசார் குறிப்பு: எப்போதும் வரையறுக்கவும் JsonSerializerOptions வெளிப்படையாகத் தெரிவித்து, எதிர்பாராத தரவு வெளிப்பாட்டிற்காக உள்ளமைக்கப்பட்ட வகைகளை மதிப்பாய்வு செய்யவும்.
ஏபிஐகள் மற்றும் மைக்ரோசர்வீஸ்களில் நிஜ உலகத் தாக்கம்
நிஜ உலக .NET பயன்பாடுகளில், இந்த சீரியலைசேஷன் அபாயங்கள் பெரும்பாலும் செயல்படுத்தப்பட்ட பின்னரே கவனிக்கப்படுகின்றன. ஆட்டோமேஷன், DTO மறுபயன்பாடு மற்றும் இயல்புநிலை jsonserializer நடத்தை ஆகியவற்றின் ஒருங்கிணைப்பு, இந்த அபாய வெளிப்பாட்டை அதிகரிக்கிறது. பாதுகாப்பற்ற தொடராக்கம் தரவுகளைக் கசியவிடும் பொதுவான முறைகள்:
- EF Core என்டிட்டிகளை API பதில்களில் நேரடியாக மீண்டும் பயன்படுத்துதல்.
அங்கீகாரத் தரவைக் கொண்ட வரிசைப்படுத்தப்பட்ட பொருள்களைப் பதிவு செய்தல். - உள் மற்றும் பொது சேவைகளுக்கு இடையிலான பகிர்வு மாதிரிகள் CI/CD pipelines.
⚠️இது கல்வி நோக்கங்களுக்காக மட்டுமேயான, பாதுகாப்பற்ற எடுத்துக்காட்டு. உற்பத்திப் பணிகளில் பயன்படுத்த வேண்டாம்.
// Logs the full object, including sensitive fields _logger.LogInformation("Response: {data}", JsonSerializer.Serialize(result)); என்றால் விளைவாக கொண்டுள்ளது கடவுச்சொல் ஹாஷ் or செஷன் டோக்கன், இவை இப்போது சேமிக்கப்பட்டுள்ளன CI/CD பதிவுகள், மீறுதல் குறைந்தபட்ச சிறப்புரிமைக் கொள்கைகள். உண்மையான டோக்கன்கள், நற்சான்றிதழ்கள் அல்லது உள் URL-களை ஒருபோதும் வெளிப்படுத்தாதீர்கள். pipelines.
பாதுகாப்பான பதிப்பு:
var options = new JsonSerializerOptions { IgnoreReadOnlyProperties = true, DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull }; // Sanitize before serialization result.SessionToken = null; _logger.LogInformation("Response: {data}", JsonSerializer.Serialize(result, options)); கல்விசார் குறிப்பு: பதிவு செய்வதற்கு முன் முக்கியமான புலங்களைத் தூய்மைப்படுத்தவும் அல்லது செயலிழக்கச் செய்யவும், மேலும் எப்போதும் பாதுகாப்பானதைப் பயன்படுத்தவும். JsonSerializerOptions தணிக்கை வெளியீட்டிற்கான இயல்புநிலைகள்.
டெவலப்பர்களுக்கான பாதுகாப்பான சீரியலைசேஷன் நடைமுறைகள்
டெவலப்பர்கள் system.text.json இயல்புநிலைகளை ஒரு பாதுகாப்புக் கொள்கையாகக் கருதாமல், ஒரு வசதிக்கான அடுக்காகவே கருத வேண்டும். பாதுகாப்பான சிஸ்டம் டெக்ஸ்ட் JSON சீரியலைசேஷன் என்பது, உங்கள் அப்ளிகேஷனிலிருந்து வெளியேறும் உள்ளடக்கத்தின் மீது கட்டுப்பாட்டை எடுத்துக்கொள்வதாகும்.
நடைமுறை பாதுகாப்புகள்
- வெளிப்படையான ஒப்பந்தங்களை வரையறுக்கவும்: API பதில்களுக்காக பிரத்யேக DTO-க்களை உருவாக்கவும், EF அல்லது டொமைன் என்டிட்டிகளை ஒருபோதும் நேரடியாக சீரியலைஸ் செய்யாதீர்கள்.
- உலகளாவிய விருப்பங்களை உள்ளமைக்கவும்: பயன்பாட்டு JsonSerializerOptions.DefaultIgnoreCondition மற்றும் சொத்து பெயரிடல் கொள்கை.
- விண்ணப்பிக்க [JsonIgnore] அல்லது மாற்றிகள்: முக்கியமான தரவுகளை மறைக்கவும் அல்லது மாற்றவும்.
- வெளியீடுகளைச் சரிபார்க்கவும்: சோதனைகளில் வரிசைப்படுத்தப்பட்ட உண்மையான பதில்களைச் சரிபார்க்கவும்.
- சோதனைகளைத் தானியங்குபடுத்துங்கள்: வரிசைப்படுத்தல் சரிபார்ப்பைச் சேர்க்கவும் CI/CD.
சிறு தடுப்பு சரிபார்ப்புப் பட்டியல்
- System.Text.Json தொடராக்கத்தைப் பயன்படுத்தும் அனைத்து வகுப்புகளையும் மதிப்பாய்வு செய்யவும்
- இரகசியங்கள் அல்லது சான்றுகளைக் குறிக்கவும் [JsonIgnore]
- உலகளாவிய பாதுகாப்பான இயல்புநிலைகளை வரையறுக்கவும் Program.cs or Startup.cs
- பதிவுகளில் நேரடி வரிசைப்படுத்தலைத் தவிர்க்கவும்
- உங்கள் வரிசைப்படுத்தல் வெளிப்பாட்டு சோதனைகளைச் சேர்க்கவும் CI/CD pipeline
கல்விசார் குறிப்பு: பாதுகாப்பான சீரியலைசேஷன் என்பது பாதிப்பைக் குறைப்பதே தவிர, சிக்கலை அதிகரிப்பது அல்ல. சீரியலைசேஷனைத் தெளிவானதாகவும் சோதிக்கக்கூடியதாகவும் ஆக்குங்கள்.
தானியங்கு ஸ்கேனிங் மூலம் பாதுகாப்பற்ற தொடராக்கத்தைக் கண்டறிதல் – System.Text.Json
தானியங்கி ஸ்கேன் CI/CD System.Text.Json மற்றும் JsonSerializer ஆகியவற்றின் அபாயகரமான பயன்பாட்டைக் கண்டறிய உதவுகிறது. நிலையான பகுப்பாய்வுக் கருவிகளால் அடையாளம் காண முடியும்:
- மாதிரிகள் காணவில்லை [JsonIgnore].
- DTO-க்களில் வெளிப்படும் உணர்திறன் மிக்க புலங்கள்.
- பாதுகாப்பற்ற உலகளாவிய இயல்புநிலைகள் (எ.கா., புறக்கணிப்பு நிபந்தனைகள் இல்லாமை).
உதாரணமாக Pipeline சரிபார்க்கவும்
# Never expose real tokens, credentials, or internal URLs in pipelines - name: Run serialization security checks run: dotnet xygeni validate --rules serialization --fail-on-risk கல்விசார் குறிப்பு: ஒருங்கிணைத்தல் நிலையான சோதனைகள் உன் மீது CI/CD அனைத்து உருவாக்கங்களிலும் கணினி உரை JSON தொடராக்கத்தின் மீது சீரான கட்டுப்பாட்டை உறுதி செய்கிறது.
எப்படி Xygeni Code Security .NET தொடராக்கப் பாதுகாப்பை வலுப்படுத்துகிறது
சைஜெனி Code Security NET-இல் பாதுகாப்பற்ற System.Text.Json இயல்புநிலைகளையும் JsonSerializer-இன் தவறான பயன்பாட்டையும் ஆழமாகக் கண்டறிகிறது.
இது போன்ற வடிவங்களை இது அடையாளம் காட்டுகிறது:
- முக்கியமான புலங்கள் இயல்பாகவே வரிசைப்படுத்தப்படுகின்றன.
- JSON தரவின் பாதுகாப்பற்ற பதிவு.
- காணாமல் [JsonIgnore] பண்புகளை.
- தவறாக உள்ளமைக்கப்பட்ட கணினி உரை JSON தொடராக்க விருப்பங்கள்.
ஒருங்கிணைப்பதன் மூலம் சைஜெனி ஒரு pre-commit hooks, CI/CD pipeline`s` அல்லது `PR gates` போன்றவற்றின் மூலம், பாதிப்புக்குள்ளாகக்கூடிய சீரியலைசேஷன் பேட்டர்ன்கள் ஒன்றிணைவதற்கு முன்பே அவற்றை நீங்கள் தடுக்கலாம். இது, சீரியலைசேஷன் தவறான உள்ளமைவுகளைச் செயல்படுத்தக்கூடிய பாதுகாப்புக் கொள்கைகளாக மாற்றுவதன் மூலம், உங்களுடைய தற்போதைய DevSecOps செயல்முறைக்குத் துணைபுரிகிறது.
கல்விசார் குறிப்பு: Xygeni போன்ற பாதுகாப்புக் கருவிகள் வரிசைப்படுத்தல் தூய்மையைத் தானாகவே அமல்படுத்துகின்றன. டெவலப்பர்களை தணிக்கைகளில் கவனம் செலுத்தாமல், குறியீட்டில் கவனம் செலுத்த விடுவிக்கிறது.
முடிவுரை – பற்றி சிஸ்டம்.டெக்ஸ்ட்.ஜேசன்
சிஸ்டம்.டெக்ஸ்ட்.ஜேசன் சீரியலைசேஷனை வேகமாக்குகிறது, ஆனால் இந்த வசதி பெரும்பாலும் ஆபத்துகளை மறைத்துவிடுகிறது. இயல்புநிலை system.text.json சீரியலைசேஷன் ஒவ்வொரு பப்ளிக் பிராப்பர்ட்டியையும் உள்ளடக்கியுள்ளது, இதனால் உள் தரவுகள், டோக்கன்கள் அல்லது அடையாளங்காட்டிகள் கசியக்கூடும்.
உருவாக்குநர்கள் செய்ய வேண்டியவை:
- அவர்களின் மாதிரிகளைத் தணிக்கை செய்யுங்கள்.
- பயன்பாட்டு [JsonIgnore] மற்றும் பாதுகாப்பானது JsonSerializerOptions.
- உள்ளகப் பொருள்களை வரிசைப்படுத்துவதைத் தவிர்க்கவும்.
- போன்ற கருவிகளைப் பயன்படுத்தி ஸ்கேனைத் தானியங்குபடுத்துங்கள் Xygeni Code Security.
இயல்புநிலை வரிசைப்படுத்தல் என்பது டெவலப்பர்களுக்கான ஒரு குறுக்குவழி மட்டுமல்ல; அது தரவுக் கசிவுக்கான ஒரு சாத்தியமான காரணியாகும். வரிசைப்படுத்தலைத் தெளிவாக வரையறுத்து, வெளியீடுகளைச் சரிபார்த்து, சோதனைகளைத் தானியங்குபடுத்துங்கள், ஏனெனில் பாதுகாப்பான இயல்புநிலைகள் எப்போதும் பாதுகாப்பானவையாக இருப்பதில்லை.
