import com.amazonaws.services.s3.model.EncryptionMaterialsProvider; //导入依赖的package包/类
@Singleton
@Provides
@Nullable
public AmazonS3 provideAmazonS3Client(@Nullable AWSCredentials awsCredentials, @Nullable EncryptionMaterialsProvider encryptionMaterialsProvider)
{
    if (awsCredentials == null) {
        if (encryptionMaterialsProvider == null) {
            return new AmazonS3Client(new InstanceProfileCredentialsProvider());
        }
        else {
            return new AmazonS3EncryptionClient(new InstanceProfileCredentialsProvider(), encryptionMaterialsProvider);
        }
    }

    if (encryptionMaterialsProvider == null) {
        return new AmazonS3Client(awsCredentials);
    }
    else {
        return new AmazonS3EncryptionClient(awsCredentials, encryptionMaterialsProvider);
    }
}
 

import com.amazonaws.services.s3.model.EncryptionMaterialsProvider; //导入依赖的package包/类
/**
 * @deprecated use {@link AmazonS3EncryptionClientBuilder#withEncryptionMaterials(EncryptionMaterialsProvider)} and
 *                 {@link AmazonS3EncryptionClientBuilder#withCredentials(AWSCredentialsProvider)} and
 *                 {@link AmazonS3EncryptionClientBuilder#withCryptoConfiguration(CryptoConfiguration)} and
 *                 {@link AmazonS3EncryptionClientBuilder#withClientConfiguration(ClientConfiguration)} and
 *                 {@link AmazonS3EncryptionClientBuilder#withMetricsCollector(RequestMetricCollector)} and
 *                 {@link AmazonS3EncryptionClientBuilder#withKmsClient(AWSKMS)}
 */
@Deprecated
public AmazonS3EncryptionClient(AWSKMSClient kms,
        AWSCredentialsProvider credentialsProvider,
        EncryptionMaterialsProvider kekMaterialsProvider,
        ClientConfiguration clientConfig,
        CryptoConfiguration cryptoConfig,
        RequestMetricCollector requestMetricCollector) {
    super(credentialsProvider, clientConfig, requestMetricCollector);
    assertParameterNotNull(kekMaterialsProvider,
            "EncryptionMaterialsProvider parameter must not be null.");
    assertParameterNotNull(cryptoConfig,
            "CryptoConfiguration parameter must not be null.");
    this.isKMSClientInternal = kms == null;
    this.kms = isKMSClientInternal 
        ? newAWSKMSClient(credentialsProvider, clientConfig, cryptoConfig, 
                requestMetricCollector)
        : kms;
    this.crypto = new CryptoModuleDispatcher(this.kms, new S3DirectImpl(),
            credentialsProvider, kekMaterialsProvider, cryptoConfig);
}
 

import com.amazonaws.services.s3.model.EncryptionMaterialsProvider; //导入依赖的package包/类
private static EncryptionMaterialsProvider createEncryptionMaterialsProvider(Configuration hadoopConfig)
{
    String empClassName = hadoopConfig.get(S3_ENCRYPTION_MATERIALS_PROVIDER);
    if (empClassName == null) {
        return null;
    }

    try {
        Object instance = Class.forName(empClassName).getConstructor().newInstance();
        if (!(instance instanceof EncryptionMaterialsProvider)) {
            throw new RuntimeException("Invalid encryption materials provider class: " + instance.getClass().getName());
        }
        EncryptionMaterialsProvider emp = (EncryptionMaterialsProvider) instance;
        if (emp instanceof Configurable) {
            ((Configurable) emp).setConf(hadoopConfig);
        }
        return emp;
    }
    catch (ReflectiveOperationException e) {
        throw new RuntimeException("Unable to load or create S3 encryption materials provider: " + empClassName, e);
    }
}
 

