Whiz Tools

Codificatore di Stringhe URL

Strumento di Escape per Stringhe URL

Introduzione

Nel campo dello sviluppo web e delle comunicazioni su Internet, gli URL (Uniform Resource Locators) svolgono un ruolo cruciale nell'identificare le risorse sul web. Tuttavia, gli URL hanno restrizioni sui caratteri che possono contenere. Alcuni caratteri hanno significati speciali, mentre altri non sono sicuri per l'uso negli URL a causa della possibilità di interpretazione errata o corruzione durante la trasmissione.

La codifica degli URL, nota anche come percent-encoding, è un meccanismo per convertire caratteri speciali in un formato che può essere trasmesso su Internet. Questo strumento consente di inserire una stringa URL e di eseguire l'escape dei caratteri speciali, garantendo che l'URL sia valido e possa essere interpretato correttamente dai browser web e dai server.

Comprendere la Codifica degli URL

Cos'è la Codifica degli URL?

La codifica degli URL comporta la sostituzione dei caratteri ASCII non sicuri con un % seguito da due cifre esadecimali che rappresentano il codice ASCII del carattere. Garantisce che le informazioni vengano trasmesse su Internet senza alterazioni.

Ad esempio, il carattere spazio ' ' viene sostituito da %20.

Perché è Necessaria la Codifica degli URL?

Gli URL possono essere inviati su Internet utilizzando solo il set di caratteri ASCII. Poiché gli URL spesso contengono caratteri al di fuori di questo set, devono essere convertiti in un formato ASCII valido. La codifica degli URL garantisce che i caratteri speciali non causino effetti indesiderati o errori nelle richieste web.

Caratteri che Necessitano di Codifica

Secondo la specifica RFC 3986, i seguenti caratteri sono riservati negli URL e devono essere percent-encoded se devono essere utilizzati letteralmente:

  • Delimitatori generali: :, /, ?, #, [, ], @
  • Sub-delimitatori: !, $, &, ', (, ), *, +, ,, ;, =

Inoltre, qualsiasi carattere non ASCII, inclusi i caratteri Unicode, deve essere codificato.

Come Funziona la Codifica degli URL?

Il Processo di Codifica

  1. Identificare i Caratteri Speciali: Analizzare la stringa URL e identificare i caratteri che non sono caratteri ASCII non riservati (lettere, cifre, -, ., _, ~).

  2. Convertire in Codice ASCII: Per ciascun carattere speciale, ottenere il suo codice ASCII o punto di codice Unicode.

  3. Convertire in Sequenza di Byte UTF-8 (se necessario): Per i caratteri non ASCII, codificare il carattere in uno o più byte utilizzando la codifica UTF-8.

  4. Convertire in Esadecimale: Convertire ciascun byte nel suo equivalente esadecimale a due cifre.

  5. Prefissare con il Simbolo Percentuale: Precedere ciascun byte esadecimale con un simbolo %.

Esempio di Codifica

  • Carattere: ' ' (Spazio)

    • Codice ASCII: 32
    • Esadecimale: 20
    • URL Codificato: %20

  • Carattere: 'é'

    • Codifica UTF-8: 0xC3 0xA9
    • URL Codificato: %C3%A9

Casi Limite da Considerare

  • Caratteri Unicode: I caratteri non ASCII devono essere codificati in UTF-8 e poi percent-encoded.

  • Percentuali Già Codificate: I simboli percentuali che fanno parte delle percent-encoding non devono essere ricodificati.

  • Caratteri Riservati nelle Stringhe di Query: Alcuni caratteri hanno significati speciali nelle stringhe di query e dovrebbero essere codificati per prevenire alterazioni nella struttura.

Decodifica degli URL

Cos'è la Decodifica degli URL?

La decodifica degli URL è il processo inverso della codifica degli URL. Converte i caratteri percent-encoded nel loro stato originale, rendendo l'URL leggibile e interpretabile da esseri umani e sistemi.

Processo di Decodifica

  1. Identificare le Sequenze di Percent-Encoding: Individuare tutti i simboli % seguiti da due cifre esadecimali nella stringa URL.

  2. Convertire l'Esadecimale in Byte: Tradurre ciascun valore esadecimale nel suo corrispondente byte.

  3. Decodificare i Byte UTF-8 (se necessario): Per le sequenze di byte multiple, combinare i byte e decodificarli utilizzando la codifica UTF-8 per ottenere il carattere originale.

  4. Sostituire le Sequenze Codificate: Sostituire le sequenze percent-encoded con i caratteri decodificati.

