OAuth 1.0-autorisationsproblemer med X API v2 i Scala via STTP

Løsning af OAuth 1.0-autorisation med Scala og STTP til Twitter API

Dette script viser, hvordan man signerer OAuth 1.0-anmodninger i Scala ved hjælp af HMAC-SHA1. Det sikrer modularitet og fejlhåndtering, hvilket resulterer i genbrugelig, vedligeholdelig kode.

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

Alternativ tilgang: OAuth 1.0 med tilpasset nonce- og tidsstempelhåndtering

Denne metode strømliner signaturprocessen ved at fokusere på at generere skræddersyede nonces og tidsstempler med minimale afhængigheder.

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

Ofte stillede spørgsmål om OAuth 1.0 og Twitter API-godkendelse

1. Hvordan adskiller OAuth 1.0 sig fra OAuth 2.0?
2. OAuth 1.0 bruger signaturer og HMAC-SHA1-kryptering til sikkerhed, hvorimod OAuth 2.0 bruger token-baseret godkendelse, hvilket forenkler processen, men nødvendiggør sikre HTTPS-forbindelser.
3. Hvad er formålet med en nonce i OAuth 1.0?
4. For at forhindre gentagelsesangreb genererer hver anmodning en unik streng kendt som en nonce. Det sikrer, at hver anmodning kun udføres én gang. Scala giver dig mulighed for at konstruere en nonce vha Random.alphanumeric.take().
5. Hvorfor er URL-kodning nødvendig i OAuth-anmodninger?
6. URL-kodning er afgørende, fordi visse tegn, som og-tegn (&) eller mellemrum, skal kodes for at undgå fejlfortolkning. Bruge URLEncoder.encode() for sikkert at kode disse tegn.
7. Hvordan genererer jeg en OAuth-signatur?
8. For at etablere en OAuth-signatur skal du først oprette en basisstreng fra anmodningsdataene og derefter signere den med HMAC-SHA1-teknikken. Bruge Mac.getInstance("HmacSHA1") for at starte hashing-processen.
9. Hvad kan forårsage en 401 uautoriseret fejl i OAuth?
10. En 401-fejl kan være forårsaget af en række fejl, herunder en ugyldig signatur, uoverensstemmende forbrugernøgler eller upassende parameterkodning. Sørg altid for, at signaturen matcher anmodningsdataene, og at kodningen er nøjagtig.

Endelige tanker om løsning af Twitter OAuth-problemer

For at godkende en OAuth 1.0-anmodning til Twitters API korrekt, skal udviklere omhyggeligt administrere signaturer og overskrifter. Mange problemer er forårsaget af kodningsproblemer eller brug af det forkerte basisstrengformat. Fejl som "401 Uautoriseret" kan forhindres ved at løse disse problemer på passende vis.

Genkontrol af manglende oprettelse, tidsstempelnøjagtighed og headerformatering øger desuden godkendelsessuccesen. Optimering af sha1sign-metoden, sikring af nøjagtig signaturberegning og overholdelse af OAuth-krav er kritiske trin i udviklingen af ​​en funktionel og automatiseret X-publiceringsapplikation.