OAuth 1.0 prieigos teisės problemos naudojant X API v2 sistemoje Scala per STTP

OAuth 1.0 autorizacijos sprendimas naudojant „Scala“ ir STTP „Twitter“ API

Šis scenarijus parodo, kaip pasirašyti OAuth 1.0 užklausas Scala naudojant HMAC-SHA1. Tai užtikrina moduliškumą ir klaidų tvarkymą, todėl kodas yra daugkartinis, prižiūrimas.

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

Alternatyvus metodas: „OAuth 1.0“ su „Custom Nonce“ ir laiko žymų tvarkymu

Šis metodas supaprastina parašo procesą, daugiausia dėmesio skiriant pagal užsakymą sukurtų netikslumų ir laiko žymų generavimui su minimaliomis priklausomybėmis.

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

Dažnai užduodami klausimai apie OAuth 1.0 ir Twitter API autentifikavimą

1. Kuo OAuth 1.0 skiriasi nuo OAuth 2.0?
2. OAuth 1.0 naudoja parašus ir HMAC-SHA1 šifravimą saugumo sumetimais, o OAuth 2.0 naudoja prieigos raktu pagrįstą autorizavimą, kuris supaprastina procesą, bet reikalauja saugaus HTTPS ryšio.
3. Koks OAuth 1.0 nonce tikslas?
4. Siekiant išvengti pakartojimo atakų, kiekviena užklausa sukuria unikalią eilutę, vadinamą nonce. Tai užtikrina, kad kiekviena užklausa būtų vykdoma tik vieną kartą. „Scala“ leidžia sukurti nenaudojimą Random.alphanumeric.take().
5. Kodėl OAuth užklausose reikalinga URL koduotė?
6. URL kodavimas yra labai svarbus, nes tam tikri simboliai, pvz., ampersandai (&) arba tarpai, turi būti užkoduoti, kad būtų išvengta klaidingo aiškinimo. Naudokite URLEncoder.encode() kad saugiai užkoduotų šiuos simbolius.
7. Kaip sugeneruoti OAuth parašą?
8. Norėdami sukurti OAuth parašą, pirmiausia sukurkite bazinę eilutę iš užklausos duomenų, tada pasirašykite ją naudodami HMAC-SHA1 techniką. Naudokite Mac.getInstance("HmacSHA1") pradėti maišos procesą.
9. Kas gali sukelti 401 neteisėtą OAuth klaidą?
10. 401 klaidą gali sukelti įvairios klaidos, įskaitant netinkamą parašą, nesutampančius vartotojo raktus arba netinkamą parametrų kodavimą. Visada įsitikinkite, kad parašas sutampa su užklausos duomenimis ir kad kodavimas yra tikslus.

Paskutinės mintys apie „Twitter“ OAuth problemų sprendimą

Norėdami tinkamai įgalioti OAuth 1.0 užklausą dėl Twitter API, kūrėjai turi atidžiai tvarkyti parašus ir antraštes. Daugelį problemų sukelia kodavimo problemos arba netinkamas pagrindinės eilutės formatas. Klaidų, tokių kaip „401 neteisėta“, galima išvengti tinkamai išsprendus šias problemas.

Be to, pakartotinai patikrinus, ar nėra sukurta, laiko žymos tikslumas ir antraštės formatavimas labai padidėja autorizavimo sėkmė. „Sha1sign“ metodo optimizavimas, tikslaus parašo skaičiavimo užtikrinimas ir „OAuth“ reikalavimų laikymasis yra svarbūs etapai kuriant funkcinę ir automatizuotą X publikavimo programą.