Construindo uma assinatura HMAC
Em vez de autorização baseada em token, é possível usar credenciais HMAC.
Essas credenciais são usadas para criar um cabeçalho de autorização análogo ao AWS Signature Versão 4 O cálculo de assinaturas fornece verificação de identidade e integridade de dados em trânsito. Cada assinatura é vinculada ao registro de data e hora da solicitação, portanto, não é possível reutilizar cabeçalhos de autorização. O cabeçalho é composto por quatro componentes: uma declaração de algoritmo, informações da credencial, cabeçalhos assinados e a assinatura calculada.
AWS4-HMAC-SHA256 Credential={access-key}/{date}/{region}/s3/aws4_request,SignedHeaders=host;x-amz-date;{other-required-headers},Signature={signature}
A data é fornecida no formato YYYYMMDD
e a região corresponde ao local do depósito especificado, por exemplo, us
. Os cabeçalhos host
e x-amz-date
são sempre necessários. Dependendo da solicitação,
outros cabeçalhos também podem ser necessários (por exemplo, x-amz-content-sha256
, em solicitações com cargas úteis). É necessário recalcular a assinatura para cada solicitação individual, portanto, muitos desenvolvedores preferem
usar uma ferramenta ou um SDK que produza o cabeçalho de autorização automaticamente.
Criando um cabeçalho authorization
Primeiro, precisamos criar uma solicitação em um formato padronizado.
- Declare qual método de HTTP estamos usando (por exemplo,
PUT
) - Defina o recurso que estamos acessando em um modo padronizado. Essa é a parte do endereço entre o
http(s)://
e a sequência de consultas Para solicitações no nível de conta (como listar depósitos), isso é simplesmente/
. - Se houver parâmetros de solicitação, eles deverão ser padronizados por codificação de percentual (por exemplo, os espaços devem ser representados como
%20
) e ordenados alfabeticamente. - Os cabeçalhos precisam ser padronizados removendo o espaço em branco, convertendo em minúsculas e incluindo uma nova linha em cada um; em seguida, devem ser classificados em ordem ASCII.
- Depois de serem listados em um formato padrão, eles devem ser 'assinados'. Isso é pegar apenas os nomes de cabeçalho, não seus valores, e listá-los em ordem alfabética, que é separada por ponto e vírgula.
Host
ex-amz-date
são necessários para todas as solicitações. - Se a solicitação tiver um corpo, como ao fazer upload de um objeto ou criar uma nova ACL, o corpo da solicitação deverá ser submetido a hash usando o algoritmo SHA-256 e ser representado como caracteres minúsculos codificados em base 16.
- Combinar o método de HTTP, o recurso padronizado, os parâmetros padronizados, os cabeçalhos padronizados, os cabeçalhos assinados e o corpo da solicitação em hash, cada um separado por uma nova linha para formar uma solicitação padronizada.
Em seguida, precisamos montar um 'string-to-sign' que é combinado com a chave de assinatura para formar a assinatura final. O string-to-sign usa o formato a seguir:
AWS4-HMAC-SHA256
{time}
{date}/{string}/s3/aws4_request
{hashed-standardized-request}
- O horário deve ser a Hora Universal Coordenada atual e formatada de acordo com a especificação ISO 8601 (por exemplo,
20161128T152924Z
). - A data está no formato
YYYYMMDD
. - A linha final é a solicitação padronizada criada anteriormente e submetida a hash, que usa o algoritmo SHA-256.
Agora precisamos calcular a assinatura.
- Primeiro, a chave de assinatura precisa ser calculada por meio da chave de acesso secreta da conta, da data atual, da região e do tipo de API que estão sendo usados.
- A sequência
AWS4
é incluída como um prefixo na chave de acesso secreta e, em seguida, essa nova sequência é usada como a chave para efetuar hash da data. - O hash resultante é usado como a chave para efetuar hash da região.
- O processo continua com o novo hash sendo usado como a chave para efetuar hash do tipo de API.
- Finalmente, o hash mais recente é usado como a chave para efetuar hash da sequência
aws4_request
criando a chave de assinatura. - A chave de assinatura é, então, usada como a chave para efetuar hash do string-to-sign que gera a assinatura final.
Agora a única etapa que falta está montando o cabeçalho authorization
conforme mostrado:
AWS4-HMAC-SHA256 Credential={access-key}/{date}/{region}/s3/aws4_request,SignedHeaders=host;x-amz-date;{other-required-headers},Signature={signature}
Gerando um cabeçalho authorization
Exemplo de Python
import os
import datetime
import hashlib
import hmac
import requests
# please don't store credentials directly in code
access_key = os.environ.get('COS_HMAC_ACCESS_KEY_ID')
secret_key = os.environ.get('COS_HMAC_SECRET_ACCESS_KEY')
# request elements
http_method = 'GET'
host = 's3.us.cloud-object-storage.appdomain.cloud'
region = 'us-standard'
endpoint = 'https://s3.us.cloud-object-storage.appdomain.cloud'
bucket = '' # add a '/' before the bucket name to list buckets
object_key = ''
request_parameters = ''
# hashing and signing methods
def hash(key, msg):
return hmac.new(key, msg.encode('utf-8'), hashlib.sha256).digest()
# region is a wildcard value that takes the place of the AWS region value
# as COS doen't use the same conventions for regions, this parameter can accept any string
def createSignatureKey(key, datestamp, region, service):
keyDate = hash(('AWS4' + key).encode('utf-8'), datestamp)
keyString = hash(keyDate, region)
keyService = hash(keyString, service)
keySigning = hash(keyService, 'aws4_request')
return keySigning
# assemble the standardized request
time = datetime.datetime.utcnow()
timestamp = time.strftime('%Y%m%dT%H%M%SZ')
datestamp = time.strftime('%Y%m%d')
standardized_resource = '/' + bucket + '/' + object_key
standardized_querystring = request_parameters
standardized_headers = 'host:' + host + '\n' + 'x-amz-date:' + timestamp + '\n'
signed_headers = 'host;x-amz-date'
payload_hash = hashlib.sha256(''.encode('utf-8')).hexdigest()
standardized_request = (http_method + '\n' +
standardized_resource + '\n' +
standardized_querystring + '\n' +
standardized_headers + '\n' +
signed_headers + '\n' +
payload_hash).encode('utf-8')
# assemble string-to-sign
hashing_algorithm = 'AWS4-HMAC-SHA256'
credential_scope = datestamp + '/' + region + '/' + 's3' + '/' + 'aws4_request'
sts = (hashing_algorithm + '\n' +
timestamp + '\n' +
credential_scope + '\n' +
hashlib.sha256(standardized_request).hexdigest())
# generate the signature
signature_key = createSignatureKey(secret_key, datestamp, region, 's3')
signature = hmac.new(signature_key,
(sts).encode('utf-8'),
hashlib.sha256).hexdigest()
# assemble all elements into the 'authorization' header
v4auth_header = (hashing_algorithm + ' ' +
'Credential=' + access_key + '/' + credential_scope + ', ' +
'SignedHeaders=' + signed_headers + ', ' +
'Signature=' + signature)
# create and send the request
headers = {'x-amz-date': timestamp, 'Authorization': v4auth_header}
# the 'requests' package autmatically adds the required 'host' header
request_url = endpoint + standardized_resource + standardized_querystring
print('\nSending `%s` request to IBM COS -----------------------' % http_method)
print('Request URL = ' + request_url)
request = requests.get(request_url, headers=headers)
print('\nResponse from IBM COS ----------------------------------')
print('Response code: %d\n' % request.status_code)
print(request.text)
Exemplo de Java
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.time.format.DateTimeFormatter;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.util.Formatter;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
public class CosHMAC {
// please don't store credentials directly in code
private static final String accessKey = System.getenv("COS_HMAC_ACCESS_KEY_ID");
private static final String secretKey = System.getenv("COS_HMAC_SECRET_ACCESS_KEY");
// constants
private static final String httpMethod = "GET";
private static final String host = "s3.us.cloud-object-storage.appdomain.cloud";
private static final String region = "us-standard";
private static final String endpoint = "https://s3.us.cloud-object-storage.appdomain.cloud";
private static final String bucket = ""; // add a '/' before the bucket name to list buckets
private static final String objectKey = "";
private static final String requestParameters = "";
public static void main(String[] args) {
try {
// assemble the standardized request
ZonedDateTime time = ZonedDateTime.now(ZoneOffset.UTC);
String datestamp = time.format(DateTimeFormatter.ofPattern("yyyyMMdd"));
String timestamp = datestamp + "T" + time.format(DateTimeFormatter.ofPattern("HHmmss")) + "Z";
String standardizedResource = bucket + "/" + objectKey;
String standardizedQuerystring = requestParameters;
String standardizedHeaders = "host:" + host + "\n" + "x-amz-date:" + timestamp + "\n";
String signedHeaders = "host;x-amz-date";
String payloadHash = hashHex("");
String standardizedRequest = httpMethod + "\n" +
standardizedResource + "\n" +
standardizedQuerystring + "\n" +
standardizedHeaders + "\n" +
signedHeaders + "\n" +
payloadHash;
// assemble string-to-sign
String hashingAlgorithm = "AWS4-HMAC-SHA256";
String credentialScope = datestamp + "/" + region + "/" + "s3" + "/" + "aws4_request";
String sts = hashingAlgorithm + "\n" +
timestamp + "\n" +
credentialScope + "\n" +
hashHex(standardizedRequest);
// generate the signature
byte[] signatureKey = createSignatureKey(secretKey, datestamp, region, "s3");
String signature = hmacHex(signatureKey, sts);
// assemble all elements into the "authorization" header
String v4auth_header = hashingAlgorithm + " " +
"Credential=" + accessKey + "/" + credentialScope + ", " +
"SignedHeaders=" + signedHeaders + ", " +
"Signature=" + signature;
// create and send the request
String requestUrl = endpoint + standardizedResource + standardizedQuerystring;
URL urlObj = new URL(requestUrl);
HttpURLConnection con = (HttpURLConnection) urlObj.openConnection();
con.setRequestMethod(httpMethod);
//add request headers
con.setRequestProperty("x-amz-date", timestamp);
con.setRequestProperty("Authorization", v4auth_header);
System.out.printf("\nSending %s request to IBM COS -----------------------", httpMethod);
System.out.println("Request URL = " + requestUrl);
int responseCode = con.getResponseCode();
System.out.println("\nResponse from IBM COS ----------------------------------");
System.out.printf("Response code: %d\n\n", responseCode);
BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
//print result
System.out.println(response.toString());
con.disconnect();
}
catch (Exception ex) {
System.out.printf("Error: %s\n", ex.getMessage());
}
}
private static String toHexString(byte[] bytes) {
Formatter formatter = new Formatter();
for (byte b : bytes) {
formatter.format("%02x", b);
}
return formatter.toString();
}
private static byte[] hash(byte[] key, String msg) {
byte[] returnVal = null;
try {
SecretKeySpec signingKey = new SecretKeySpec(key, "HmacSHA256");
Mac mac = Mac.getInstance("HmacSHA256");
mac.init(signingKey);
returnVal = mac.doFinal(msg.getBytes("UTF8"));
}
catch (Exception ex) {
throw ex;
}
finally {
return returnVal;
}
}
private static String hmacHex(byte[] key, String msg) {
String returnVal = null;
try {
returnVal = toHexString(hash(key, msg));
}
catch (Exception ex) {
throw ex;
}
finally {
return returnVal;
}
}
private static String hashHex(String msg) {
String returnVal = null;
try {
MessageDigest digest = MessageDigest.getInstance("SHA-256");
byte[] encodedhash = digest.digest(msg.getBytes(StandardCharsets.UTF_8));
returnVal = toHexString(encodedhash);
}
catch (Exception ex) {
throw ex;
}
finally {
return returnVal;
}
}
// region is a wildcard value that takes the place of the AWS region value
// as COS doesn"t use the same conventions for regions, this parameter can accept any string
private static byte[] createSignatureKey(String key, String datestamp, String region, String service) {
byte[] returnVal = null;
try {
byte[] keyDate = hash(("AWS4" + key).getBytes("UTF8"), datestamp);
byte[] keyString = hash(keyDate, region);
byte[] keyService = hash(keyString, service);
byte[] keySigning = hash(keyService, "aws4_request");
returnVal = keySigning;
}
catch (Exception ex) {
throw ex;
}
finally {
return returnVal;
}
}
}
Exemplo de NodeJS
const crypto = require('crypto');
const moment = require('moment');
const https = require('https');
// please don't store credentials directly in code
const accessKey = process.env.COS_HMAC_ACCESS_KEY_ID;
const secretKey = process.env.COS_HMAC_SECRET_ACCESS_KEY;
const httpMethod = 'GET';
const host = 's3.us.cloud-object-storage.appdomain.cloud';
const region = 'us-standard';
const endpoint = 'https://s3.us.cloud-object-storage.appdomain.cloud';
const bucket = ''; // add a '/' before the bucket name to list buckets
const objectKey = '';
const requestParameters = '';
// hashing and signing methods
function hash(key, msg) {
var hmac = crypto.createHmac('sha256', key);
hmac.update(msg, 'utf8');
return hmac.digest();
}
function hmacHex(key, msg) {
var hmac = crypto.createHmac('sha256', key);
hmac.update(msg, 'utf8');
return hmac.digest('hex');
}
function hashHex(msg) {
var hash = crypto.createHash('sha256');
hash.update(msg);
return hash.digest('hex');
}
// region is a wildcard value that takes the place of the AWS region value
// as COS doesn't use the same conventions for regions, this parameter can accept any string
function createSignatureKey(key, datestamp, region, service) {
keyDate = hash(('AWS4' + key), datestamp);
keyString = hash(keyDate, region);
keyService = hash(keyString, service);
keySigning = hash(keyService, 'aws4_request');
return keySigning;
}
// assemble the standardized request
var time = moment().utc();
var timestamp = time.format('YYYYMMDDTHHmmss') + 'Z';
var datestamp = time.format('YYYYMMDD');
var standardizedResource = bucket + '/' + objectKey;
var standardizedQuerystring = requestParameters;
var standardizedHeaders = 'host:' + host + '\n' + 'x-amz-date:' + timestamp + '\n';
var signedHeaders = 'host;x-amz-date';
var payloadHash = hashHex('');
var standardizedRequest = httpMethod + '\n' +
standardizedResource + '\n' +
standardizedQuerystring + '\n' +
standardizedHeaders + '\n' +
signedHeaders + '\n' +
payloadHash;
// assemble string-to-sign
var hashingAlgorithm = 'AWS4-HMAC-SHA256';
var credentialScope = datestamp + '/' + region + '/' + 's3' + '/' + 'aws4_request';
var sts = hashingAlgorithm + '\n' +
timestamp + '\n' +
credentialScope + '\n' +
hashHex(standardizedRequest);
// generate the signature
var signatureKey = createSignatureKey(secretKey, datestamp, region, 's3');
var signature = hmacHex(signatureKey, sts);
// assemble all elements into the 'authorization' header
var v4authHeader = hashingAlgorithm + ' ' +
'Credential=' + accessKey + '/' + credentialScope + ', ' +
'SignedHeaders=' + signedHeaders + ', ' +
'Signature=' + signature;
// create and send the request
var authHeaders = {'x-amz-date': timestamp, 'Authorization': v4authHeader}
// the 'requests' package autmatically adds the required 'host' header
console.log(authHeaders);
var requestUrl = endpoint + standardizedResource + standardizedQuerystring
console.log(`\nSending ${httpMethod} request to IBM COS -----------------------`);
console.log('Request URL = ' + requestUrl);
var options = {
host: host,
port: 443,
path: standardizedResource + standardizedQuerystring,
method: httpMethod,
headers: authHeaders
}
var request = https.request(options, function (response) {
console.log('\nResponse from IBM COS ----------------------------------');
console.log(`Response code: ${response.statusCode}\n`);
response.on('data', function (chunk) {
console.log(chunk.toString());
});
});
request.end();
Próximas etapas
É possível revisar a documentação para credenciais como parte de uma Credencial de serviço. Para obter uma visão geral sobre a autenticação, efetue check-out do serviço IBM Cloud Identity and Access Management.