Cleartext Storage of Sensitive Information

// model/User.java
@Entity
public class User {
    // ... id, username ...
    // DANGEROUS: Password stored directly.
    private String plainPassword;
    // ... getters/setters ...
}
// Assume service layer saves this field directly without hashing.

// service/PaymentService.java
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class PaymentService {
    private static final Logger log = LoggerFactory.getLogger(PaymentService.class);

    public void processPayment(String creditCardNumber, String cvv, ...) {
        // DANGEROUS: Logging full credit card number and CVV.
        log.info("Processing payment for card: {}, CVV: {}", creditCardNumber, cvv);
        // ... processing logic ...
    }
}

// model/User.java (Secure - Stores Hash)
@Entity
public class User {
    // ... id, username ...
    // SECURE: Store the hashed password.
    private String passwordHash;
    // NO plainPassword field!
    // ... getters/setters for passwordHash ...
}

// service/UserService.java (Secure Hashing)
@Service
public class UserService {
    @Autowired private PasswordEncoder passwordEncoder;
    @Autowired private UserRepository userRepository;

    public User registerUser(String username, String rawPassword) {
        User user = new User();
        user.setUsername(username);
        // SECURE: Hash password before saving.
        user.setPasswordHash(passwordEncoder.encode(rawPassword));
        return userRepository.save(user);
    }
}

// model/Config.java (Secure Encryption using Attribute Converter - Conceptual)
@Entity
public class Config {
    @Id private Long id;
    // SECURE: Apply converter to encrypt/decrypt this field automatically.
    @Convert(converter = AesCryptoConverter.class)
    private String sensitiveApiKey;
}
// Need to implement AesCryptoConverter using javax.crypto.Cipher
// and SECURELY manage the encryption key used by the converter.

// service/PaymentService.java (Secure Logging)
public class PaymentService {
    private static final Logger log = LoggerFactory.getLogger(PaymentService.class);

    public void processPayment(String creditCardNumber, String cvv, ...) {
        // SECURE: Mask sensitive data before logging.
        String maskedCard = maskCardNumber(creditCardNumber); // Implement masking logic
        log.info("Processing payment for card ending in: {}", maskedCard); // Log only masked data
        // DO NOT log CVV at all (PCI-DSS compliance)
        // ... processing logic ...
    }
    // Implement maskCardNumber appropriately (e.g., show last 4 digits)
}

// Models/LegacyUser.cs
public class LegacyUser
{
    public int Id { get; set; }
    public string Username { get; set; }
    // DANGEROUS: Property to store password directly.
    public string ClearTextPassword { get; set; }
}
// Assume DbContext saves this property directly.

// Middleware/LoggingMiddleware.cs
public class LoggingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<LoggingMiddleware> _logger;

    public LoggingMiddleware(RequestDelegate next, ILogger<LoggingMiddleware> logger) { /* ... */ }

    public async Task InvokeAsync(HttpContext context)
    {
        context.Request.EnableBuffering(); // Allow reading body multiple times
        var reader = new StreamReader(context.Request.Body);
        var body = await reader.ReadToEndAsync();
        // DANGEROUS: Logging the raw request body might include passwords, API keys, etc.
        _logger.LogInformation("Request Body: {RequestBody}", body);
        context.Request.Body.Position = 0; // Reset stream position
        await _next(context);
    }
}

// Models/ApplicationUser.cs (Secure - using Identity)
using Microsoft.AspNetCore.Identity;

// SECURE: Inherits from IdentityUser which manages PasswordHash securely.
public class ApplicationUser : IdentityUser
{
    // Add custom properties if needed, but NOT password.
}

// Service saving data (Secure Hashing via UserManager)
// private readonly UserManager<ApplicationUser> _userManager;
// ...
// var user = new ApplicationUser { UserName = model.Email, Email = model.Email };
// var result = await _userManager.CreateAsync(user, model.Password); // Hashes password

// Models/Settings.cs (Secure Encryption - conceptual using AES)
public class Settings
{
    public int Id { get; set; }
    // Store encrypted value, e.g., as Base64 string or byte[]
    public string EncryptedApiKey { get; set; }

    // Use a service to handle encryption/decryption, managing keys securely
    [NotMapped] // Tell EF not to map this property directly
    public string ApiKey
    {
        get => EncryptionService.Decrypt(EncryptedApiKey); // Needs secure key management
        set => EncryptedApiKey = EncryptionService.Encrypt(value);
    }
}

// Middleware/LoggingMiddleware.cs (Secure Logging)
public async Task InvokeAsync(HttpContext context)
{
    // SECURE: Avoid logging raw body for sensitive routes.
    // Or implement robust filtering/masking logic if body logging is essential.
    if (context.Request.Path.StartsWithSegments("/api/auth")) // Example check
    {
         _logger.LogInformation("Processing sensitive request to {Path}", context.Request.Path);
         // DO NOT log body
    }
    else
    {
        // Log body safely if needed (e.g., using filtering)
    }
    await _next(context);
}

// database/migrations/..._create_users_table.php
Schema::create('users', function (Blueprint $table) {
    // ... id, name, email ...
    // DANGEROUS: Storing password directly.
    $table->string('password_clear');
    $table->rememberToken();
    $table->timestamps();
});
// Assume Auth logic saves directly to 'password_clear'

// app/Http/Middleware/LogRequestsMiddleware.php
use Illuminate\Support\Facades\Log;

public function handle(Request $request, Closure $next)
{
    // DANGEROUS: Logging all request input might include passwords, tokens etc.
    Log::info('Request Data:', $request->all());
    return $next($request);
}

