system: You are an expert security code reviewer. You will be shown a source code file along with a multi-select question listing several CWE (Common Weakness Enumeration) categories. Your task is to identify which of the listed CWEs are present in the code.

OUTPUT FORMAT: Respond with the letter(s) of all correct options, sorted alphabetically and comma-separated, wrapped in a single \boxed{...}. Examples: `\boxed{A}` for one correct, `\boxed{A,C}` for two, `\boxed{A,C,E}` for three. Output the boxed answer ONLY -- no explanation, no other text.

user: ```python
import os
import logging
from datetime import datetime, timezone
from ibm_botocore.credentials import DefaultTokenManager

from lithops.utils import is_lithops_worker
from lithops.config import load_yaml_config, dump_yaml_config
from lithops.constants import CACHE_DIR

logger = logging.getLogger(__name__)


class IBMTokenManager:

    def __init__(self, api_key, api_key_type='IAM', token=None, token_expiry_time=None):
        self.api_key = api_key
        self.api_key_type = api_key_type

        self._token_manager = DefaultTokenManager(api_key_id=self.api_key)
        self._token_filename = os.path.join(CACHE_DIR, 'ibm_{}'.format(api_key_type.lower()), 'token')

        if token:
            logger.debug("Using IBM {} API Key - Reusing Token from config".format(self.api_key_type))
            self._token_manager._token = token
            self._token_manager._expiry_time = datetime.strptime(token_expiry_time,
                                                                 '%Y-%m-%d %H:%M:%S.%f%z')
            logger.debug("Token expiry time: {} - Minutes left: {}"
                         .format(self._token_manager._expiry_time,
                                 self._get_token_minutes_diff()))

        elif os.path.exists(self._token_filename):
            logger.debug("Using IBM {} API Key - Reusing Token from local cache".format(self.api_key_type))
            token_data = load_yaml_config(self._token_filename)
            self._token_manager._token = token_data['token']
            self._token_manager._expiry_time = datetime.strptime(token_data['token_expiry_time'],
                                                                 '%Y-%m-%d %H:%M:%S.%f%z')
            logger.debug("Token expiry time: {} - Minutes left: {}".
                         format(self._token_manager._expiry_time,
                                self._get_token_minutes_diff()))

    def _is_token_expired(self):
        """
        Checks if a token already expired
        """
        return self._get_token_minutes_diff() < 1

    def _get_token_minutes_diff(self):
        """
        Gets the remaining minutes in which the current token is valid
        """
        expiry_time = self._token_manager._expiry_time
        return max(0, int((expiry_time - datetime.now(timezone.utc)).total_seconds() / 60.0))

    def _generate_new_token(self):
        self._token_manager._token = None
        self._token_manager.get_token()
        token_data = {}
        token_data['token'] = self._token_manager._token
        token_data['token_expiry_time'] = self._token_manager._expiry_time.strftime('%Y-%m-%d %H:%M:%S.%f%z')
        dump_yaml_config(self._token_filename, token_data)
        logger.debug("Token expiry time: {} - Minutes left: {}".
                     format(self._token_manager._expiry_time,
                            self._get_token_minutes_diff()))

    def get_token(self):
        """
        Gets a new token within a mutex block to prevent multiple threads
        requesting new tokens at the same time.
        """
        if (self._token_manager._is_expired() or self._is_token_expired()) \
           and not is_lithops_worker():
            logger.debug("Token expired. Requesting new token".format(self.api_key_type))
            self._generate_new_token()

        token = self._token_manager._token
        token_expiry_time = self._token_manager._expiry_time.strftime('%Y-%m-%d %H:%M:%S.%f%z')

        return token, token_expiry_time

```

Which of the following CWE vulnerability categories are present in this code? Multiple options may be correct.

  A) CWE-730: OWASP Top Ten 2004 Category A9 - Denial of Service
  B) CWE-74: Improper Neutralization of Special Elements in Output Used by a Downstream Component ('Injection')
  C) CWE-312: Cleartext Storage of Sensitive Information
  D) CWE-502: Deserialization of Untrusted Data
  E) CWE-643: Improper Neutralization of Data within XPath Expressions ('XPath Injection')
  F) CWE-776: Improper Restriction of Recursive Entity References in DTDs ('XML Entity Expansion')
Answer: C