Problèmes d'autorisation OAuth 1.0 avec l'API X v2 dans Scala via STTP

Résolution de l'autorisation OAuth 1.0 avec Scala et STTP pour l'API Twitter

Ce script montre comment signer les requêtes OAuth 1.0 dans Scala à l'aide de HMAC-SHA1. Il garantit la modularité et la gestion des erreurs, ce qui donne lieu à un code réutilisable et maintenable.

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

Approche alternative : OAuth 1.0 avec gestion des noms occasionnels personnalisés et des horodatages

Cette méthode rationalise le processus de signature en se concentrant sur la génération de noms occasionnels et d'horodatages sur mesure avec un minimum de dépendances.

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

Questions fréquemment posées sur l'authentification OAuth 1.0 et l'API Twitter

1. En quoi OAuth 1.0 diffère-t-il d'OAuth 2.0 ?
2. OAuth 1.0 utilise des signatures et le cryptage HMAC-SHA1 pour la sécurité, tandis qu'OAuth 2.0 utilise une autorisation basée sur des jetons, ce qui simplifie le processus mais nécessite des connexions HTTPS sécurisées.
3. Quel est le but d'un nom occasionnel dans OAuth 1.0 ?
4. Pour empêcher les attaques par relecture, chaque requête génère une chaîne unique appelée nonce. Il garantit que chaque requête n’est exécutée qu’une seule fois. Scala vous permet de construire un nonce en utilisant Random.alphanumeric.take().
5. Pourquoi le codage d'URL est-il nécessaire dans les requêtes OAuth ?
6. Le codage des URL est crucial car certains caractères, comme les esperluettes (&) ou les espaces, doivent être codés pour éviter toute mauvaise interprétation. Utiliser URLEncoder.encode() pour encoder ces caractères en toute sécurité.
7. Comment générer une signature OAuth ?
8. Pour établir une signature OAuth, créez d'abord une chaîne de base à partir des données de la requête, puis signez-la avec la technique HMAC-SHA1. Utiliser Mac.getInstance("HmacSHA1") pour démarrer le processus de hachage.
9. Qu'est-ce qui peut provoquer une erreur 401 non autorisée dans OAuth ?
10. Une erreur 401 peut être provoquée par diverses erreurs, notamment une signature non valide, des clés de consommateur incompatibles ou un codage de paramètres inapproprié. Assurez-vous toujours que la signature correspond aux données de la demande et que le codage est exact.

Réflexions finales sur la résolution des problèmes de Twitter OAuth

Pour autoriser correctement une requête OAuth 1.0 pour l'API de Twitter, les développeurs doivent gérer soigneusement les signatures et les en-têtes. De nombreux problèmes sont causés par des problèmes d’encodage ou par l’utilisation d’un format de chaîne de base incorrect. Les erreurs telles que « 401 non autorisé » peuvent être évitées en résolvant ces problèmes de manière appropriée.

De plus, la revérification de la création des noms occasionnels, de la précision de l'horodatage et du formatage de l'en-tête augmente considérablement le succès de l'autorisation. L'optimisation de la méthode sha1sign, la garantie d'un calcul précis de la signature et le respect des exigences OAuth sont des étapes critiques vers le développement d'une application de publication X fonctionnelle et automatisée.