import com.amazonaws.services.s3.model.EncryptionMaterialsProvider; //导入依赖的package包/类
@Nullable
@Singleton
@Provides
private EncryptionMaterialsProvider provideEncryptionMaterialsProvider()
{
    String empClassName = config.getS3EncryptionMaterialsProvider();
    if (empClassName != null) {
        try {
            Class<?> empClass = Class.forName(empClassName);
            Object instance = empClass.newInstance();
            if (instance instanceof EncryptionMaterialsProvider) {
                return (EncryptionMaterialsProvider) instance;
            }
            else {
                throw new IllegalArgumentException("Class " + empClassName + " must implement EncryptionMaterialsProvider");
            }
        }
        catch (Exception x) {
            throw new RuntimeException("Unable to initialize EncryptionMaterialsProvider class " + empClassName + ": " + x, x);
        }
    }

    return null;
}
 

import com.amazonaws.services.s3.model.EncryptionMaterialsProvider; //导入依赖的package包/类
AmazonS3EncryptionClientParamsWrapper(AwsSyncClientParams getClientParams,
                                      S3ClientOptions getS3ClientOptions,
                                      EncryptionMaterialsProvider encryptionMaterials,
                                      CryptoConfiguration cryptoConfiguration,
                                      AWSKMS kms) {
    this.encryptionMaterials = encryptionMaterials;
    this.cryptoConfiguration = cryptoConfiguration;
    this.kms = kms;
    this.getClientParams = getClientParams;
    this.getS3ClientOptions = getS3ClientOptions;
}
 

import com.amazonaws.services.s3.model.EncryptionMaterialsProvider; //导入依赖的package包/类
/**
 * @param cryptoConfig a read-only copy of the crypto configuration.
 */
S3CryptoModuleAEStrict(AWSKMS kms, S3Direct s3,
                       AWSCredentialsProvider credentialsProvider,
                       EncryptionMaterialsProvider encryptionMaterialsProvider,
                       CryptoConfiguration cryptoConfig) {
    super(kms, s3, credentialsProvider, encryptionMaterialsProvider,
            cryptoConfig);
    if (cryptoConfig.getCryptoMode() != StrictAuthenticatedEncryption)
        throw new IllegalArgumentException();
}
 

import com.amazonaws.services.s3.model.EncryptionMaterialsProvider; //导入依赖的package包/类
/**
 * @param cryptoConfig a read-only copy of the crypto configuration.
 */
protected S3CryptoModuleBase(AWSKMS kms, S3Direct s3,
        AWSCredentialsProvider credentialsProvider,
        EncryptionMaterialsProvider kekMaterialsProvider,
        CryptoConfiguration cryptoConfig) {
    if (!cryptoConfig.isReadOnly())
        throw new IllegalArgumentException("The cryto configuration parameter is required to be read-only");
    this.kekMaterialsProvider = kekMaterialsProvider;
    this.s3 = s3;
    this.cryptoConfig = cryptoConfig;
    this.cryptoScheme = S3CryptoScheme.from(cryptoConfig.getCryptoMode());
    this.contentCryptoScheme = cryptoScheme.getContentCryptoScheme();
    this.kms = kms;
}
 

import com.amazonaws.services.s3.model.EncryptionMaterialsProvider; //导入依赖的package包/类
/**
 * Returns the content encryption material generated with the given kek
 * material, material description and security providers; or null if
 * the encryption material cannot be found for the specified description.
 */
private ContentCryptoMaterial newContentCryptoMaterial(
        EncryptionMaterialsProvider kekMaterialProvider,
        Map<String, String> materialsDescription, Provider provider,
        AmazonWebServiceRequest req) {
    EncryptionMaterials kekMaterials =
        kekMaterialProvider.getEncryptionMaterials(materialsDescription);
    if (kekMaterials == null) {
        return null;
    }
    return buildContentCryptoMaterial(kekMaterials, provider, req);
}
 

import com.amazonaws.services.s3.model.EncryptionMaterialsProvider; //导入依赖的package包/类
/**
 * @param cryptoConfig a read-only copy of the crypto configuration
 */
S3CryptoModuleEO(AWSKMS kms, S3Direct s3,
                 AWSCredentialsProvider credentialsProvider,
                 EncryptionMaterialsProvider encryptionMaterialsProvider,
                 CryptoConfiguration cryptoConfig) {
    super(kms, s3, credentialsProvider, encryptionMaterialsProvider,
            cryptoConfig);
    if (cryptoConfig.getCryptoMode() != EncryptionOnly)
        throw new IllegalArgumentException();
}
 

