Problemi di autorizzazione OAuth 1.0 con X API v2 in Scala tramite STTP

Risoluzione dell'autorizzazione OAuth 1.0 con Scala e STTP per l'API di Twitter

Questo script mostra come firmare le richieste OAuth 1.0 in Scala utilizzando HMAC-SHA1. Garantisce modularità e gestione degli errori, risultando in un codice riutilizzabile e manutenibile.

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

Approccio alternativo: OAuth 1.0 con gestione del nonce personalizzato e del timestamp

Questo metodo semplifica il processo di firma concentrandosi sulla generazione di nonce e timestamp personalizzati con dipendenze minime.

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

Domande frequenti su OAuth 1.0 e sull'autenticazione API di Twitter

1. In cosa differisce OAuth 1.0 da OAuth 2.0?
2. OAuth 1.0 utilizza firme e crittografia HMAC-SHA1 per la sicurezza, mentre OAuth 2.0 utilizza l'autorizzazione basata su token, che semplifica il processo ma richiede connessioni HTTPS sicure.
3. Qual è lo scopo di un nonce in OAuth 1.0?
4. Per prevenire attacchi di replay, ogni richiesta genera una stringa univoca nota come nonce. Garantisce che ogni richiesta venga eseguita una sola volta. Scala ti permette di costruire un nonce usando Random.alphanumeric.take().
5. Perché è necessaria la codifica URL nelle richieste OAuth?
6. La codifica dell'URL è fondamentale perché alcuni caratteri, come la e commerciale (&) o gli spazi, devono essere codificati per evitare interpretazioni errate. Utilizzo URLEncoder.encode() per codificare in modo sicuro questi caratteri.
7. Come posso generare una firma OAuth?
8. Per stabilire una firma OAuth, creare prima una stringa di base dai dati della richiesta e poi firmarla con la tecnica HMAC-SHA1. Utilizzo Mac.getInstance("HmacSHA1") per avviare il processo di hashing.
9. Cosa può causare un errore 401 Non autorizzato in OAuth?
10. Un errore 401 può essere causato da una serie di errori, tra cui una firma non valida, chiavi consumer non corrispondenti o codifica dei parametri inappropriata. Assicurati sempre che la firma corrisponda ai dati della richiesta e che la codifica sia accurata.

Considerazioni finali sulla risoluzione dei problemi OAuth di Twitter

Per autorizzare correttamente una richiesta OAuth 1.0 per l'API di Twitter, gli sviluppatori devono gestire attentamente firme e intestazioni. Molti problemi sono causati da problemi di codifica o dall'utilizzo di un formato di stringa di base errato. Errori come "401 Unauthorized" possono essere prevenuti risolvendo questi problemi in modo appropriato.

Inoltre, il ricontrollo della creazione del nonce, dell'accuratezza del timestamp e della formattazione dell'intestazione aumenta notevolmente il successo dell'autorizzazione. L'ottimizzazione del metodo sha1sign, la garanzia di un calcolo accurato della firma e il rispetto dei requisiti OAuth sono fasi cruciali verso lo sviluppo di un'applicazione di pubblicazione X funzionale e automatizzata.