OAuth 1.0 autorizācijas problēmas ar X API v2 programmā Scala, izmantojot STTP

OAuth 1.0 autorizācijas atrisināšana, izmantojot Scala un STTP Twitter API

Šis skripts parāda, kā parakstīt OAuth 1.0 pieprasījumus programmā Scala, izmantojot HMAC-SHA1. Tas nodrošina modularitāti un kļūdu apstrādi, kā rezultātā tiek iegūts atkārtoti lietojams, apkopjams kods.

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

Alternatīva pieeja: OAuth 1.0 ar pielāgotu Nonce un laikspiedolu apstrādi

Šī metode racionalizē parakstīšanas procesu, koncentrējoties uz pasūtījuma neatbilstību un laikspiedolu ģenerēšanu ar minimālu atkarību.

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

Bieži uzdotie jautājumi par OAuth 1.0 un Twitter API autentifikāciju

1. Kā OAuth 1.0 atšķiras no OAuth 2.0?
2. OAuth 1.0 drošības nolūkos izmanto parakstus un HMAC-SHA1 šifrēšanu, savukārt OAuth 2.0 izmanto pilnvaru, kas balstīta uz pilnvarām, kas vienkāršo procesu, bet ir nepieciešami droši HTTPS savienojumi.
3. Kāds ir OAuth 1.0 neprecizitātes mērķis?
4. Lai novērstu atkārtošanas uzbrukumus, katrs pieprasījums ģenerē unikālu virkni, kas pazīstama kā nonce. Tas nodrošina, ka katrs pieprasījums tiek izpildīts tikai vienu reizi. Scala ļauj jums izveidot nonce, izmantojot Random.alphanumeric.take().
5. Kāpēc OAuth pieprasījumos ir nepieciešams URL kodējums?
6. URL kodējums ir ļoti svarīgs, jo noteiktas rakstzīmes, piemēram, & (&) vai atstarpes, ir jākodē, lai izvairītos no nepareizas interpretācijas. Izmantot URLEncoder.encode() lai droši kodētu šīs rakstzīmes.
7. Kā ģenerēt OAuth parakstu?
8. Lai izveidotu OAuth parakstu, vispirms izveidojiet bāzes virkni no pieprasījuma datiem un pēc tam parakstiet to, izmantojot HMAC-SHA1 paņēmienu. Izmantot Mac.getInstance("HmacSHA1") lai sāktu jaukšanas procesu.
9. Kas var izraisīt 401 nesankcionētu kļūdu pakalpojumā OAuth?
10. Kļūdu 401 var izraisīt dažādas kļūdas, tostarp nederīgs paraksts, neatbilstošas ​​patērētāja atslēgas vai neatbilstošs parametru kodējums. Vienmēr pārliecinieties, vai paraksts atbilst pieprasījuma datiem un vai kodējums ir precīzs.

Pēdējās domas par Twitter OAuth problēmu risināšanu

Lai pareizi autorizētu OAuth 1.0 pieprasījumu Twitter API, izstrādātājiem rūpīgi jāpārvalda paraksti un galvenes. Daudzas problēmas izraisa kodēšanas problēmas vai nepareiza bāzes virknes formāta izmantošana. Kļūdas, piemēram, "401 Nesankcionēts", var novērst, pienācīgi risinot šīs problēmas.

Turklāt, atkārtoti pārbaudot nepareizu izveidi, laikspiedolu precizitāti un galvenes formatējumu, ievērojami palielinās autorizācijas panākumi. Metodes sha1sign optimizēšana, precīza paraksta aprēķina nodrošināšana un OAuth prasību ievērošana ir kritiski posmi funkcionālas un automatizētas X publicēšanas lietojumprogrammas izstrādē.