Esempio di Decodifica

  • Codificato: hello%20world

    • %20 si traduce in uno spazio ' '
    • Decodificato: hello world

  • Codificato: J%C3%BCrgen

    • %C3%A4 si traduce in 'ü' in UTF-8
    • Decodificato: Jürgen

Importanza della Decodifica degli URL

La decodifica degli URL è essenziale quando si elaborano input dell'utente da URL, si leggono parametri di query o si interpretano dati ricevuti da richieste web. Garantisce che le informazioni estratte da un URL siano nella loro forma originale e prevista.

Casi d'Uso

Sviluppo Web

  • Parametri di Query: Codificare l'input dell'utente nei parametri di query per prevenire errori o vulnerabilità di sicurezza.

  • Parametri di Percorso: Includere in modo sicuro dati dinamici nei percorsi URL.

Trasmissione Dati

  • API e Servizi Web: Garantire che i dati inviati alle API siano formattati correttamente.

  • Internazionalizzazione: Supportare URL con caratteri di varie lingue.

Sicurezza

  • Prevenire Attacchi di Iniezione: Codificare gli input per mitigare il rischio di cross-site scripting (XSS) e altri attacchi di iniezione.

Alternative

Sebbene la codifica degli URL sia essenziale, ci sono scenari in cui altri metodi di codifica potrebbero essere più appropriati:

  • Codifica Base64: Utilizzata per codificare dati binari all'interno degli URL o quando è richiesta una maggiore densità informativa.

  • Codifica UTF-8 senza Percent-Encoding: Alcuni sistemi utilizzano direttamente la codifica UTF-8, ma questo può portare a problemi se non gestito correttamente.

Considerare le specifiche della propria applicazione per scegliere il metodo di codifica più adatto.

Storia

La codifica degli URL è stata introdotta con le prime specifiche degli URL e degli URI (Uniform Resource Identifier) negli anni '90. La necessità di un modo coerente per codificare caratteri speciali è emersa dai diversi sistemi e set di caratteri utilizzati in tutto il mondo.

I traguardi chiave includono:

  • RFC 1738 (1994): Ha definito gli URL e introdotto la percent-encoding.

  • RFC 3986 (2005): Ha aggiornato la sintassi URI, affinando le regole per la codifica.

Nel tempo, la codifica degli URL è diventata parte integrante delle tecnologie web, garantendo comunicazioni affidabili tra diversi sistemi e piattaforme.

Esempi di Codice

Ecco esempi di come eseguire la codifica degli URL in vari linguaggi di programmazione:

' Esempio Excel VBA
Function URLEncode(ByVal Text As String) As String
    Dim i As Integer
    Dim CharCode As Integer
    Dim Char As String
    Dim EncodedText As String

    For i = 1 To Len(Text)
        Char = Mid(Text, i, 1)
        CharCode = AscW(Char)
        Select Case CharCode
            Case 48 To 57, 65 To 90, 97 To 122, 45, 46, 95, 126 ' 0-9, A-Z, a-z, -, ., _, ~
                EncodedText = EncodedText & Char
            Case Else
                If CharCode < 0 Then
                    ' Gestire i caratteri Unicode
                    EncodedText = EncodedText & "%" & Hex(65536 + CharCode)
                Else
                    EncodedText = EncodedText & "%" & Right("0" & Hex(CharCode), 2)
                End If
        End Select
    Next i
    URLEncode = EncodedText
End Function

' Utilizzo:
' =URLEncode("https://example.com/?name=Jürgen")

% Esempio MATLAB
function encodedURL = urlEncode(url)
    import java.net.URLEncoder
    encodedURL = char(URLEncoder.encode(url, 'UTF-8'));
end

% Utilizzo:
% encodedURL = urlEncode('https://example.com/?name=Jürgen');

## Esempio Ruby
require 'uri'

url = 'https://example.com/path?query=hello world&name=Jürgen'
encoded_url = URI::DEFAULT_PARSER.escape(url)
puts encoded_url
## Output: https://example.com/path?query=hello%20world&name=J%C3%BCrgen

// Esempio Rust
use url::form_urlencoded;

fn main() {
    let url = "https://example.com/path?query=hello world&name=Jürgen";
    let encoded_url = percent_encode(url);
    println!("{}", encoded_url);
    // Output: https://example.com/path%3Fquery%3Dhello%20world%26name%3DJ%C3%BCrgen
}

fn percent_encode(input: &str) -> String {
    use percent_encoding::{utf8_percent_encode, NON_ALPHANUMERIC};
    utf8_percent_encode(input, NON_ALPHANUMERIC).to_string()
}

## Esempio Python
import urllib.parse

