URL String Escaper Tool for Safe Web Applications

URL-strengs Escaper Verktøy

Introduksjon

I webutvikling og internettkommunikasjon spiller URL-er (Uniform Resource Locators) en avgjørende rolle i å identifisere ressurser på nettet. Imidlertid har URL-er restriksjoner på hvilke tegn de kan inneholde. Enkelte tegn har spesielle betydninger, mens andre er usikre å bruke i URL-er på grunn av muligheten for feiltolkning eller korrupsjon under overføring.

URL-koding, også kjent som prosent-koding, er en mekanisme for å konvertere spesialtegn til et format som kan overføres over internett. Dette verktøyet lar deg skrive inn en URL-streng og eskapere spesialtegn, noe som sikrer at URL-en er gyldig og kan tolkes riktig av nettlesere og servere.

Forstå URL-koding

Hva er URL-koding?

URL-koding innebærer å erstatte usikre ASCII-tegn med en % etterfulgt av to heksadesimale sifre som representerer tegnets ASCII-kode. Det sikrer at informasjonen overføres over internett uten endringer.

For eksempel, mellomromstegnet ' ' blir erstattet med %20.

Hvorfor er URL-koding nødvendig?

URL-er kan bare sendes over internett ved hjelp av ASCII-tegnsettet. Siden URL-er ofte inneholder tegn utenfor dette settet, må de konverteres til et gyldig ASCII-format. URL-koding garanterer at spesialtegn ikke forårsaker utilsiktede effekter eller feil i webforespørslene.

Tegn som må kodes

I henhold til RFC 3986-spesifikasjonen må følgende tegn som er reservert i URL-er prosent-kodes hvis de skal brukes bokstavelig:

Generelle avgrensere: :, /, ?, #, [, ], @
Underavgrensere: !, $, &, ', (, ), *, +, ,, ;, =

I tillegg må alle ikke-ASCII-tegn, inkludert tegn i Unicode, kodes.

Hvordan fungerer URL-koding?

Kodingprosessen

Identifiser spesialtegn: Analyser URL-strengen og identifiser tegn som ikke er ureservede ASCII-tegn (bokstaver, sifre, -, ., _, ~).
Konverter til ASCII-kode: For hvert spesialtegn, hent dets ASCII- eller Unicode-kodepunkt.
Konverter til UTF-8 byte-sekvens (hvis nødvendig): For ikke-ASCII-tegn, kod tegnene til en eller flere byte ved hjelp av UTF-8-koding.
Konverter til heksadesimal: Konverter hver byte til dens to-sifrede heksadesimale ekvivalent.
Prefiks med prosent-tegn: Foran hver heksadesimale byte med et %-tegn.

Eksempel på koding

Tegn: ' ' (Mellomrom)
- ASCII-kode: 32
- Heksadesimal: 20
- URL-kodet: %20
Tegn: 'é'
- UTF-8-koding: 0xC3 0xA9
- URL-kodet: %C3%A9

Grensekaser å vurdere

Unicode-tegn: Ikke-ASCII-tegn må kodes i UTF-8 og deretter prosent-kodes.
Allerede kodede prosent-tegn: Prosent-tegn som er en del av prosent-koding må ikke kodes på nytt.
Reserverte tegn i spørringsstrenger: Enkelte tegn har spesielle betydninger i spørringsstrenger og bør kodes for å forhindre endring av strukturen.

URL-dekoding

Hva er URL-dekoding?

URL-dekoding er den motsatte prosessen av URL-koding. Den konverterer prosent-kodede tegn tilbake til sin opprinnelige form, noe som gjør URL-en lesbar og forståelig for mennesker og systemer.

Dekodingsprosess

Identifiser prosent-koding sekvenser: Finn alle %-symboler etterfulgt av to heksadesimale sifre i URL-strengen.
Konverter heksadesimal til byte: Oversett hver heksadesimalverdi til sin tilsvarende byte.
Dekod UTF-8 byte (hvis nødvendig): For flerbyte-sekvenser, kombiner byte og dekod dem ved hjelp av UTF-8-koding for å få det opprinnelige tegnet.
Erstatt kodede sekvenser: Erstatt de prosent-kodede sekvensene med de dekodede tegnene.

Eksempel på dekoding

Kodet: hello%20world
- %20 oversettes til et mellomrom ' '
- Dekodet: hello world
Kodet: J%C3%BCrgen
- %C3%A4 oversettes til 'ü' i UTF-8
- Dekodet: Jürgen

