OAuth 1.0-autorisatieproblemen met X API v2 in Scala via STTP

OAuth 1.0-autorisatie oplossen met Scala en STTP voor de Twitter API

Dit script laat zien hoe u OAuth 1.0-verzoeken in Scala kunt ondertekenen met behulp van HMAC-SHA1. Het zorgt voor modulariteit en foutafhandeling, wat resulteert in herbruikbare, onderhoudbare code.

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

Alternatieve aanpak: OAuth 1.0 met aangepaste verwerking van nonce en tijdstempel

Deze methode stroomlijnt het ondertekeningsproces door zich te concentreren op het genereren van op maat gemaakte nonces en tijdstempels met minimale afhankelijkheden.

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

Veelgestelde vragen over OAuth 1.0 en Twitter API-authenticatie

1. Waarin verschilt OAuth 1.0 van OAuth 2.0?
2. OAuth 1.0 maakt gebruik van handtekeningen en HMAC-SHA1-codering voor beveiliging, terwijl OAuth 2.0 gebruik maakt van token-gebaseerde autorisatie, wat het proces vereenvoudigt maar veilige HTTPS-verbindingen vereist.
3. Wat is het doel van een nonce in OAuth 1.0?
4. Om replay-aanvallen te voorkomen, genereert elk verzoek een unieke string die bekend staat als een nonce. Het zorgt ervoor dat elk verzoek slechts één keer wordt uitgevoerd. Met Scala kun je een nonce bouwen met behulp van Random.alphanumeric.take().
5. Waarom is URL-codering nodig in OAuth-verzoeken?
6. URL-codering is van cruciaal belang omdat bepaalde tekens, zoals ampersands (&) of spaties, moeten worden gecodeerd om verkeerde interpretaties te voorkomen. Gebruik URLEncoder.encode() om deze tekens veilig te coderen.
7. Hoe genereer ik een OAuth-handtekening?
8. Om een ​​OAuth-handtekening tot stand te brengen, maakt u eerst een basisreeks op basis van de aanvraaggegevens en ondertekent u deze vervolgens met de HMAC-SHA1-techniek. Gebruik Mac.getInstance("HmacSHA1") om het hashingproces te starten.
9. Wat kan een 401 ongeautoriseerde fout in OAuth veroorzaken?
10. Een 401-fout kan worden veroorzaakt door een verscheidenheid aan fouten, waaronder een ongeldige handtekening, niet-overeenkomende consumentensleutels of ongepaste parametercodering. Zorg er altijd voor dat de handtekening overeenkomt met de aanvraaggegevens en dat de codering accuraat is.

Laatste gedachten over het oplossen van Twitter OAuth-problemen

Om een ​​OAuth 1.0-verzoek voor de Twitter-API goed te autoriseren, moeten ontwikkelaars handtekeningen en headers zorgvuldig beheren. Veel problemen worden veroorzaakt door coderingsproblemen of door het gebruik van een onjuist basistekenreeksformaat. Fouten zoals '401 Unauthorized' kunnen worden voorkomen door deze problemen op de juiste manier aan te pakken.

Bovendien vergroot het opnieuw controleren van de creatie van nonce, de nauwkeurigheid van de tijdstempel en de opmaak van de koptekst het autorisatiesucces aanzienlijk. Het optimaliseren van de sha1sign-methode, het garanderen van een nauwkeurige handtekeningberekening en het voldoen aan de OAuth-vereisten zijn cruciale fasen in de ontwikkeling van een functionele en geautomatiseerde X-publicatietoepassing.