Develop Reference

Convert Base64 string to image and save it

I want to save base64 image to a folder in application, but I have a problem in code. it gives an error as below,
Message = "Invalid length for a Base-64 char array or string."
In my code;
public static string UpdateUser(int refuser, string name, string surname,string base64)
{
string result = "FAILED";
var photo = "";
if (base64!=null && base64!="")
{
string mediaPath = Extend.GetXmlConfigParameter("media", "path")+"User\\";
string mediaName = Guid.NewGuid().ToString();
base64 = base64.Replace("data:image/png;base64,", "");
base64 = base64.Replace("data:image/jpg;base64,", "");
base64 = base64.Replace("data:image/gif;base64,", "");
base64 = base64.Replace("data:image/jpeg;base64,", "");
string filePath = mediaPath + mediaName + ".png";
try
{
byte[] bytes = Convert.FromBase64String(base64);
Image image;
using (MemoryStream ms = new MemoryStream(bytes))
{
image = Image.FromStream(ms);
}
image.Save(filePath, System.Drawing.Imaging.ImageFormat.Png);
//File.WriteAllBytes(filePath, Convert.FromBase64String(base64));
photo = mediaName + ".png";
}
catch(Exception ex)
{
Logger.LogError(ex.Message, ex.StackTrace);
return result;
}
}
try
{
DataSet ds = Database.GetDataSet(con, Database.CreateSpQuery("mobile_user_update ",
new List<object> {
refuser,
name,
surname,
photo
}));
if (!Database.IsDataSetValid(ds))
return null;
result = Database.GetString(ds.Tables[0].Rows[0]["Result"]);
}
catch (Exception ex)
{
Logger.LogError(ex.Message, ex.StackTrace);
}
return result;
}
when i try to convert to byte array with below step in code
byte[] bytes = Convert.FromBase64String(base64);
I take this error. my example base64 string is
data:image/png;base64,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
How can I solve this problem.
Thanks in advance.

It looks that you getting this base64 string through url. If so, you should encode it , before it send to the client.
HttpUtility.UrlEncode(base64string)

c# base64 encoding. Invalid length error on decrpytion

