How do I get the Image Path from below base 64 string?
data:image/jpeg;base64,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
I tried doing it this way:
byte[] data = Convert.FromBase64String(_model.Image_Array[i]);
fileName = Path.GetFileName(Encoding.UTF8.GetString(data));
path = Path.Combine(Server.MapPath("~/Images/Product/"), fileName);
file[i].SaveAs(path);
But it is throwing up below error:
The input is not a valid Base-64 string as it contains a non-base 64 character, more than two padding characters, or an illegal character among the padding characters.
Related
I am trying to decode the following Base64 string that i'm getting from a url like so:
string msgFromUrl = "j3oaCbiwIfZF1QFa%2FHkMaW5lVpnOMBsA5wYI";
byte[] data = Convert.FromBase64String(msgFromUrl);
string decoded = Encoding.UTF8.GetString(data);
Console.WriteLine(decoded);
I am getting an error on the string that i need to decode. The error i'm getting is:
The input is not a valid Base-64 string as it contains a non-base 64 character, more than two padding characters, or an illegal character among the padding characters.
I have realised that there is a percentage symbol in the string and when i try remove it i come short of the valid length of Base64 char. Since i'm retrieving this from a url, could there be anything hidden or do i have to do more than i have done in order to decode the encoded string?
Thank you .
I tried to decode a following base64 string in C#:
PGlmcmFtZSBzcmM9Imh0dHA6Ly9lbWJlZC5yZWR0dWJlLmNvbS8\/aWQ9Mzg1NjAmYmdjb2x
vcj0wMDAwMDAiIGZyYW1lYm9yZGVyPSIwIiB3aWR0aD0iNDM0IiBoZWlnaHQ9IjM0NCIgc2Nyb2xsaW5n
PSJubyIgYWxsb3dmdWxsc2NyZWVuPjwvaWZyYW1lPg==
But i'm getting an error:
The input is not a valid Base-64 string as it contains a non-base 64 character, more than two padding characters, or an illegal character among the padding characters.
Even if i remove last
=
in the string above but still the same error.
Here is the code i use:
byte[] decodedBytes = Convert.FromBase64String(embedCode);
string decodedText = Encoding.UTF8.GetString(decodedBytes);
Why is that?
Thank you.
the correct Base64String is:
PGlmcmFtZSBzcmM9Imh0dHA6Ly9lbWJlZC5yZWR0dWJlLmNvbS8/aWQ9Mzg1NjAmYmdjb2x
vcj0wMDAwMDAiIGZyYW1lYm9yZGVyPSIwIiB3aWR0aD0iNDM0IiBoZWlnaHQ9IjM0NCIgc2Nyb2xsaW5n
PSJubyIgYWxsb3dmdWxsc2NyZWVuPjwvaWZyYW1lPg==
Well this is not a valid Base64String. Base64String can not have \ character. remove this character and it will work
I'm trying to remove a dependence on System.Web.dll from a Web API project, but have stumbled on a call to HttpServerUtility.UrlTokenEncode(byte[] input) (and its corresponding decode method) that I don't know what to replace with to ensure backwards compatibility. The documentation says that this method
Encodes a byte array into its equivalent string representation using base 64 digits, which is usable for transmission on the URL.
I tried substituting with Convert.ToBase64String(byte[] input) (and its corresponding decode method), which is very similarly described in the docs:
Converts an array of 8-bit unsigned integers to its equivalent string representation that is encoded with base-64 digits.
However, they don't seem to be entirely equivalent; when using Convert.FromBase64String(string input) to decode a string encoded with HttpServerUtility, I get an exception stating
The input is not a valid Base-64 string as it contains a non-base 64 character, more than two padding characters, or an illegal character among the padding characters.
What is the difference between these two conversion utilities? What's the correct way to remove this dependence on System.Web.HttpServerUtility?
Some users have suggested that this is a duplicate of this one, but I disagree. That question is about base-64-encoding a string in a url-safe manner in general, but I need to reproduce the exact behavior of HttpServerUtility but without a dependency on System.Web.
I took DGibbs on their word and Used the Source. It turns out the following happens in the HttpServerUtility methods:
Encoding to Base64
Use System.Convert to convert the input to Base64.
Replace + by - and / by _. Example: Foo+bar/=== becomes Foo-bar_===.
Replace any number of = at the end of the string, with an integer denoting how many they were. Example: Foo-bar_=== becomes Foo-bar_3.
Decoding from Base64
Replace the digit at the end of the string by the same number of = signs. Example: Foo-bar_3 becomes Foo-bar_===.
Replace - by + and _ by /. Example: Foo-bar_=== becomes Foo+bar/===.
Use System.Convert to decode the preprocessed input from Base64.
HttpServerUtility.UrlTokenEncode(byte[] input) will encode a URL safe Base64 string. In Base64 +, / and = characters are valid, but they are not URL safe, this method will replace these characters whereas the Convert.ToBase64String(byte[] input) will not. You can probably drop the reference and do it yourself.
Usually, '+' is replaced with '-' and '/' with '_' padding '=' is just removed.
Accepted answer here gives a code example: How to achieve Base64 URL safe encoding in C#?
What I am generally trying to do, is to validate an id_token value obtained from an OpenID Connect provider (e.g. Google). The token is signed with the RSA algorithm and the public key is read from the Discovery document (the jwks_uri parameter). For example, Google keys are available here in the JWK format:
{
kty: "RSA",
alg: "RS256",
use: "sig",
kid: "38d516cbe31d4345819b786d4d227e3075df02fc",
n: "4fQxF6dFabDqsz9a9-XgVhDaadTBO4yBZkpUyUKrS98ZtpKIQRMLoph3bK9Cua828wwDZ9HHhUxOcbcUiNDUbubtsDz1AirWpCVRRauxRdRInejbGSqHMbg1bxWYfquKKQwF7WnrrSbgdInUZPv5xcHEjQ6q_Kbcsts1Nnc__8YRdmIGrtdTAcm1Ga8LfwroeyiF-2xn0mtWDnU7rblQI4qaXCwM8Zm-lUrpSUkO6E1RTJ1L0vRx8ieyLLOBzJNwxpIBNFolMK8-DYXDSX0SdR7gslInKCn8Ihd9mpI2QBuT-KFUi88t8TW4LsoWHAwlgXCRGP5cYB4r30NQ1wMiuQ",
e: "AQAB"
}
I am going to use the RSACryptoServiceProvider class for decoding the signature. To initialize it, I have to provide RSAParameters with the Modulus and Exponent values. These values are read from the above JWK as n and e correspondingly. According to the specification, these values are Base64urlUInt-encoded values:
The representation of a positive or zero integer value as the
base64url encoding of the value's unsigned big-endian representation
as an octet sequence. The octet sequence MUST utilize the minimum
number of octets needed to represent the value. Zero is represented
as BASE64URL(single zero-valued octet), which is "AA".
So, my question is how to decode these values to put them to RSAParameters? I tried decoding them as a common Base64url string (Convert.FromBase64String(modulusRaw)), but this obviously does not work and generates this error:
The input is not a valid Base-64 string as it contains a non-base 64
character, more than two padding characters, or an illegal character
among the padding characters.
RFC 7515 defines base64url encoding like this:
Base64 encoding using the URL- and filename-safe character set
defined in Section 5 of RFC 4648, with all trailing '='
characters omitted (as permitted by Section 3.2) and without the
inclusion of any line breaks, whitespace, or other additional
characters. Note that the base64url encoding of the empty octet
sequence is the empty string. (See Appendix C for notes on
implementing base64url encoding without padding.)
RFC 4648 defines "Base 64 Encoding with URL and Filename Safe Alphabet" as regular base64, but:
The padding may be omitted (as it is here)
Using - instead of + and _ instead of /
So to use regular Convert.FromBase64String, you just need to reverse that process:
static byte[] FromBase64Url(string base64Url)
{
string padded = base64Url.Length % 4 == 0
? base64Url : base64Url + "====".Substring(base64Url.Length % 4);
string base64 = padded.Replace("_", "/")
.Replace("-", "+");
return Convert.FromBase64String(base64);
}
It's possible that this code already exists somewhere in the framework, but I'm not aware of it.
Who ever comes here from Java: there are two methods in java.util.Base64:
getDecoder()
getUrlDecoder()
As you probably assumed: taking the second one does all the chars replacements for you already.
The following line of code runs fine in IIS Express:
Convert.FromBase64String("dmVoaWNsZUlkPTE0MTM=??");
But when run on my local IIS 8 server, it throws the following exception:
System.FormatException: The input is not a valid Base-64 string as it contains a non-base 64 character, more than two padding characters, or an illegal character among the padding characters.
Why is this happening?
The last two characters "??" are not valid in a base 64 string.
Have a read here: https://en.wikipedia.org/wiki/Base64
The string should end in an alphanumeric character or be padded with one or more = characters.
Edit — Decoding the string without the ? characters returns "vehicleId=1413", so I guess it's just a case of removing them.