rawurlencode - .net UrlEncode-problema minúsculo

urlencode php

Question

Estoy trabajando en una transferencia de datos para una puerta de enlace que requiere que envíe datos en formato UrlEncoded. Sin embargo, UrlEncode de .net crea etiquetas en minúsculas y rompe la transferencia (Java crea mayúsculas).

¿Alguna idea de cómo puedo forzar .net para hacer mayúsculas UrlEncoding?

actualización1:

.net out:

dltz7UK2pzzdCWJ6QOvWXyvnIJwihPdmAioZ%2fENVuAlDQGRNCp1F

vs Java:

dltz7UK2pzzdCWJ6QOvWXyvnIJwihPdmAioZ%2FENVuAlDQGRNCp1F

(es una cadena 3DES base64d, necesito mantener su caso).

Answer 1

Aquí está mi conversión de VB.NET de la versión pública OAuth.OAuthBase de UrlEncode (para .NET 2.0 / 3.5):

'' MEH: Made this ReadOnly because the range of unreserved characters is specified in the OAuth spec. Inheritors ought not change it.
Protected Shared ReadOnly unreservedChars As String = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_.~"
'' MEH: Added. These are the other characters HttpUtility.UrlEncode does not convert to percent encoding itself.
Protected Shared ReadOnly reservedChars As String = " !''()*" '' If this moves to .NET 4+ '' can be removed.
'''''' <summary>
'''''' This is a different Url Encode implementation since the default .NET one outputs the percent encoding in lower case.
'''''' While this is not a problem with the percent encoding spec, it is used in upper case throughout OAuth.
'''''' Also the OAuth spec explicitly requires some characters to be unencoded.
'''''' </summary>
'''''' <param name="Value">The value to Url encode</param>
'''''' <returns>Returns a Url encoded string</returns>
'''''' <revisionhistory>
'''''' 140313 MEH Fixed to correctly cater for any characters between %80 and %ff, and the O(n^2) IndexOf call.
'''''' </revisionhistory>
Public Shared Function UrlEncode(ByVal Value As String) As String
Dim result, buffer As New StringBuilder()
For Each symbol As Char In Value
If unreservedChars.IndexOf(symbol) <> -1 Then
UrlEncodeAppendClear(result, buffer).Append(symbol)
ElseIf reservedChars.IndexOf(symbol) = -1 Then
''some symbols produce 2 or more octets in UTF8 so the system urlencoder must be used to get the correct data
'' but this is best done over a full sequence of characters, so just store this one in a buffer.
buffer.Append(symbol)
Else '' These characters are not converted to percent encoding by UrlEncode.
UrlEncodeAppendClear(result, buffer).AppendFormat(Globalization.CultureInfo.InvariantCulture, "%{0:X2}", AscW(symbol))
End If
Next
UrlEncodeAppendClear(result, buffer)
Return result.ToString()
End Function
Private Shared percentHex As New RegularExpressions.Regex("(%[0-9a-f][0-9a-f])", RegularExpressions.RegexOptions.Compiled)
'''''' <summary>
'''''' Actually performs the UrlEncode on any buffered characters, ensuring the resulting percents are uppercased and clears the buffer.
'''''' </summary>
''''''
'''''' <param name="Result">The result of the UrlEncode is appended here.</param>
'''''' <param name="Buffer">The current buffer of characters to be encoded. Cleared on return.</param>
''''''
'''''' <returns>The <paramref name="Result">Result</paramref>, as passed in, with the UrlEncoding of the <paramref name="Buffer">buffer of characters</paramref> appended.</returns>
''''''
'''''' <remarks>Would like to be an extension method.</remarks>
''''''
'''''' <revisionhistory>
'''''' 140313 MEH Created.
'''''' </revisionhistory>
Private Shared Function UrlEncodeAppendClear(ByVal Result As StringBuilder, ByVal Buffer As StringBuilder) As StringBuilder
If Buffer.Length > 0 Then
Result.Append(percentHex.Replace(HttpUtility.UrlEncode(Buffer.ToString), Function(c) c.Value.ToUpperInvariant()))
Buffer.Length = 0
End If
Return Result
End Function

Answer 2

Creo que estás atascado con lo que C # te da, y obtener errores sugiere una función de UrlDecode mal implementada en el otro extremo.

Dicho esto, solo deberías recorrer la cadena y en mayúsculas solo los dos caracteres siguiendo un signo de%. Esto mantendrá intactos los datos de tu base64 al dar masajes a los caracteres codificados en el formato correcto:

public static string UpperCaseUrlEncode(string s)
{
char[] temp = HttpUtility.UrlEncode(s).ToCharArray();
for (int i = 0; i < temp.Length - 2; i++)
{
if (temp[i] == ''%'')
{
temp[i + 1] = char.ToUpper(temp[i + 1]);
temp[i + 2] = char.ToUpper(temp[i + 2]);
}
}
return new string(temp);
}

Answer 3

Este es el código que estoy usando en una aplicación de Twitter para OAuth ...

 Public Function OAuthUrlEncode(ByVal value As String) As String
Dim result As New StringBuilder()
Dim unreservedChars As String = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_.~"
For Each symbol As Char In value
If unreservedChars.IndexOf(symbol) <> -1 Then
result.Append(symbol)
Else
result.Append("%"c + [String].Format("{0:X2}", AscW(symbol)))
End If
Next
Return result.ToString()
End Function

¡Espero que esto ayude!

Answer 4

Esto es muy facil

Regex.Replace( encodedString, @"%[a-f/d]{2}", m => m.Value.ToUpper() )

Es decir, reemplaza todas las combinaciones de letras y cifras hexadecimales por mayúsculas

Answer 5

Reemplace la codificación de porcentaje en minúsculas de HttpUtility.UrlEnocde con una Regex:

static string UrlEncodeUpperCase(string value) {
value = HttpUtility.UrlEncode(value);
return Regex.Replace(value, "(%[0-9a-f][0-9a-f])", c => c.Value.ToUpper());
}
var value = "SomeWords 123 #=/ äöü";
var encodedValue = HttpUtility.UrlEncode(value);
// SomeWords+123+%23%3d%2f+%c3%a4%c3%b6%c3%bc
var encodedValueUpperCase = UrlEncodeUpperCase(value);
// now the hex chars after % are uppercase:
// SomeWords+123+%23%3D%2F+%C3%A4%C3%B6%C3%BC

Answer 6

Sé que esto es muy antiguo y tal vez esta solución no existía, pero esta fue una de las mejores páginas que encontré en google cuando trato de resolver esto.

System.Net.WebUtility.UrlEncode(posResult);

Esto codifica a mayúsculas.

Answer 7

si alguien más llega aquí en busca de un código perl o una PCRE (expresión regular compatible con perl) para resolver el problema, una expresión perl (candidata para la más corta posible) para convertir la codificación url a hexadecimal en minúscula es:

s/%(/X{2})/%/L$1/E/go

y al revés (minúsculas a mayúsculas)

s/%(/x{2})/%/U$1/E/go