I'm trying to decrypt a string which is also base64 encoded, but I am receiving an when I try to decrypt the string.
The error I am receiving is:
{System.FormatException: Invalid length for a Base-64 char array or string.
at this line in the decrypt function below:
MemoryStream ms = new MemoryStream(Convert.FromBase64String(inString));
Encrpyt/Decrypt functions:
//ENCRYPT
public static bool stringEncrypt(string inString,ref string outstring)
{
try
{
if(String.IsNullOrEmpty(inString)){return false;}
DESCryptoServiceProvider provider = new DESCryptoServiceProvider();
MemoryStream ms = new MemoryStream();
CryptoStream cs = new CryptoStream(ms,provider.CreateEncryptor(PWbytes,PWbytes),CryptoStreamMode.Write);
StreamWriter sw = new StreamWriter(cs);
sw.Write(inString);
sw.Flush();
cs.FlushFinalBlock();
sw.Flush();
outstring = Convert.ToBase64String(ms.GetBuffer(),0,(int)ms.Length);
return true;
}
catch(Exception ex)
{
clsCommonBase.AppendToExceptionFile("Encrypt : " + ex.Message);
return false;
}
}
//DECRPYT
public static bool stringDecrypt(string inString,ref string outstring)
{
try
{
if(String.IsNullOrEmpty(inString)){return false;};
DESCryptoServiceProvider provider = new DESCryptoServiceProvider();
MemoryStream ms = new MemoryStream(Convert.FromBase64String(inString));
CryptoStream cs = new CryptoStream(ms, provider.CreateDecryptor(PWbytes,PWbytes),CryptoStreamMode.Read);
StreamReader sr = new StreamReader(cs);
outstring = sr.ReadToEnd();
return true;
}
catch(Exception ex)
{
clsCommonBase.AppendToExceptionFile("Decrypt : " + ex.Message);
return false;
}
}

Solved using the simple solution in the following link
How do I encode and decode a base64 string?
Also added some code in the encoding function to ensure the plain text string will be converted to a valid length base64 string.
Code:
public static string Base64Encode(string plainText)
{
//check plain text string and pad if needed
int mod4 = plainText.Length % 4;
if (mod4 > 0)
{
plainText += new string('=', 4 - mod4);
}
//convert to base64 and return
var plainTextBytes = System.Text.Encoding.UTF8.GetBytes(plainText);
return System.Convert.ToBase64String(plainTextBytes);
}
public static string Base64Decode(string base64EncodedData)
{
//decode base64 and return as string
var base64EncodedBytes = System.Convert.FromBase64String(base64EncodedData);
return System.Text.Encoding.UTF8.GetString(base64EncodedBytes);
}

Error in converting base64 string to image (description inside)

I've a task to convert a base64 string to image in asp.net c#, I'm using the following code,
private static bool SaveImage(string path, string link, string name)
{
bool result = true;
if (link.StartsWith("data:image/jpeg;base64,"))
{
try
{
string intImg = path + "/" + name + ".jpg";
System.Drawing.Image bmpFromString = Base64StringToBitmap(link.Replace("data:image/jpeg;base64,",""));
bmpFromString.Save(intImg, ImageFormat.Jpeg);
result = true;
}
catch (Exception)
{
result = false;
}
}
return result;
}
public static System.Drawing.Image Base64StringToBitmap(string base64String)
{
System.Drawing.Image bmpReturn = null;
//string converted = base64String.Replace('-', '+');
//converted = converted.Replace('_', '/');
byte[] byteBuffer = Convert.FromBase64String(base64String);
using (MemoryStream memoryStream = new MemoryStream(byteBuffer))
{
//finalImage = System.Drawing.Image.FromStream(ms);
memoryStream.Position = 0;
bmpReturn = System.Drawing.Image.FromStream(memoryStream);
memoryStream.Close();
byteBuffer = null;
}
return bmpReturn;
}
this is the base64 string
data:image/jpeg;base64,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
The error message is,
Error Message 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 can't understand what is wrong with this method, would somebody correct me if i'm wrong.

The base64 string you have is not the correct length. Base64 strings should be in blocks of four characters, but you have 4657 characters, or 1164.25 blocks.
Conclusion: You've mistakenly doubled the last 8 in your string. Removing this, you get an image of three people on a yellow background, with a small gray border on the bottom.

You can use:
user.Image.Replace(#"data:image/jpeg;base64,", "");

Help me, throwing exception error in decoding code. help needed

To encode a string
Code:
public string base64Encode(string data)
{
try
{
byte[] encData_byte = new byte[data.Length];
encData_byte = System.Text.Encoding.UTF8.GetBytes(data);
string encodedData = Convert.ToBase64String(encData_byte);
return encodedData;
}
catch(Exception e)
{
throw new Exception("Error in base64Encode" + e.Message);
}
}
and to decode
Code:
public string base64Decode(string data)
{
try
{
System.Text.UTF8Encoding encoder = new System.Text.UTF8Encoding();
System.Text.Decoder utf8Decode = encoder.GetDecoder();
byte[] todecode_byte = Convert.FromBase64String(data);
int charCount = utf8Decode.GetCharCount(todecode_byte, 0, todecode_byte.Length);
char[] decoded_char = new char[charCount];
utf8Decode.GetChars(todecode_byte, 0, todecode_byte.Length, decoded_char, 0);
string result = new String(decoded_char);
return result;
}
catch(Exception e)
{
throw new Exception("Error in base64Decode" + e.Message);
}
}

You haven't said what error you're getting, but surely your second code should simply be:
return Encoding.UTF8.GetString(Convert.FromBase64String(data));
You don't need to create a new UTF8Encoding
You don't need to worry about decoders explicitly
Additionally, your exception handling is nasty - the stack trace would already show where the error occurs, but by catching it and rethrowing just Exception you're hiding the original exception type. Just remove the try/catch blocks from both your methods. (And rename them to match .NET naming conventions.)
Basically, your code can look as simple as this:
public static string Base64AndUtf8Encode(string text)
{
return Convert.ToBase64String(Encoding.UTF8.GetBytes(text));
}
public static string Base64AndUtf8Decode(string base64)
{
return Encoding.UTF8.GetString(Convert.FromBase64String(base64));
}
Obviously you can split it into separate statements if you want, but it can stil be pretty short:
public static string Base64AndUtf8Encode(string text)
{
byte[] bytes = Encoding.UTF8.GetBytes(text);
return Convert.ToBase64String(bytes);
}
public static string Base64AndUtf8Decode(string base64)
{
bytes[] bytes = Convert.FromBase64String(base64);
return Encoding.UTF8.GetString(bytes);
}

Unicode-to-string conversion in C#

How can I convert a Unicode value to its equivalent string?
For example, I have "రమెశ్", and I need a function that accepts this Unicode value and returns a string.
I was looking at the System.Text.Encoding.Convert() function, but that does not take in a Unicode value; it takes two encodings and a byte array.
I bascially have a byte array that I need to save in a string field and then come back later and convert the string first back to a byte array.
So I use ByteConverter.GetString(byteArray) to save the byte array to a string, but I can't get it back to a byte array.

Use .ToString();:
this.Text = ((char)0x00D7).ToString();

Try the following:
byte[] bytes = ...;
string convertedUtf8 = Encoding.UTF8.GetString(bytes);
string convertedUtf16 = Encoding.Unicode.GetString(bytes); // For UTF-16
The other way around is using `GetBytes():
byte[] bytesUtf8 = Encoding.UTF8.GetBytes(convertedUtf8);
byte[] bytesUtf16 = Encoding.Unicode.GetBytes(convertedUtf16);
In the Encoding class, there are more variants if you need them.

To convert a string to a Unicode string, do it like this: very simple... note the BytesToString function which avoids using any inbuilt conversion stuff. Fast, too.
private string BytesToString(byte[] Bytes)
{
MemoryStream MS = new MemoryStream(Bytes);
StreamReader SR = new StreamReader(MS);
string S = SR.ReadToEnd();
SR.Close();
return S;
}
private string ToUnicode(string S)
{
return BytesToString(new UnicodeEncoding().GetBytes(S));
}

UTF8Encoding Class
UTF8Encoding uni = new UTF8Encoding();
Console.WriteLine( uni.GetString(new byte[] { 1, 2 }));

There are different types of encoding. You can try some of them to see if your bytestream get converted correctly:
System.Text.ASCIIEncoding encodingASCII = new System.Text.ASCIIEncoding();
System.Text.UTF8Encoding encodingUTF8 = new System.Text.UTF8Encoding();
System.Text.UnicodeEncoding encodingUNICODE = new System.Text.UnicodeEncoding();
var ascii = string.Format("{0}: {1}", encodingASCII.ToString(), encodingASCII.GetString(textBytesASCII));
var utf = string.Format("{0}: {1}", encodingUTF8.ToString(), encodingUTF8.GetString(textBytesUTF8));
var unicode = string.Format("{0}: {1}", encodingUNICODE.ToString(), encodingUNICODE.GetString(textBytesCyrillic));
Have a look here as well: http://george2giga.com/2010/10/08/c-text-encoding-and-transcoding/.

var ascii = $"{new ASCIIEncoding().ToString()}: {((ASCIIEncoding)new ASCIIEncoding()).GetString(textBytesASCII)}";
var utf = $"{new UTF8Encoding().ToString()}: {((UTF8Encoding)new UTF8Encoding()).GetString(textBytesUTF8)}";
var unicode = $"{new UnicodeEncoding().ToString()}: {((UnicodeEncoding)new UnicodeEncoding()).GetString(textBytesCyrillic)}";

Wrote a cycle for converting unicode symbols in string to UTF8 letters:
string stringWithUnicodeSymbols = #"{""id"": 10440119, ""photo"": 10945418, ""first_name"": ""\u0415\u0432\u0433\u0435\u043d\u0438\u0439""}";
var splitted = Regex.Split(stringWithUnicodeSymbols, #"\\u([a-fA-F\d]{4})");
string outString = "";
foreach (var s in splitted)
{
try
{
if (s.Length == 4)
{
var decoded = ((char) Convert.ToUInt16(s, 16)).ToString();
outString += decoded;
}
else
{
outString += s;
}
}
catch (Exception e)
{
outString += s;
}
}