Problemas de autorización de OAuth 1.0 con X API v2 en Scala a través de STTP

Resolución de autorización de OAuth 1.0 con Scala y STTP para la API de Twitter

Este script muestra cómo firmar solicitudes de OAuth 1.0 en Scala usando HMAC-SHA1. Garantiza modularidad y manejo de errores, lo que da como resultado un código reutilizable y mantenible.

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)
  }
}

Enfoque alternativo: OAuth 1.0 con manejo personalizado de marcas de tiempo y nonce

Este método agiliza el proceso de firma centrándose en generar nonces y marcas de tiempo personalizados con dependencias 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)
  }
}

Preguntas frecuentes sobre OAuth 1.0 y la autenticación API de Twitter

1. ¿En qué se diferencia OAuth 1.0 de OAuth 2.0?
2. OAuth 1.0 utiliza firmas y cifrado HMAC-SHA1 por motivos de seguridad, mientras que OAuth 2.0 utiliza autorización basada en tokens, lo que simplifica el proceso pero requiere conexiones HTTPS seguras.
3. ¿Cuál es el propósito de un nonce en OAuth 1.0?
4. Para evitar ataques de repetición, cada solicitud genera una cadena única conocida como nonce. Garantiza que cada solicitud solo se ejecute una vez. Scala le permite construir un nonce usando Random.alphanumeric.take().
5. ¿Por qué es necesaria la codificación de URL en las solicitudes de OAuth?
6. La codificación de URL es crucial porque ciertos caracteres, como los símbolos (&) o espacios, deben codificarse para evitar malas interpretaciones. Usar URLEncoder.encode() para codificar de forma segura estos caracteres.
7. ¿Cómo genero una firma OAuth?
8. Para establecer una firma OAuth, primero cree una cadena base a partir de los datos de la solicitud y luego fírmela con la técnica HMAC-SHA1. Usar Mac.getInstance("HmacSHA1") para iniciar el proceso de hash.
9. ¿Qué puede causar un error 401 no autorizado en OAuth?
10. Un error 401 puede deberse a una variedad de errores, incluida una firma no válida, claves de consumidor que no coinciden o una codificación de parámetros inapropiada. Asegúrese siempre de que la firma coincida con los datos de la solicitud y que la codificación sea precisa.

Reflexiones finales sobre la resolución de problemas de OAuth en Twitter

Para autorizar adecuadamente una solicitud OAuth 1.0 para la API de Twitter, los desarrolladores deben administrar cuidadosamente las firmas y los encabezados. Muchos problemas se deben a problemas de codificación o al uso de un formato de cadena base incorrecto. Errores como "401 no autorizado" se pueden evitar solucionando estos problemas de forma adecuada.

Además, volver a verificar la creación del nonce, la precisión de la marca de tiempo y el formato del encabezado aumenta en gran medida el éxito de la autorización. Optimizar el método sha1sign, garantizar un cálculo preciso de la firma y cumplir con los requisitos de OAuth son etapas críticas para desarrollar una aplicación de publicación X funcional y automatizada.