Todos os produtos
Search
Central de documentação

Object Storage Service:Authorize access (Android SDK)

Última atualização: Jul 03, 2026

O kit de desenvolvimento de software (SDK) para Android oferece o modo de autenticação STS, o modo autoassinado e URLs pré-assinadas para garantir a segurança em dispositivos móveis.

Informações básicas

Nos modos de autenticação STS e autoassinado, a função de callback implementada deve retornar o token e a assinatura quando chamada. Para enviar uma solicitação de rede ao servidor de aplicativos e obter esses dados, chame a API síncrona da biblioteca de rede. O callback é executado em uma subthread quando o SDK inicia uma requisição, evitando o bloqueio da thread principal.

Modo de autenticação STS

Nota

Para usar o modo STS na autorização, ative primeiro o Resource Access Management (RAM) do Alibaba Cloud.

Use o Security Token Service (STS) do Alibaba Cloud para acessar o OSS com autorização temporária. O STS é um serviço web que fornece tokens de acesso temporários para usuários de computação em nuvem. Com ele, você pode emitir uma credencial de acesso com tempo de vida (TTL) e permissões personalizadas para uma aplicação de terceiros ou para um usuário federado cuja identidade você gerencia. Para mais informações, consulte O que é o STS?.

O STS oferece os seguintes benefícios:

  • Evita a exposição do seu par de AccessKey de longo prazo a aplicações de terceiros. Em vez disso, gere um token de acesso com permissões específicas e um período de validade definido para fornecer à aplicação.

  • Elimina a necessidade de gerenciar a revogação de permissões, pois o token de acesso torna-se inválido automaticamente ao expirar.

Para conceder acesso temporário ao OSS usando o STS, siga estas etapas:

  1. Obtenha credenciais de acesso temporárias.

    As credenciais de acesso temporárias incluem um par de AccessKey temporário, composto por um AccessKey ID e um AccessKey secret, além de um token de segurança. A validade dessas credenciais é medida em segundos, com valor mínimo de 900. O valor máximo corresponde à duração máxima da sessão configurada para a função RAM atual. Para mais detalhes, consulte Defina a duração máxima da sessão para uma função RAM.

    Há duas formas de obter credenciais de acesso temporárias:

  2. Inicialize o SDK com as credenciais de acesso temporárias.

    String endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
    
    OSSCredentialProvider credentialProvider = new OSSStsTokenCredentialProvider("StsToken.AccessKeyId", "StsToken.SecretKeyId", "StsToken.SecurityToken");
    
    OSS oss = new OSSClient(getApplicationContext(), endpoint, credentialProvider);                  

    Ao inicializar o SDK com credenciais de acesso temporárias, observe o período de validade do StsToken.

    O código abaixo demonstra como atualizar o StsToken quando seu tempo de validade restante for inferior a 5 minutos:

    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
    sdf.setTimeZone(TimeZone.getTimeZone("UTC"));
    Date date = sdf.parse("<StsToken.Expiration>");
    long expiration = date.getTime() / 1000;
    // If the StsToken is about to expire in less than 5 minutes, update the StsToken.
    if (DateUtil.getFixedSkewedTimeMillis() / 1000 > expiration - 5 * 60) {
        oss.updateCredentialProvider(new OSSStsTokenCredentialProvider("StsToken.AccessKeyId", "StsToken.SecretKeyId", "StsToken.SecurityToken"));
    }
    • Atualização manual do StsToken

      Quando o StsToken estiver prestes a expirar, reconstrua o OSSClient ou atualize o CredentialProvider conforme o exemplo:

      oss.updateCredentialProvider(new OSSStsTokenCredentialProvider("StsToken.AccessKeyId", "StsToken.SecretKeyId", "StsToken.SecurityToken"));                   
    • Atualização automática do StsToken

      Para permitir que o SDK atualize o StsToken automaticamente, implemente um callback na sua aplicação. O SDK chama esse callback para obter um Federation Token (StsToken), usa o token para assinatura e chama novamente o callback para obter um novo StsToken quando o atual estiver próximo da expiração.

      String endpoint = "http://oss-cn-hangzhou.aliyuncs.com";
      
      OSSCredentialProvider credentialProvider = new OSSFederationCredentialProvider() {
      
          @Override
          public OSSFederationToken getFederationToken() {
          // Obtain the FederationToken and construct it as an OSSFederationToken object to return. If the FederationToken fails to be obtained for any reason, the server directly returns null.
      
              OSSFederationToken token;
              // Obtain the token from your server.
              return token;
          }
      };
      
      OSS oss = new OSSClient(getApplicationContext(), endpoint, credentialProvider);                    
      Nota

      Caso já tenha obtido os campos necessários para o StsToken por outros meios, retorne o StsToken diretamente no callback. No entanto, gerencie manualmente a atualização do StsToken e redefina o OSSCredentialProvider para a instância do OSSClient após a atualização.

      Por exemplo, ao acessar o servidor em http://localhost:8080/distribute-token.json, os seguintes dados são retornados:

      {
          "StatusCode": 200,
          "AccessKeyId":"STS.iA645eTOXEqP3cg3****",
          "AccessKeySecret":"rV3VQrpFQ4BsyHSAvi5NVLpPIVffDJv4LojU****",
          "Expiration":"2015-11-03T09:52:59Z",
          "SecurityToken":"CAES7QIIARKAAZPlqaN9ILiQZPS+JDkS/GSZN45RLx4YS/p3OgaUC+oJl3XSlbJ7StKpQ****"}                    

      O exemplo a seguir mostra como implementar o OSSFederationCredentialProvider:

      OSSCredentialProvider credetialProvider = new OSSFederationCredentialProvider() {
          @Override
          public OSSFederationToken getFederationToken() {
              try {
                  URL stsUrl = new URL("http://localhost:8080/distribute-token.json");
                  HttpURLConnection conn = (HttpURLConnection) stsUrl.openConnection();
                  InputStream input = conn.getInputStream();
                  String jsonText = IOUtils.readStreamAsString(input, OSSConstants.DEFAULT_CHARSET_NAME);
                  JSONObject jsonObjs = new JSONObject(jsonText);
                  String ak = jsonObjs.getString("AccessKeyId");
                  String sk = jsonObjs.getString("AccessKeySecret");
                  String token = jsonObjs.getString("SecurityToken");
                  String expiration = jsonObjs.getString("Expiration");
                  return new OSSFederationToken(ak, sk, token, expiration);
              } catch (Exception e) {
                  e.printStackTrace();
              }
              return null;
          }
      };                    

