Proste zaciemnianie ciągów znaków w .NET?

A może coś klasycznego (z nowoczesnym akcentem)?

public static string Caesar(this string source, Int16 shift)

{

 var maxChar = Convert.ToInt32(char.MaxValue);

 var minChar = Convert.ToInt32(char.MinValue); var buffer = source.ToCharArray(); for (var i = 0; i < buffer.Length; i++)

 {

 var shifted = Convert.ToInt32(buffer[i]) + shift; if (shifted > maxChar)

 {

 shifted -= maxChar;

 }

 else if (shifted < minChar)

 {

 shifted += maxChar;

 } buffer[i] = Convert.ToChar(shifted);

 } return new string(buffer);

}

Których oczywiście byś użył w ten sposób

var plain = "Wibble";

var caesered = plain.Caesar(42);

var newPlain = caesered.Caesar(-42);

Jest szybki, twój klucz to tylko

Int16

i nie pozwoli przypadkowemu obserwatorowi na skopiowanie wklejonej wartości, ale nie jest bezpieczny.

Co powiesz na:

Convert.ToBase64String(Encoding.UTF8.GetBytes(myString));

i jej apel:

Encoding.UTF8.GetString(Convert.FromBase64String(myObfuscatedString));

pod warunkiem, że nie masz nic przeciwko zwiększeniu długości struny

Spróbuj zaszyfrować go na przykład za pomocą AES, jeśli znasz klucz szyfrowania na innym komputerze, możesz go łatwo odszyfrować
http://msdn.microsoft.com/en-us/ library/system.security.cryptography.aes (v = vs.100). aspx
http://msdn.microsoft.com/en-u ... y.aes(v=vs.100).aspx
Istnieje wiele przykładów kodu. Na przykład znalazłem ten post korzystając z szybkiego wyszukiwania, chociaż ma tylko 128 bitów, myślę, że powinien załatwić sprawę
Korzystanie z szyfrowania AES w C #
https://coderoad.ru/273452/

Zainspirowała mnie odpowiedź @ Jodrell, a oto moja alternatywna wersja. Jedyną prawdziwą różnicą jest to, że używam operatora modulo zamiast konstrukcji if-then-else.
A jeśli tak jak ja nigdy wcześniej nie słyszałeś o szyfrze Cezara, oto link:
https://en.wikipedia.org/wiki/ Caesar_cipher
https://en.wikipedia.org/wiki/Caesar_cipher

public static partial class MString

 {

 .../// <summary>

/// Method to perform a very simple (and classical) encryption for a string. This is NOT at 

/// all secure, it is only intended to make the string value non-obvious at a first glance.

///

/// The shiftOrUnshift argument is an arbitrary "key value", and must be a non-zero integer 

/// between -65535 and 65535 (inclusive). To decrypt the encrypted string you use the negative 

/// value. For example, if you encrypt with -42, then you decrypt with +42, or vice-versa.

///

/// This is inspired by, and largely based on, this:

/// [url=https://stackoverflow.com/a/13026595/253938]https://stackoverflow.com/a/13026595/253938[/url]

/// </summary>

/// <param name="inputString">string to be encrypted or decrypted, must not be null</param>

/// <param name="shiftOrUnshift">see above</param>

/// <returns>encrypted or decrypted string</returns>

 public static string CaesarCipher(string inputString, int shiftOrUnshift)

 {

// Check C# is still C#

 Debug.Assert(char.MinValue == 0 && char.MaxValue == UInt16.MaxValue); const int C64K = UInt16.MaxValue + 1;// Check the arguments

 if (inputString == null)

 throw new ArgumentException("Must not be null.", "inputString");

 if (shiftOrUnshift == 0)

 throw new ArgumentException("Must not be zero.", "shiftOrUnshift");

 if (shiftOrUnshift <= -C64K || shiftOrUnshift >= C64K)

 throw new ArgumentException("Out of range.", "shiftOrUnshift");// Perform the Caesar cipher shifting, using modulo operator to provide wrap-around

 char[] charArray = new char[inputString.Length];

 for (int i = 0; i < inputString.Length; i++)

 {

 charArray[i] = 

 Convert.ToChar((Convert.ToInt32(inputString[i]) + shiftOrUnshift + C64K) % C64K);

 }// Return the result as a new string

 return new string(charArray);

 } ...

 }

I trochę kodu testowego:

// Test CaesarCipher() method

 const string CHelloWorld = "Hello world!";

 const int CCaesarCipherKey = 42;

 string caesarCiphered = MString.CaesarCipher(CHelloWorld, CCaesarCipherKey);

 if (MString.CaesarCipher(caesarCiphered, -CCaesarCipherKey) != CHelloWorld)

 throw new Exception("Oh no!");