Viktigheten av URL-dekoding

URL-dekoding er avgjørende når man behandler brukerinput fra URL-er, leser spørringsparametere eller tolker data mottatt fra webforespørsel. Det sikrer at informasjonen som hentes fra en URL er i sin rette, tiltenkte form.

Bruksområder

Webutvikling

Spørringsparametere: Koding av brukerinput i spørringsparametere for å forhindre feil eller sikkerhetsproblemer.
Sti-parametere: Trygg inkludering av dynamiske data i URL-stier.

Datatransmisjon

API-er og webtjenester: Sikre at data sendt til API-er er riktig formatert.
Internasjonalisering: Støtte URL-er med tegn fra forskjellige språk.

Sikkerhet

Forebygge injeksjonsangrep: Koding av input for å redusere risikoen for cross-site scripting (XSS) og andre injeksjonsangrep.

Alternativer

Selv om URL-koding er essensiell, finnes det scenarier der andre kodingsmetoder kan være mer hensiktsmessige:

Base64-koding: Brukt for å kode binære data i URL-er eller når høyere informasjonsdensitet er nødvendig.
UTF-8-koding uten prosent-koding: Noen systemer bruker direkte UTF-8-koding, men dette kan føre til problemer hvis det ikke håndteres riktig.

Vurder spesifikasjonene til applikasjonen din for å velge den mest passende kodingsmetoden.

Historie

URL-koding ble introdusert med de tidlige spesifikasjonene av URL- og URI (Uniform Resource Identifier) standardene på 1990-tallet. Behovet for en konsekvent måte å kode spesialtegn på oppsto fra de mangfoldige systemene og tegnsettene som ble brukt over hele verden.

Nøkkelmilepæler inkluderer:

RFC 1738 (1994): Definerte URL-er og introduserte prosent-koding.
RFC 3986 (2005): Oppdaterte URI-syntaksen, og finjusterte reglene for koding.

Over tid har URL-koding blitt integrert i webteknologier, og sikrer pålitelig kommunikasjon på tvers av forskjellige systemer og plattformer.

Kodeeksempler

Her er eksempler på hvordan man utfører URL-koding i forskjellige programmeringsspråk:

1' Excel VBA Eksempel
2Function URLEncode(ByVal Text As String) As String
3    Dim i As Integer
4    Dim CharCode As Integer
5    Dim Char As String
6    Dim EncodedText As String
7
8    For i = 1 To Len(Text)
9        Char = Mid(Text, i, 1)
10        CharCode = AscW(Char)
11        Select Case CharCode
12            Case 48 To 57, 65 To 90, 97 To 122, 45, 46, 95, 126 ' 0-9, A-Z, a-z, -, ., _, ~
13                EncodedText = EncodedText & Char
14            Case Else
15                If CharCode < 0 Then
16                    ' Håndtere Unicode-tegn
17                    EncodedText = EncodedText & "%" & Hex(65536 + CharCode)
18                Else
19                    EncodedText = EncodedText & "%" & Right("0" & Hex(CharCode), 2)
20                End If
21        End Select
22    Next i
23    URLEncode = EncodedText
24End Function
25
26' Bruk:
27' =URLEncode("https://example.com/?name=Jürgen")
28

1% MATLAB Eksempel
2function encodedURL = urlEncode(url)
3    import java.net.URLEncoder
4    encodedURL = char(URLEncoder.encode(url, 'UTF-8'));
5end
6
7% Bruk:
8% encodedURL = urlEncode('https://example.com/?name=Jürgen');
9

1## Ruby Eksempel
2require 'uri'
3
4url = 'https://example.com/path?query=hello world&name=Jürgen'
5encoded_url = URI::DEFAULT_PARSER.escape(url)
6puts encoded_url
7## Utdata: https://example.com/path?query=hello%20world&name=J%C3%BCrgen
8

1// Rust Eksempel
2use url::form_urlencoded;
3
4fn main() {
5    let url = "https://example.com/path?query=hello world&name=Jürgen";
6    let encoded_url = percent_encode(url);
7    println!("{}", encoded_url);
8    // Utdata: https://example.com/path%3Fquery%3Dhello%20world%26name%3DJ%C3%BCrgen
9}
10
11fn percent_encode(input: &str) -> String {
12    use percent_encoding::{utf8_percent_encode, NON_ALPHANUMERIC};
13    utf8_percent_encode(input, NON_ALPHANUMERIC).to_string()
14}
15