Modo autoassinado

image

Armazene seu AccessKey ID e AccessKey secret no servidor de aplicativos e use o servidor para assinar as informações do cliente. O processo ocorre da seguinte forma:

  1. No cliente, obtenha a string a ser assinada e envie-a ao seu servidor.

    1. Ao construir uma requisição, use o método signContent do OSSCustomSignerCredentialProvider no SDK para obter a string a ser assinada.

    2. Envie a string a ser assinada para o seu servidor.

  2. No servidor, assine a string e retorne a assinatura ao cliente.

    1. Assine a string usando o algoritmo de assinatura especificado pelo OSS. Para mais detalhes sobre o algoritmo, consulte Assinatura V1.

      O formato da assinatura é signature = "OSS " + AccessKeyId + ":" + base64(hmac-sha1(AccessKeySecret, content)), onde content é a string criada pela concatenação dos parâmetros da requisição.

    2. Retorne a assinatura ao cliente.

      Por exemplo, suponha que o endereço do servidor seja http://localhost:8080/sign. Passe o conteúdo ao servidor para assinatura e o servidor retornará a assinatura ao cliente. O código abaixo ilustra esse processo:

      String endpoint = "http://oss-cn-hangzhou.aliyuncs.com";
      
      OSSCredentialProvider credentialProvider = new OSSCustomSignerCredentialProvider() {
          @Override
          public String signContent(String content) {
              URL stsUrl = new URL("http://localhost:8080/sign?content=" + content);
              HttpURLConnection conn = (HttpURLConnection) stsUrl.openConnection();
              InputStream input = conn.getInputStream();
              String jsonText = IOUtils.readStreamAsString(input, OSSConstants.DEFAULT_CHARSET_NAME);
              JSONObject jsonObjs = new JSONObject(jsonText);
              String signature = jsonObjs.getString("signature");
              return signature;
          }
      };
      OSS oss = new OSSClient(getApplicationContext(), endpoint, credentialProvider);
  3. No cliente, envie a assinatura ao servidor OSS para autenticação.

URL pré-assinada

