system: You are an expert security code reviewer. You will be shown a source code file along with a multiple-choice question listing several function or class names from that file. Your task is to identify which one contains the specified CWE vulnerability.

OUTPUT FORMAT: Respond with the single letter of the correct option, wrapped in \boxed{...}. Example: `\boxed{B}`. Output the boxed letter ONLY -- no explanation, no other text.

user: ```python
import os
import socket
import sys

import boto3

sys.path.append(os.path.abspath(os.path.join(__file__, "../../../")))
import logging

import v2.utils.utils as utils
from botocore.client import Config

log = logging.getLogger()


class Auth(object):
    """
    This class is used to perform authentication.
    The functions in this class are
    1. do_auth() : Authenticate using resource
    2. do_auth_using_client() : Authenticate using client
    """

    def __init__(self, user_info, ssh_con=None, **extra_kwargs):
        """
        Initializes the variables of user_info parameter
        """
        self.access_key = user_info["access_key"]
        self.secret_key = user_info["secret_key"]
        if ssh_con is not None:
            stdin, stdout, stderr = ssh_con.exec_command("hostname")
            self.hostname = stdout.readline().strip()
            self.port = utils.get_radosgw_port_no(ssh_con)
            stdin, stdout, stderr = ssh_con.exec_command(
                "hostname -I | awk '{print $1}'"
            )
            self.ip = stdout.readline().strip()
        else:
            self.hostname = socket.gethostname()
            self.port = utils.get_radosgw_port_no()
            self.ip = socket.gethostbyname(self.hostname)
        self.ssl = extra_kwargs.get("ssl", False)
        self.haproxy = extra_kwargs.get("haproxy", False)
        if self.haproxy:
            self.port = 5000
        self.endpoint_url = (
            "https://{}:{}".format(self.ip, self.port)
            if self.ssl
            else "http://{}:{}".format(self.ip, self.port)
        )
        self.is_secure = False
        self.user_id = user_info["user_id"]
        self.session_token = user_info.get("session_token")
        log.info("access_key: %s" % self.access_key)
        log.info("secret_key: %s" % self.secret_key)
        log.info("hostname: %s" % self.hostname)
        log.info("port: %s" % self.port)
        log.info("user_id: %s" % self.user_id)
        log.info("endpoint url: %s" % self.endpoint_url)
        log.info("ssl: %s" % self.ssl)
        log.info("session_token: %s" % self.session_token)

    def do_auth(self, **config):
        """
        This function is to perform authentication using resource
        Parameters:
            **config: Configuration details
        Returns:
            rgw: Connection status
        """
        log.info("performing authentication")
        additional_config = Config(
            signature_version=config.get("signature_version", None)
        )

        rgw = boto3.resource(
            "s3",
            aws_access_key_id=self.access_key,
            aws_secret_access_key=self.secret_key,
            endpoint_url=self.endpoint_url,
            use_ssl=self.ssl,
            verify=False,
            config=additional_config,
            region_name="",
            aws_session_token=self.session_token if self.session_token else None,
        )

        log.info("connected")
        return rgw

    def do_auth_using_client(self, **config):
        """
        This function is to perform authentication using client module

        Parameters:
            **config: Configuration details

        Returns:
            rgw: Connection status
        """
        log.info("performing authentication using client module")
        additional_config = Config(
            signature_version=config.get("signature_version", None)
        )
        rgw = boto3.client(
            "s3",
            aws_access_key_id=self.access_key,
            aws_secret_access_key=self.secret_key,
            endpoint_url=self.endpoint_url,
            config=additional_config,
            verify=False,
            region_name="",
            aws_session_token=self.session_token if self.session_token else None,
        )
        return rgw

    def do_auth_iam_client(self, **extra_config):
        """
        perform authentication using iam client
        :param extra_config: extra config for config key
        :return: rgw connection object
        """

        log.info("performing authentication using sts client")
        rgw = boto3.client(
            "iam",
            aws_access_key_id=self.access_key,
            aws_secret_access_key=self.secret_key,
            endpoint_url=self.endpoint_url,
            region_name="",
            verify=False,
        )

        return rgw

    def do_auth_sts_client(
        self,
    ):
        """
        :return: connection object
        """

        sts_client = boto3.client(
            "sts",
            aws_access_key_id=self.access_key,
            aws_secret_access_key=self.secret_key,
            endpoint_url=self.endpoint_url,
            region_name="",
            verify=False,
        )

        return sts_client

    def do_auth_sns_client(
        self,
    ):
        """
        :return: connection object
        """

        sns_client = boto3.client(
            "sns",
            aws_access_key_id=self.access_key,
            aws_secret_access_key=self.secret_key,
            endpoint_url=self.endpoint_url,
            region_name="",
            config=Config(signature_version="s3"),
            verify=False,
        )

        return sns_client

```

Which of the following functions or classes contains a `CWE-312: Cleartext Storage of Sensitive Information` vulnerability?

  A) do_auth_iam_client
  B) do_auth_using_client
  C) do_auth_sts_client
  D) __init__
Answer: D