docs: def __verify_minion(self, id_, token):
          '''
          Take a minion id and a string signed with the minion private key
          The string needs to verify as 'salt' with the minion public key
  
          :param str id_: A minion ID
          :param str token: A string signed with the minion private key
  
          :rtype: bool
          :return: Boolean indicating whether or not the token can be verified.
          '''
          if not salt.utils.verify.valid_id(self.opts, id_):
              return False
          pub_path = os.path.join(self.opts['pki_dir'], 'minions', id_)
  
          try:
              pub = salt.crypt.get_rsa_pub_key(pub_path)
          except (IOError, OSError):
              log.warning(
                  'Salt minion claiming to be %s attempted to communicate with '
                  'master, but key could not be read and verification was denied.',
                  id_
              )
              return False
          except (ValueError, IndexError, TypeError) as err:
              log.error('Unable to load public key "%s": %s', pub_path, err)
          try:
              if salt.crypt.public_decrypt(pub, token) == b'salt':
                  return True
          except ValueError as err:
              log.error('Unable to decrypt token: %s', err)
  
          log.error(
              'Salt minion claiming to be %s has attempted to communicate with '
              'the master and could not be verified', id_
          )
          return False