Observações

  • Ao usar um SDK do OSS para gerar uma URL pré-assinada, o SDK usa um algoritmo específico baseado nas informações-chave armazenadas localmente para calcular uma assinatura e adicioná-la à URL, garantindo sua validade e segurança. As operações de cálculo e construção da URL ocorrem inteiramente no cliente, sem necessidade de enviar requisições pela rede ao servidor. Dessa forma, não é preciso conceder permissões específicas ao chamador durante a geração da URL pré-assinada. Contudo, para permitir que usuários de terceiros realizem operações nos recursos autorizados pela URL, assegure-se de que a entidade principal que chama as operações de API para gerar a URL possua as permissões correspondentes.

    Por exemplo, se uma entidade deseja fazer upload de um objeto usando uma URL pré-assinada, conceda a permissão oss:PutObject a ela. Caso a intenção seja baixar ou visualizar um objeto, conceda a permissão oss:GetObject.

  • A URL pré-assinada gerada pelo código de exemplo abaixo pode conter um sinal de mais (+). Nessa situação, substitua o sinal de mais (+) na URL por %2B. Caso contrário, a URL pré-assinada poderá não funcionar corretamente para acessar o objeto.

Os exemplos a seguir demonstram como usar URLs pré-assinadas para autorização temporária.

Gere uma URL pré-assinada e use-a para fazer upload de um arquivo

  1. Gere uma URL pré-assinada para upload.

    // Specify the bucket name, for example, examplebucket.
    String bucketName = "examplebucket";
    // Specify the full path of the source object, without the bucket name, for example, exampleobject.txt.
    String objectKey = "exampleobject.txt";
    // Set the content-type.
    String contentType = "application/octet-stream";
    String url = null;
    try {
        // Generate a presigned URL for uploading the file.
        GeneratePresignedUrlRequest request = new GeneratePresignedUrlRequest(bucketName, objectKey);
        // Set the expiration time of the presigned URL to 30 minutes.
        request.setExpiration(30*60);
        request.setContentType(contentType);    
        request.setMethod(HttpMethod.PUT);
        url = oss.presignConstrainedObjectURL(request);
        Log.d("url", url);
    } catch (ClientException e) {
        e.printStackTrace();
    }
  2. Faça o upload de um arquivo usando a URL pré-assinada.

    // Specify the generated presigned URL.
    String url = "";
    // Specify the full path of the local file.
    String localFile = "/storage/emulated/0/oss/examplefile";
    // Set the content-type.
    String contentType = "application/octet-stream";
    // Upload the file using the presigned URL.
    OkHttpClient client = new OkHttpClient();
    Request putRequest = new Request.Builder()
            .url(url)
            .put(RequestBody.create(MediaType.parse(contentType), new File(localFile)))
            .build();
    client.newCall(putRequest).enqueue(new Callback() {
        @Override
        public void onFailure(Call call, IOException e) {
            e.printStackTrace();
        }
    
        @Override
        public void onResponse(Call call, Response response) throws IOException {
            Log.d("response", response.body().string());
        }
    });

Gere uma URL pré-assinada e use-a para baixar um arquivo

  1. Gere uma URL pré-assinada para download.

    // Specify the bucket name, for example, examplebucket.
    String bucketName = "examplebucket";
    // Specify the full path of the source object, without the bucket name, for example, exampleobject.txt.
    String objectKey = "exampleobject.txt";
    String url = null;
    try {
        // Generate a presigned URL for downloading the file.
        GeneratePresignedUrlRequest request = new GeneratePresignedUrlRequest(bucketName, objectKey);
        // Set the expiration time of the presigned URL to 30 minutes.
        request.setExpiration(30*60);
        request.setMethod(HttpMethod.GET);
        url = oss.presignConstrainedObjectURL(request);
        Log.d("url", url);
    } catch (ClientException e) {
        e.printStackTrace();
    }
  2. Baixe um arquivo usando a URL pré-assinada.

    // Specify the generated presigned URL.
    String url = "";
    OkHttpClient client = new OkHttpClient();
    // Download the file using the presigned URL.
    Request getRequest = new Request.Builder()
            .url(url)
            .get()
            .build();
    client.newCall(getRequest).enqueue(new Callback() {
        @Override
        public void onFailure(Call call, IOException e) {
            e.printStackTrace();
        }
    
        @Override
        public void onResponse(Call call, Response response) throws IOException {
            if (response.code() == 203 || response.code() >= 300) {
                Log.d("download", "fail");
                Log.d("download", response.body().string());
                return;
            }
            // The request was successful.
            InputStream inputStream = response.body().byteStream();
    
            byte[] buffer = new byte[2048];
            int len;
    
            while ((len = inputStream.read(buffer)) != -1) {
                // Process the downloaded data, such as displaying an image or writing to a file.
            }
        }
    });