// database/migrations/..._create_users_table.php (Secure)
Schema::create('users', function (Blueprint $table) {
    // ... id, name, email ...
    // SECURE: Standard Laravel password column for hash.
    $table->string('password');
    $table->rememberToken();
    $table->timestamps();
});
// Use Hash::make() in registration/password set logic.

// app/Models/ServiceCredential.php (Secure Encryption using Attribute Casting)
use Illuminate\Database\Eloquent\Model;
use Illuminate\Contracts\Database\Eloquent\CastsAttributes; // Use correct interface if needed
use Illuminate\Contracts\Encryption\Encrypter; // Use correct interface if needed
use Illuminate\Support\Facades\Crypt; // Facade for Crypt service

class ServiceCredential extends Model
{
    // SECURE: Automatically encrypt/decrypt 'api_secret' attribute.
    protected $casts = [
        'api_secret' => 'encrypted',
    ];
    // Ensure APP_KEY is strong and secret
}

// app/Http/Middleware/LogRequestsMiddleware.php (Secure Logging)
public function handle(Request $request, Closure $next)
{
    // SECURE: Log specific, non-sensitive data or use masking.
    $logData = $request->except(['password', 'password_confirmation', '_token']); // Exclude sensitive fields
    Log::info('Filtered Request Data:', $logData);
    // Or configure Monolog processors for masking globally (see config/logging.php)
    return $next($request);
}

// models/User.js
const mongoose = require('mongoose');
const userSchema = new mongoose.Schema({
    username: { type: String, required: true, unique: true },
    // DANGEROUS: Password stored directly.
    password_plaintext: { type: String, required: true }
});
module.exports = mongoose.model('User', userSchema);
// Assume route handler saves password_plaintext directly.

// routes/profile.js
router.get('/me', ensureAuthenticated, (req, res) => {
    // DANGEROUS: If the req.user object fetched from DB contains
    // sensitive fields (e.g., password hash, tokens, PII) and is logged directly.
    console.log('User profile requested:', req.user); // Logs potentially sensitive data
    // Filter req.user before sending response too!
    res.json({ username: req.user.username /* etc */ });
});

// models/User.js (Secure - Using bcrypt pre-save hook)
const mongoose = require('mongoose');
const bcrypt = require('bcrypt');
const saltRounds = 12;

const userSchema = new mongoose.Schema({
    username: { type: String, required: true, unique: true },
    // SECURE: Store hash, not plaintext.
    passwordHash: { type: String, required: true }
});

// SECURE: Mongoose pre-save hook to hash password automatically
userSchema.pre('save', async function(next) {
    // Only hash the password if it has been modified (or is new)
    if (!this.isModified('passwordHash')) return next();
    try {
        const hash = await bcrypt.hash(this.passwordHash, saltRounds); // Assume raw password was temporarily put here
        this.passwordHash = hash;
        next();
    } catch (error) {
        next(error);
    }
});
// Add method to compare password
userSchema.methods.comparePassword = async function(candidatePassword) {
    return bcrypt.compare(candidatePassword, this.passwordHash);
};
module.exports = mongoose.model('User', userSchema);

// routes/profile.js (Secure Logging)
router.get('/me', ensureAuthenticated, (req, res) => {
    // SECURE: Log only non-sensitive fields.
    console.log(`User profile requested for ID: ${req.user.id}, Username: ${req.user.username}`);
    // Ensure response also doesn't leak sensitive data
    res.json({ id: req.user.id, username: req.user.username });
});

# app/models/legacy_user.rb
class LegacyUser < ApplicationRecord
  # DANGEROUS: Attribute stores password directly.
  # attr_accessor :plain_password # Not needed if column exists
  # Assume 'plain_password' column exists in DB and is saved directly.
end

# app/controllers/users_controller.rb
class UsersController < ApplicationController
  def show
    @user = User.find(params[:id])
    # DANGEROUS: If User model has sensitive attributes (e.g., token,
    # api_key) and the logger's default formatter outputs all attributes.
    Rails.logger.info "Showing user: #{@user.inspect}"
    render :show
  end
end

# app/models/user.rb (Secure Password)
class User < ApplicationRecord
  # SECURE: Handles password hashing via bcrypt.
  has_secure_password
  # Add other attributes, but NOT plaintext password
end

# app/models/api_credential.rb (Secure Encryption using attr_encrypted)
# gem 'attr_encrypted' # Add to Gemfile
class ApiCredential < ApplicationRecord
  # SECURE: Load encryption key securely (e.g., from Rails credentials)
  KEY = Rails.application.credentials.dig(:attr_encrypted_key) || ENV['ATTR_ENCRYPTED_KEY']
  raise "Encryption key not set!" if KEY.blank?

  # SECURE: Encrypts the api_secret attribute before saving to api_secret_encrypted column
  attr_encrypted :api_secret, key: KEY
  # Requires an `api_secret_encrypted` column in the database table.
end

# config/initializers/filter_parameter_logging.rb (Secure Logging)
# Be sure to restart your server when you modify this file.
Rails.application.config.filter_parameters += [
  :password, :secret, :token, :_key, :crypt, :salt, :certificate, :otp, :ssn, # Default Rails filters
  :api_key, :credit_card_number # Add custom sensitive parameters
]

# app/controllers/users_controller.rb (Secure Logging)
def show
    @user = User.find(params[:id])
    # SECURE: Log only specific, non-sensitive attributes.
    Rails.logger.info "Showing user ID: #{@user.id}, Username: #{@user.username}"
    render :show
end