Težave z avtorizacijo OAuth 1.0 z API-jem X v2 v Scali prek STTP

Razreševanje avtorizacije OAuth 1.0 s Scala in STTP za Twitter API

Ta skript prikazuje, kako podpisati zahteve OAuth 1.0 v Scali z uporabo HMAC-SHA1. Zagotavlja modularnost in obravnavanje napak, kar ima za posledico ponovno uporabno in vzdržljivo kodo.

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

Alternativni pristop: OAuth 1.0 z ravnanjem s časovnim žigom po meri

Ta metoda poenostavi postopek podpisovanja tako, da se osredotoči na ustvarjanje prilagojenih nonce in časovnih žigov z minimalnimi odvisnostmi.

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

Pogosto zastavljena vprašanja o OAuth 1.0 in preverjanju pristnosti API-ja za Twitter

1. Kako se OAuth 1.0 razlikuje od OAuth 2.0?
2. OAuth 1.0 za varnost uporablja podpise in šifriranje HMAC-SHA1, medtem ko OAuth 2.0 uporablja avtorizacijo na podlagi žetonov, kar poenostavlja postopek, vendar zahteva varne povezave HTTPS.
3. Kakšen je namen oznake nonce v OAuth 1.0?
4. Za preprečitev napadov ponovnega predvajanja vsaka zahteva ustvari edinstven niz, znan kot nonce. Zagotavlja, da se vsaka zahteva izvede le enkrat. Scala vam omogoča, da sestavite nonce z uporabo Random.alphanumeric.take().
5. Zakaj je v zahtevah OAuth potrebno kodiranje URL-jev?
6. Kodiranje URL-jev je ključnega pomena, ker morajo biti določeni znaki, kot so ampersand (&) ali presledki, kodirani, da se prepreči napačna interpretacija. Uporaba URLEncoder.encode() za varno kodiranje teh znakov.
7. Kako ustvarim podpis OAuth?
8. Če želite vzpostaviti podpis OAuth, najprej ustvarite osnovni niz iz podatkov zahteve in ga nato podpišite s tehniko HMAC-SHA1. Uporaba Mac.getInstance("HmacSHA1") za začetek postopka zgoščevanja.
9. Kaj lahko povzroči napako 401 Nepooblaščeno v OAuth?
10. Napako 401 lahko povzročijo različne napake, vključno z neveljavnim podpisom, neujemajočimi se uporabniškimi ključi ali neustreznim kodiranjem parametrov. Vedno zagotovite, da se podpis ujema s podatki zahteve in da je kodiranje natančno.

Zadnje misli o reševanju težav z OAuth za Twitter

Za pravilno avtorizacijo zahteve OAuth 1.0 za Twitterjev API morajo razvijalci skrbno upravljati podpise in glave. Številne težave nastanejo zaradi težav s kodiranjem ali uporabe nepravilne oblike osnovnega niza. Napake, kot je »401 nepooblaščeno«, lahko preprečite tako, da te težave ustrezno obravnavate.

Poleg tega ponovno preverjanje ustvarjanja nonce, natančnosti časovnega žiga in oblikovanja glave močno poveča uspešnost avtorizacije. Optimiziranje metode sha1sign, zagotavljanje natančnega izračuna podpisa in upoštevanje zahtev OAuth so ključne faze pri razvoju funkcionalne in avtomatizirane aplikacije za objavljanje X.