1## Python Eksempel
2import urllib.parse
3
4url = 'https://example.com/path?query=hello world&name=Jürgen'
5encoded_url = urllib.parse.quote(url, safe=':/?&=')
6print(encoded_url)
7## Utdata: https://example.com/path?query=hello%20world&name=J%C3%BCrgen
8

1// JavaScript Eksempel
2const url = 'https://example.com/path?query=hello world&name=Jürgen';
3const encodedURL = encodeURI(url);
4console.log(encodedURL);
5// Utdata: https://example.com/path?query=hello%20world&name=J%C3%BCrgen
6

1// Java Eksempel
2import java.net.URLEncoder;
3import java.nio.charset.StandardCharsets;
4
5public class URLEncodeExample {
6    public static void main(String[] args) throws Exception {
7        String url = "https://example.com/path?query=hello world&name=Jürgen";
8        String encodedURL = URLEncoder.encode(url, StandardCharsets.UTF_8.toString());
9        // Erstatt "+" med "%20" for mellomrom
10        encodedURL = encodedURL.replace("+", "%20");
11        System.out.println(encodedURL);
12        // Utdata: https%3A%2F%2Fexample.com%2Fpath%3Fquery%3Dhello%20world%26name%3DJ%C3%BCrgen
13    }
14}
15

1// C# Eksempel
2using System;
3using System.Net;
4
5class Program
6{
7    static void Main()
8    {
9        string url = "https://example.com/path?query=hello world&name=Jürgen";
10        string encodedURL = Uri.EscapeUriString(url);
11        Console.WriteLine(encodedURL);
12        // Utdata: https://example.com/path?query=hello%20world&name=J%C3%BCrgen
13    }
14}
15

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

1// Go Eksempel
2package main
3
4import (
5    "fmt"
6    "net/url"
7)
8
9func main() {
10    urlStr := "https://example.com/path?query=hello world&name=Jürgen"
11    encodedURL := url.QueryEscape(urlStr)
12    fmt.Println(encodedURL)
13    // Utdata: https%3A%2F%2Fexample.com%2Fpath%3Fquery%3Dhello+world%26name%3DJ%25C3%25BCrgen
14}
15

1// Swift Eksempel
2import Foundation
3
4let url = "https://example.com/path?query=hello world&name=Jürgen"
5if let encodedURL = url.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed) {
6    print(encodedURL)
7    // Utdata: https://example.com/path?query=hello%20world&name=J%C3%BCrgen
8}
9

1## R Eksempel
2url <- "https://example.com/path?query=hello world&name=Jürgen"
3encodedURL <- URLencode(url, reserved = TRUE)
4print(encodedURL)
5## Utdata: https://example.com/path?query=hello%20world&name=J%C3%BCrgen
6

Merk: Utdata kan variere noe avhengig av hvordan hvert språk håndterer reserverte tegn og mellomrom (f.eks. koding av mellomrom som %20 eller +).

SVG-diagram over URL-kodingprosessen

Sikkerhetsbetraktninger

Riktig URL-koding og dekoding er avgjørende for sikkerheten:

Forebygge injeksjonsangrep: Koding av brukerinput bidrar til å forhindre at ondsinnet kode blir utført, og reduserer risikoen for cross-site scripting (XSS) og SQL-injeksjon.
Dataintegritet: Sikrer at data overføres uten endringer eller korrupsjon.
Overholdelse av standarder: Å følge kodingsstandarder unngår interoperabilitetsproblemer mellom systemer.

Referanser

RFC 3986 - Uniform Resource Identifier (URI): https://tools.ietf.org/html/rfc3986
Hva er URL-koding og hvordan fungerer det? https://www.urlencoder.io/learn/
Prosent-koding: https://en.wikipedia.org/wiki/Percent-encoding
URL-standard: https://url.spec.whatwg.org/
URI.escape er foreldet: https://stackoverflow.com/questions/2824126/why-is-uri-escape-deprecated

Konklusjon

URL-koding er en essensiell del av webutvikling og internettkommunikasjon. Ved å konvertere spesialtegn til et trygt format, sikrer det at URL-er tolkes riktig av nettlesere og servere, og opprettholder integriteten og sikkerheten til datatransmisjon. Dette verktøyet gir en praktisk måte å eskapere spesialtegn i URL-ene dine, noe som forbedrer kompatibiliteten og forhindrer potensielle feil eller sikkerhetsproblemer.

Whiz Tools