import com.amazonaws.services.s3.model.EncryptionMaterialsProvider; //导入依赖的package包/类
/**
 * @param cryptoConfig a read-only copy of the crypto configuration.
 */
S3CryptoModuleAE(AWSKMS kms, S3Direct s3,
                 AWSCredentialsProvider credentialsProvider,
                 EncryptionMaterialsProvider encryptionMaterialsProvider,
                 CryptoConfiguration cryptoConfig) {
    super(kms, s3, credentialsProvider, encryptionMaterialsProvider,
            cryptoConfig);
    CryptoMode mode = cryptoConfig.getCryptoMode();
    if (mode != StrictAuthenticatedEncryption
    &&  mode != AuthenticatedEncryption) {
        throw new IllegalArgumentException();
    }
}
 

import com.amazonaws.services.s3.model.EncryptionMaterialsProvider; //导入依赖的package包/类
@Override
EncryptionMaterialsProvider getEncryptionMaterials() {
    return encryptionMaterials;
}
 

import com.amazonaws.services.s3.model.EncryptionMaterialsProvider; //导入依赖的package包/类
public CryptoModuleDispatcher(AWSKMS kms, S3Direct s3,
                              AWSCredentialsProvider credentialsProvider,
                              EncryptionMaterialsProvider encryptionMaterialsProvider,
                              CryptoConfiguration cryptoConfig) {
    cryptoConfig = cryptoConfig.clone();    // make a clone
    CryptoMode cryptoMode = cryptoConfig.getCryptoMode();
    if (cryptoMode == null) {
        cryptoMode = EncryptionOnly;
        cryptoConfig.setCryptoMode(cryptoMode); // defaults to EO
    }
    cryptoConfig = cryptoConfig.readOnly(); // make read-only
    this.defaultCryptoMode = cryptoConfig.getCryptoMode();
    switch(this.defaultCryptoMode) {
        case StrictAuthenticatedEncryption:
            this.ae = new S3CryptoModuleAEStrict(kms, s3, credentialsProvider,
                    encryptionMaterialsProvider,
                    cryptoConfig);
            this.eo = null;
            break;
        case AuthenticatedEncryption:
            this.ae = new S3CryptoModuleAE(kms, s3, credentialsProvider,
                    encryptionMaterialsProvider,
                    cryptoConfig);
            this.eo = null;
            break;
        case EncryptionOnly:
            this.eo = new S3CryptoModuleEO(kms, s3, credentialsProvider,
                    encryptionMaterialsProvider,
                    cryptoConfig);
            CryptoConfiguration aeConfig = cryptoConfig.clone();
            try {
                aeConfig.setCryptoMode(AuthenticatedEncryption);
            } catch(UnsupportedOperationException ex) {
                // BC not available during runtime; but EO can still work.
                // Hence ignoring.
            }
            this.ae = new S3CryptoModuleAE(kms, s3, credentialsProvider,
                encryptionMaterialsProvider,
                aeConfig.readOnly());
            break;
        default:
            throw new IllegalStateException();
    }
}
 

import com.amazonaws.services.s3.model.EncryptionMaterialsProvider; //导入依赖的package包/类
/**
 * Sets the encryption materials to be used to encrypt and decrypt data
 * @param encryptionMaterials a provider for the encryption materials
 */
public void setEncryptionMaterials(EncryptionMaterialsProvider encryptionMaterials) {
    this.encryptionMaterials = encryptionMaterials;
}
 

import com.amazonaws.services.s3.model.EncryptionMaterialsProvider; //导入依赖的package包/类
/**
 * Sets the encryption materials to be used to encrypt and decrypt data
 * @param encryptionMaterials A provider for the encryption materials to be used to encrypt and decrypt data.
 * @return this object for method chaining
 */
public AmazonS3EncryptionClientBuilder withEncryptionMaterials(EncryptionMaterialsProvider encryptionMaterials) {
    setEncryptionMaterials(encryptionMaterials);
    return this;
}
 

import com.amazonaws.services.s3.model.EncryptionMaterialsProvider; //导入依赖的package包/类
abstract EncryptionMaterialsProvider getEncryptionMaterials();