OAuth 1.0 engedélyezési problémák az X API v2-vel a Scalában STTP-n keresztül

Az OAuth 1.0 hitelesítés megoldása Scalával és STTP-vel a Twitter API-hoz

Ez a szkript bemutatja, hogyan írhat alá OAuth 1.0-kérelmeket a Scalában a HMAC-SHA1 használatával. Biztosítja a modularitást és a hibakezelést, ami újrafelhasználható, karbantartható kódot eredményez.

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ív megközelítés: OAuth 1.0 egyedi Nonce és időbélyeg kezeléssel

Ez a módszer leegyszerűsíti az aláírási folyamatot azáltal, hogy testre szabott eltérések és időbélyegek létrehozására összpontosít minimális függőséggel.

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

Gyakran ismételt kérdések az OAuth 1.0 és a Twitter API hitelesítésről

1. Miben különbözik az OAuth 1.0 az OAuth 2.0-tól?
2. Az OAuth 1.0 aláírásokat és HMAC-SHA1 titkosítást használ a biztonság érdekében, míg az OAuth 2.0 token alapú engedélyezést használ, ami leegyszerűsíti a folyamatot, de biztonságos HTTPS-kapcsolatokat tesz szükségessé.
3. Mi a nonce célja az OAuth 1.0-ban?
4. A visszajátszási támadások elkerülése érdekében minden kérés egyedi karakterláncot generál, amelyet nonce néven ismerünk. Biztosítja, hogy minden kérést csak egyszer hajtsanak végre. A Scala lehetővé teszi egy nonce using létrehozását Random.alphanumeric.take().
5. Miért szükséges az URL-kódolás az OAuth-kérésekben?
6. Az URL-kódolás kulcsfontosságú, mert bizonyos karaktereket, például és-jeleket (&) vagy szóközöket kódolni kell a félreértelmezések elkerülése érdekében. Használat URLEncoder.encode() hogy biztonságosan kódolja ezeket a karaktereket.
7. Hogyan hozhatok létre OAuth-aláírást?
8. OAuth-aláírás létrehozásához először hozzon létre egy alapkarakterláncot a kérésadatokból, majd írja alá a HMAC-SHA1 technikával. Használat Mac.getInstance("HmacSHA1") a kivonatolási folyamat elindításához.
9. Mi okozhat 401-es jogosulatlan hibát az OAuthban?
10. A 401-es hibát számos hiba okozhatja, beleértve az érvénytelen aláírást, a nem megfelelő fogyasztói kulcsokat vagy a nem megfelelő paraméterkódolást. Mindig győződjön meg arról, hogy az aláírás megegyezik a kérés adataival, és a kódolás pontos.

Utolsó gondolatok a Twitter OAuth-problémák megoldásáról

A Twitter API-jára vonatkozó OAuth 1.0 kérelmek megfelelő engedélyezéséhez a fejlesztőknek gondosan kell kezelniük az aláírásokat és a fejléceket. Sok problémát a kódolási problémák vagy a nem megfelelő alapkarakterlánc-formátum használata okoz. Az olyan hibák, mint például a „401 jogosulatlan”, megelőzhetők ezeknek a problémáknak megfelelő megoldásával.

Ezenkívül a nem-létrehozás, az időbélyeg pontosságának és a fejlécformázásnak az újraellenőrzése nagymértékben növeli az engedélyezési sikert. A sha1sign módszer optimalizálása, a pontos aláírás-számítás biztosítása és az OAuth-követelmények betartása kritikus lépések egy működőképes és automatizált X közzétételi alkalmazás fejlesztésében.