Problemas de autorização do OAuth 1.0 com X API v2 em Scala via STTP

Resolvendo autorização OAuth 1.0 com Scala e STTP para a API do Twitter

Este script mostra como assinar solicitações OAuth 1.0 em Scala usando HMAC-SHA1. Ele garante modularidade e tratamento de erros, resultando em código reutilizável e de fácil manutenção.

import java.net.URLEncoder
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec
import org.joda.time.DateTime
import sttp.client4._
import sttp.model.Header
import scala.util.Random
object Auth {
  def urlEncode(text: String): String =
    URLEncoder.encode(text, java.nio.charset.Charset.defaultCharset())
  def generateNonce: String = Random.alphanumeric.take(15).mkString
  def sha1sign(text: String, key: String): String = {
    val mac = Mac.getInstance("HmacSHA1")
    val signingKey = new SecretKeySpec(key.getBytes, "HmacSHA1")
    mac.init(signingKey)
    val signature = mac.doFinal(text.getBytes("UTF-8"))
    java.util.Base64.getEncoder.encodeToString(signature)
  }
  def createHeader(authData: Map[String, String]): Header = {
    val signatureBaseString = "POST&" + urlEncode("https://api.twitter.com/2/tweets") + "&" +
      urlEncode(authData.toSeq.sorted.map(x => s"${x._1}=${x._2}").mkString("&"))
    val signature = sha1sign(signatureBaseString, "consumerSecret&tokenSecret")
    val authHeader = "OAuth " + authData.map { case (k, v) => s"""$k="${urlEncode(v)}"""" }.mkString(", ") +
      s""", oauth_signature="${urlEncode(signature)}""""
    Header("Authorization", authHeader)
  }
}
object TwitterApi {
  val postEndpoint = "https://api.twitter.com/2/tweets"
  def createPost(text: String): Response = {
    val authData = Map(
      "oauth_consumer_key" -> "yourConsumerKey",
      "oauth_nonce" -> Auth.generateNonce,
      "oauth_signature_method" -> "HMAC-SHA1",
      "oauth_timestamp" -> DateTime.now().getMillis.toString,
      "oauth_token" -> "yourToken",
      "oauth_version" -> "1.0"
    )
    val header = Auth.createHeader(authData)
    basicRequest
      .header(header)
      .contentType("application/json")
      .body(s"""{"text":"$text"}""")
      .post(uri"$postEndpoint")
      .send(backend)
  }
}

Abordagem alternativa: OAuth 1.0 com tratamento personalizado de Nonce e carimbo de data/hora

Este método agiliza o processo de assinatura, concentrando-se na geração de nonces e carimbos de data/hora personalizados com dependências mínimas.

import java.net.URLEncoder
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec
import sttp.client4._
import sttp.model.Header
object OAuthHelper {
  def generateTimestamp: String = (System.currentTimeMillis / 1000).toString
  def generateNonce: String = java.util.UUID.randomUUID().toString.replace("-", "")
  def urlEncode(value: String): String = URLEncoder.encode(value, "UTF-8")
  def hmacSha1(baseString: String, key: String): String = {
    val mac = Mac.getInstance("HmacSHA1")
    val signingKey = new SecretKeySpec(key.getBytes("UTF-8"), "HmacSHA1")
    mac.init(signingKey)
    val rawHmac = mac.doFinal(baseString.getBytes("UTF-8"))
    java.util.Base64.getEncoder.encodeToString(rawHmac)
  }
}
object TwitterClient {
  def createAuthorizationHeader(params: Map[String, String], signature: String): Header = {
    val headerParams = params.map { case (k, v) => s"""$k="${OAuthHelper.urlEncode(v)}"""" }.mkString(", ")
    Header("Authorization", s"""OAuth $headerParams, oauth_signature="$signature"""")
  }
  def postTweet(text: String): Response = {
    val params = Map(
      "oauth_consumer_key" -> "consumerKey",
      "oauth_nonce" -> OAuthHelper.generateNonce,
      "oauth_signature_method" -> "HMAC-SHA1",
      "oauth_timestamp" -> OAuthHelper.generateTimestamp,
      "oauth_token" -> "accessToken",
      "oauth_version" -> "1.0"
    )
    val baseString = "POST&" + OAuthHelper.urlEncode("https://api.twitter.com/2/tweets") + "&" +
      OAuthHelper.urlEncode(params.toSeq.sorted.map { case (k, v) => s"$k=$v" }.mkString("&"))
    val signature = OAuthHelper.hmacSha1(baseString, "consumerSecret&tokenSecret")
    val authHeader = createAuthorizationHeader(params, signature)
    basicRequest
      .header(authHeader)
      .contentType("application/json")
      .body(s"""{"text":"$text"}""")
      .post(uri"https://api.twitter.com/2/tweets")
      .send(backend)
  }
}

Perguntas frequentes sobre OAuth 1.0 e autenticação de API do Twitter

1. Como o OAuth 1.0 difere do OAuth 2.0?
2. O OAuth 1.0 usa assinaturas e criptografia HMAC-SHA1 para segurança, enquanto o OAuth 2.0 usa autorização baseada em token, o que simplifica o processo, mas exige conexões HTTPS seguras.
3. Qual é o propósito de um nonce no OAuth 1.0?
4. Para evitar ataques de repetição, cada solicitação gera uma string exclusiva conhecida como nonce. Ele garante que cada solicitação seja executada apenas uma vez. Scala permite que você construa um nonce usando Random.alphanumeric.take().
5. Por que a codificação de URL é necessária nas solicitações OAuth?
6. A codificação de URL é crucial porque certos caracteres, como e comercial (&) ou espaços, devem ser codificados para evitar interpretações incorretas. Usar URLEncoder.encode() para codificar com segurança esses caracteres.
7. Como faço para gerar uma assinatura OAuth?
8. Para estabelecer uma assinatura OAuth, primeiro crie uma string base a partir dos dados da solicitação e depois assine-a com a técnica HMAC-SHA1. Usar Mac.getInstance("HmacSHA1") para iniciar o processo de hash.
9. O que pode causar um erro 401 não autorizado no OAuth?
10. Um erro 401 pode ser causado por vários erros, incluindo assinatura inválida, chaves de consumidor incompatíveis ou codificação de parâmetro inadequada. Certifique-se sempre de que a assinatura corresponda aos dados da solicitação e que a codificação seja precisa.

Considerações finais sobre como resolver problemas de OAuth do Twitter

Para autorizar adequadamente uma solicitação OAuth 1.0 para a API do Twitter, os desenvolvedores devem gerenciar cuidadosamente as assinaturas e os cabeçalhos. Muitos problemas são causados ​​por problemas de codificação ou pelo uso do formato de string base incorreto. Erros como "401 Não Autorizado" podem ser evitados abordando esses problemas de maneira adequada.

Além disso, verificar novamente a criação do nonce, a precisão do carimbo de data/hora e a formatação do cabeçalho aumenta muito o sucesso da autorização. Otimizar o método sha1sign, garantir o cálculo preciso da assinatura e aderir aos requisitos do OAuth são etapas críticas para o desenvolvimento de um aplicativo de publicação X funcional e automatizado.