Probleme de autorizare OAuth 1.0 cu X API v2 în Scala prin STTP

Rezolvarea autorizației OAuth 1.0 cu Scala și STTP pentru API-ul Twitter

Acest script arată cum să semnați solicitările OAuth 1.0 în Scala folosind HMAC-SHA1. Acesta asigură modularitatea și gestionarea erorilor, rezultând un cod reutilizabil și care poate fi întreținut.

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

Abordare alternativă: OAuth 1.0 cu manipulare personalizată Nonce și marca temporală

Această metodă simplifică procesul de semnătură concentrându-se pe generarea de non-uri personalizate și marcaje de timp cu dependențe 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)
  }
}

Întrebări frecvente despre OAuth 1.0 și autentificarea API Twitter

1. Prin ce diferă OAuth 1.0 de OAuth 2.0?
2. OAuth 1.0 utilizează semnături și criptarea HMAC-SHA1 pentru securitate, în timp ce OAuth 2.0 utilizează autorizarea bazată pe token, ceea ce simplifică procesul, dar necesită conexiuni HTTPS sigure.
3. Care este scopul unui nonce în OAuth 1.0?
4. Pentru a preveni atacurile de reluare, fiecare solicitare generează un șir unic cunoscut sub numele de nonce. Se asigură că fiecare cerere este executată o singură dată. Scala vă permite să construiți un nonce folosind Random.alphanumeric.take().
5. De ce este necesară codificarea adreselor URL în solicitările OAuth?
6. Codificarea adreselor URL este crucială, deoarece anumite caractere, cum ar fi ampersand (&) sau spații, trebuie să fie codificate pentru a evita interpretarea greșită. Utilizare URLEncoder.encode() pentru a codifica în siguranță aceste caractere.
7. Cum generez o semnătură OAuth?
8. Pentru a stabili o semnătură OAuth, creați mai întâi un șir de bază din datele cererii și apoi semnați-l cu tehnica HMAC-SHA1. Utilizare Mac.getInstance("HmacSHA1") pentru a începe procesul de hashing.
9. Ce poate cauza o eroare 401 neautorizată în OAuth?
10. O eroare 401 poate fi cauzată de o varietate de erori, inclusiv o semnătură nevalidă, chei de consum nepotrivite sau codificare inadecvată a parametrilor. Asigurați-vă întotdeauna că semnătura se potrivește cu datele solicitate și că codificarea este corectă.

Gânduri finale despre rezolvarea problemelor OAuth pe Twitter

Pentru a autoriza corect o solicitare OAuth 1.0 pentru API-ul Twitter, dezvoltatorii trebuie să gestioneze cu atenție semnăturile și anteturile. Multe probleme sunt cauzate de probleme de codificare sau de utilizarea unui format incorect de șir de bază. Erorile precum „401 neautorizate” pot fi prevenite abordând aceste probleme în mod corespunzător.

În plus, reverificarea creării nonce, acuratețea marcajului de timp și formatarea antetului crește foarte mult succesul autorizației. Optimizarea metodei sha1sign, asigurarea calculului precis al semnăturii și respectarea cerințelor OAuth sunt etape critice pentru dezvoltarea unei aplicații de publicare X funcționale și automate.