Problemes d'autorització OAuth 1.0 amb X API v2 a Scala mitjançant STTP

Resolució de l'autorització OAuth 1.0 amb Scala i STTP per a l'API de Twitter

Aquest script mostra com signar sol·licituds OAuth 1.0 a Scala mitjançant HMAC-SHA1. Assegura la modularitat i la gestió d'errors, donant lloc a codi reutilitzable i 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)
  }
}

Enfocament alternatiu: OAuth 1.0 amb gestió personalitzada de nonce i marca de temps

Aquest mètode racionalitza el procés de signatura centrant-se a generar noces i marques de temps a mida amb dependències mínimes.

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

Preguntes freqüents sobre OAuth 1.0 i l'autenticació de l'API de Twitter

1. En què difereix OAuth 1.0 d'OAuth 2.0?
2. OAuth 1.0 utilitza signatures i xifratge HMAC-SHA1 per a la seguretat, mentre que OAuth 2.0 utilitza autorització basada en testimonis, que simplifica el procés però requereix connexions HTTPS segures.
3. Quin és el propòsit d'un nonce a OAuth 1.0?
4. Per evitar atacs de reproducció, cada sol·licitud genera una cadena única coneguda com a nonce. Assegura que cada sol·licitud només s'executa una vegada. Scala us permet construir un nonce utilitzant Random.alphanumeric.take().
5. Per què és necessària la codificació d'URL a les sol·licituds d'OAuth?
6. La codificació d'URL és crucial perquè determinats caràcters, com ara els signes (&) o els espais, s'han de codificar per evitar interpretacions errònies. Ús URLEncoder.encode() per codificar aquests caràcters amb seguretat.
7. Com puc generar una signatura OAuth?
8. Per establir una signatura OAuth, primer creeu una cadena base a partir de les dades de la sol·licitud i després signeu-la amb la tècnica HMAC-SHA1. Ús Mac.getInstance("HmacSHA1") per iniciar el procés hashing.
9. Què pot provocar un error 401 no autoritzat a OAuth?
10. Un error 401 pot ser causat per diversos errors, com ara una signatura no vàlida, claus de consumidor que no coincideixen o una codificació de paràmetres inadequada. Assegureu-vos sempre que la signatura coincideixi amb les dades de la sol·licitud i que la codificació sigui precisa.

Consideracions finals sobre la resolució de problemes d'OAuth de Twitter

Per autoritzar correctament una sol·licitud d'OAuth 1.0 per a l'API de Twitter, els desenvolupadors han de gestionar acuradament les signatures i les capçaleres. Molts problemes són causats per problemes de codificació o per l'ús d'un format de cadena base incorrecte. Els errors com ara "401 no autoritzats" es poden prevenir si abordeu aquests problemes de manera adequada.

A més, tornar a comprovar la creació de nonce, la precisió de la marca de temps i el format de la capçalera augmenta molt l'èxit de l'autorització. Optimitzar el mètode sha1sign, assegurar un càlcul precís de la signatura i complir els requisits d'OAuth són etapes crítiques per desenvolupar una aplicació de publicació X funcional i automatitzada.