url = 'https://example.com/path?query=hello world&name=Jürgen'
encoded_url = urllib.parse.quote(url, safe=':/?&=')
print(encoded_url)
## Output: https://example.com/path?query=hello%20world&name=J%C3%BCrgen

// Esempio JavaScript
const url = 'https://example.com/path?query=hello world&name=Jürgen';
const encodedURL = encodeURI(url);
console.log(encodedURL);
// Output: https://example.com/path?query=hello%20world&name=J%C3%BCrgen

// Esempio Java
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;

public class URLEncodeExample {
    public static void main(String[] args) throws Exception {
        String url = "https://example.com/path?query=hello world&name=Jürgen";
        String encodedURL = URLEncoder.encode(url, StandardCharsets.UTF_8.toString());
        // Sostituire "+" con "%20" per gli spazi
        encodedURL = encodedURL.replace("+", "%20");
        System.out.println(encodedURL);
        // Output: https%3A%2F%2Fexample.com%2Fpath%3Fquery%3Dhello%20world%26name%3DJ%C3%BCrgen
    }
}

// Esempio C#
using System;
using System.Net;

class Program
{
    static void Main()
    {
        string url = "https://example.com/path?query=hello world&name=Jürgen";
        string encodedURL = Uri.EscapeUriString(url);
        Console.WriteLine(encodedURL);
        // Output: https://example.com/path?query=hello%20world&name=J%C3%BCrgen
    }
}

<?php
// Esempio PHP
$url = 'https://example.com/path?query=hello world&name=Jürgen';
$encodedURL = urlencode($url);
echo $encodedURL;
// Output: https%3A%2F%2Fexample.com%2Fpath%3Fquery%3Dhello+world%26name%3DJ%C3%BCrgen
?>

// Esempio Go
package main

import (
    "fmt"
    "net/url"
)

func main() {
    urlStr := "https://example.com/path?query=hello world&name=Jürgen"
    encodedURL := url.QueryEscape(urlStr)
    fmt.Println(encodedURL)
    // Output: https%3A%2F%2Fexample.com%2Fpath%3Fquery%3Dhello+world%26name%3DJ%25C3%25BCrgen
}

// Esempio Swift
import Foundation

let url = "https://example.com/path?query=hello world&name=Jürgen"
if let encodedURL = url.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed) {
    print(encodedURL)
    // Output: https://example.com/path?query=hello%20world&name=J%C3%BCrgen
}

## Esempio R
url <- "https://example.com/path?query=hello world&name=Jürgen"
encodedURL <- URLencode(url, reserved = TRUE)
print(encodedURL)
## Output: https://example.com/path?query=hello%20world&name=J%C3%BCrgen

Nota: L'output può variare leggermente a seconda di come ciascun linguaggio gestisce i caratteri riservati e gli spazi (ad esempio, codificando gli spazi come %20 o +).

Diagramma SVG del Processo di Codifica degli URL

Processo di Codifica degli URL URL Originale Identificare Speciali Caratteri Codificare URL Esempio: Input: https://example.com/über uns Output: https://example.com/%C3%BCber%20uns

Considerazioni di Sicurezza

Una corretta codifica e decodifica degli URL è fondamentale per la sicurezza:

  • Prevenire Attacchi di Iniezione: La codifica dell'input dell'utente aiuta a prevenire l'esecuzione di codice malevolo, mitigando i rischi come il cross-site scripting (XSS) e l'iniezione SQL.

  • Integrità dei Dati: Garantisce che i dati vengano trasmessi senza alterazioni o corruzione.

  • Conformità agli Standard: Aderire agli standard di codifica evita problemi di interoperabilità tra i sistemi.

Riferimenti

  1. RFC 3986 - Identificatore di Risorsa Uniforme (URI): https://tools.ietf.org/html/rfc3986
  2. Cos'è la Codifica degli URL e Come Funziona? https://www.urlencoder.io/learn/
  3. Percent-encoding: https://en.wikipedia.org/wiki/Percent-encoding
  4. Standard URL: https://url.spec.whatwg.org/
  5. URI.escape è obsoleto: https://stackoverflow.com/questions/2824126/why-is-uri-escape-deprecated

Conclusione

La codifica degli URL è un aspetto essenziale dello sviluppo web e delle comunicazioni su Internet. Convertendo i caratteri speciali in un formato sicuro, garantisce che gli URL siano interpretati correttamente da browser e server, mantenendo l'integrità e la sicurezza della trasmissione dei dati. Questo strumento fornisce un modo conveniente per eseguire l'escape dei caratteri speciali nei tuoi URL, migliorando la compatibilità e prevenendo potenziali errori o vulnerabilità di sicurezza.

Feedback