Forenbeiträge von marsgk Ingesamt 1.439 Beiträge
Register klingt nach FastCall.
Dies erklärt auch, warum der Aufruf der Init-Methode funktioniert hat. Ohne Parameter sollte es zu stdcall "kompatibel" sein.
Btw.:
Bei CallingConvention.FastCall steht in der Doku:This calling convention is not supported.
Ich würde mal auf eine falsche CallingConvention tippen.
Zeig mal die genaue C Signatur der Methode und des structs.
Btw.: ein C long entspricht meistens einem C# int.
Du könntest mehrere Thread.Sleep(0) Statements einbauen. Aber eine Möglichkeit die Auslastung auf 20% zu begrenzen kenne ich nicht.
Das '+'-Zeichen ist bei UTF-7 ein spezielles Markerzeichen. => Dein Text ist nicht UTF-7 kodiert.
Probier mal Encoding.Default oder Latin-1.
Du kannst ja auf deinem Entwicklungsboard einen FT2232 von FTDI verwenden. Es gibt bereits fertige Treiber für USB von FTDI und du kannst die einzelnen Pins gezielt Ansteuern.
Für Handles solltest du IntPtr verwenden und nicht long.
Hallo herbivore!
Die ResourceWriter/Reader Klassen kenne ich, aber man muss ja nicht immer das Rad neu erfinden...
Aber danke für die Antwort.
lg
Hallo!
Kennt jemand ein Tool zum Erstellen/Bearbeiten von Resourcen-Dateien.
Dieses sollte über die Kommandozeile bedienbar sein(Automation) und auch mit Binärressourcen zurechtkommen.
Im Prinzip soetwas wie resgen mit der Möglichkeit auch byte[] und Image/Icon Einträge zu erstellen.
lg
Sonst wandle dein byte-Array in einen Hex-String um. Dann musst du auch nicht mehr UrlEncode aufrufen.
Versuch nicht das byte Array mittels Encoding in einen String umzuwandeln. Da gibts nur Fehler.
Das g.Transform kannst du gleich weglassen. Ich war nur zu faul...
Was du brauchst ist die ColorMatrix und das g.DrawImage(sourceImg, rect, 0, 0, sourceImg.Width, sourceImg.Height, GraphicsUnit.Pixel, attributes); Wobei du hier noch die Parameter anpassen musst.
OpenFileDialog.RestoreDirectory
- Ist dein Code Fehlerhaft
- Willst du wirklich 5 Queues haben, oder reicht dir eine?
- Was genau willst du eigentlich machen?
Ich habe dir mal folgende Methode von mir rauskopiert. Diese erzeugt ein spiegelverkehrtes, hab transparentes Bild mit einem Schattenverlauf.
private Image CreateMirrorImage(Image sourceImg, float angle, float opacity) {
Bitmap bitmap = new Bitmap(sourceImg.Width, sourceImg.Height);
ColorMatrix clr = new ColorMatrix();
ImageAttributes attributes = new ImageAttributes();
Rectangle rect = new Rectangle(0, -sourceImg.Height, sourceImg.Width, sourceImg.Height);
clr.Matrix33 = opacity / 100.0f;
attributes.SetColorMatrix(clr);
using (Graphics g = Graphics.FromImage(bitmap)) {
g.SmoothingMode = SmoothingMode.AntiAlias;
g.Transform = new Matrix(1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f);
g.DrawImage(sourceImg, rect, 0, 0, sourceImg.Width, sourceImg.Height, GraphicsUnit.Pixel, attributes);
using (Brush brush = new LinearGradientBrush(rect, Color.Transparent, Color.Black, angle, false)) {
g.FillRectangle(brush, rect);
}
}
return bitmap;
}
Zeig mal deinen Code zum auslesen.
Btw.: structs und ArrayList sind eher kontraproduktiv; verwende lieber Klassen.
Pcap funktioniert aber nur auf Paketebene.
Warum zeichnest du die beiden Bilder nicht einfach übereinander und überlässt GDI+ die Arbeit. Ist doch viel einfacher...
Die GlobalMemoryStatus-Signatur sollte so aussehen:
[DllImport("CoreDll.dll")]
public static extern void GlobalMemoryStatus
(
out MEMORYSTATUS lpBuffer
);
Hallo herbivore!
Bei 20 bytes Länge ist es wirklich egal ob der String jetzt um 100% länger oder nur um 33% länger ist...
Allerdings habe ich noch nie ein Programm angetroffen, dass einen Hash als Base64 kodiert ausgibt.
Ich habe dir den Code rauskopiert:
public static string ByteArrayToHexString(byte[] val) {
StringBuilder sBuild = new StringBuilder();
for (int i = 0; i < val.Length; i++) {
sBuild.AppendFormat("{0:X2}", val[i]);
}
return sBuild.ToString();
}
Ich habe jetzt das Programm umgeschrieben, sodass es auch als Komponente verwendet werden kann. Einfach den untenstehenden Code ins Projekt einfügen, oder die Dll nutzen.
Zur Verwendung:
void Main() {
CryptItComponent crypter = new CryptItComponent();//Verwendet AES; für andere Verfahren einfach den Names im Konstruktor als String übergeben.
Im einfachsten Fall müssen nur Key und IV gesetzt werden, damit gearbeitet werden kann.
string hexCodedIV = Console.ReadLine();
crypter.IV = CryptItComponent.HexStringToByteArray(hexCodedIV);
string hexCodedKey = Console.ReadLine();
crypter.Key= CryptItComponent.HexStringToByteArray(hexCodedKey);
//-----------------
// Erzeugt einen neuen Schlüssel + IV und gibt diesen aus.
crypter.GenerateIV();
hexCodedIV = CryptItComponent.ByteArrayToHexString(crypter.IV);
Console.WriteLine("IV: {0}", hexCodedIV);
crypter.GenerateKey();
hexCodedKey = CryptItComponent.ByteArrayToHexString(crypter.Key);
Console.WriteLine("Key: {0}", hexCodedKey);
}
Sobald zumindest Key und IV gesetzt sind, kann die Klasse wie folgt verwendet werden:
Zum verschlüsseln von Strings gibt es die Methode EncryptString(string text).
byte[] encryptedString = crypter.EncryptString("Hello world!");
string hexString = CryptItComponent.ByteArrayToHexString(encryptedString );
Console.WriteLine("Encrypted string: {0}", hexString);
string decryptedString = crypter.DecryptString(encryptedString);
Console.WriteLine("Decrypted string: {0}", decryptedString);
//oder
string decryptedString = crypter.DecryptString(CryptItComponent.HexStringToByteArray(encryptedString));
Console.WriteLine("Decrypted string: {0}", decryptedString);
Zum verschlüsseln eines byte-Arrays kann die Methode EncryptByteArray verwendet werden.
Dies funktioniert genauso wie bei einem string, nur dass statt string ein byte[] übergeben wird.
Um ganze Objektgraphen zu verschlüsseln, kann die Methode EnryptObject oder EncryptObjectToFile verwendet werden.
[Serializable]
public class Credentials {
public string url;
public string password;
public string userName;
}
[Serializable]
public class PasswordList {
private Hashtable innerSet = new Hashtable();
public Credentials this[string url] {
get {
return (Credentials)innerSet[url];
}
set{
innerSet[url] = value;
}
}
...
}
public class PasswordStorage {
public static void Main() {
CryptItComponent crypter = new CryptItComponent();
//Ask user for master password and IV
PasswordList list = new PasswordList();
list[@"www.mycsharp.de"] = ...
...
crypter.EncryptObjectToFile("passwords.dat", list);
...
list = (PasswordList )crypter.DecryptObjectFromFile("passwords.dat");
}
}
Zum Verschlüsseln von Dateien gibt es die Methode EncryptFile.
public static void Main() {
CryptItComponent crypter = new CryptItComponent();
//Ask user for master password and IV
crypter.EncryptFile("passwords.txt", "enryptedPWDs.dat");
...
crypter.DecryptFile("enryptedPWDs.dat", "passwords.txt");
}
Es gibt noch eine allgemeine Methode, EnryptStream, zum verschlüsseln, bei der von einem Stream gelesen wird und in einen Stream geschrieben wird.
using System;
using System.Text;
using System.IO;
using System.Security.Cryptography;
using System.Runtime.Serialization.Formatters.Binary;
public class CryptItComponent: IDisposable {
private SymmetricAlgorithm alg;
public CryptItComponent() {
alg = SymmetricAlgorithm.Create();
}
public CryptItComponent(string algName) {
alg = SymmetricAlgorithm.Create(algName);
}
public int BlockSize {
get {
return alg.BlockSize;
}
set {
alg.BlockSize = value;
}
}
public int FeedbackSize {
get {
return alg.FeedbackSize;
}
set {
alg.FeedbackSize = value;
}
}
public byte[] IV {
get {
return alg.IV;
}
set {
alg.IV = value;
}
}
public byte[] Key {
get {
return alg.Key;
}
set {
alg.Key = value;
}
}
public int KeySize {
get {
return alg.KeySize;
}
set {
alg.KeySize = value;
}
}
public KeySizes[] LegalBlockSizes {
get {
return alg.LegalBlockSizes;
}
}
public KeySizes[] LegalKeySizes {
get {
return alg.LegalKeySizes;
}
}
public CipherMode Mode {
get {
return alg.Mode;
}
set {
alg.Mode = value;
}
}
public PaddingMode Padding {
get {
return alg.Padding;
}
set {
alg.Padding = value;
}
}
public void GenerateIV() {
alg.GenerateIV();
}
public void GenerateKey() {
alg.GenerateKey();
}
public void Dispose() {
alg.Clear();
}
public byte[] EncryptString(string text) {
return EncryptString(text, Encoding.UTF8);
}
public string DecryptString(byte[] encryptedString) {
return DecryptString(encryptedString, Encoding.UTF8);
}
public byte[] EncryptString(string text, Encoding encoding) {
if (text == null) {
throw new ArgumentNullException("text");
}
if (encoding == null) {
throw new ArgumentNullException("encoding");
}
return EncryptByteArray(encoding.GetBytes(text));
}
public string DecryptString(byte[] encryptedString, Encoding encoding) {
byte[] decryptedRawString;
if (encryptedString == null) {
throw new ArgumentNullException("encryptedString");
}
if (encoding == null) {
throw new ArgumentNullException("encoding");
}
decryptedRawString = DecryptByteArray(encryptedString);
return encoding.GetString(decryptedRawString);
}
public byte[] EncryptByteArray(byte[] data) {
CryptoStream cryptoStream;
MemoryStream ms;
if (data == null) {
throw new ArgumentNullException("data");
}
ms = new MemoryStream();
using (cryptoStream = new CryptoStream(ms, alg.CreateEncryptor(), CryptoStreamMode.Write)) {
cryptoStream.Write(data, 0, data.Length);
cryptoStream.FlushFinalBlock();
}
return ms.ToArray();
}
public byte[] DecryptByteArray(byte[] encryptedData) {
MemoryStream source, destination;
source = new MemoryStream(encryptedData, false);
destination = new MemoryStream();
DecryptStream(source, destination);
return destination.ToArray();
}
public void EncryptObjectToFile(string path, object obj) {
File.WriteAllBytes(path, EncryptObject(obj));
}
public byte[] EncryptObject(object obj) {
BinaryFormatter formatter;
CryptoStream cryptoStream;
MemoryStream ms;
if (obj == null) {
throw new ArgumentNullException("obj");
}
ms = new MemoryStream();
formatter = new BinaryFormatter();
using (cryptoStream = new CryptoStream(ms, alg.CreateEncryptor(), CryptoStreamMode.Write)) {
formatter.Serialize(cryptoStream, obj);
cryptoStream.FlushFinalBlock();
}
return ms.ToArray();
}
public object DecryptObjectFromFile(string path) {
return DecryptObject(File.ReadAllBytes(path));
}
public object DecryptObject(byte[] encryptedObj) {
BinaryFormatter formatter;
CryptoStream cryptoStream;
MemoryStream ms;
if (encryptedObj == null) {
throw new ArgumentNullException("encryptedObj");
}
ms = new MemoryStream(encryptedObj, false);
formatter = new BinaryFormatter();
using (cryptoStream = new CryptoStream(ms, alg.CreateDecryptor(), CryptoStreamMode.Read)) {
return formatter.Deserialize(cryptoStream);
}
}
public void EncryptFile(string source, string destination) {
Stream sourceStream, destinationStream;
sourceStream = null;
destinationStream = null;
try {
sourceStream = new FileStream(source, FileMode.Open, FileAccess.Read, FileShare.Read);
destinationStream = new FileStream(destination, FileMode.Create, FileAccess.Write, FileShare.Read);
EnryptStream(sourceStream, destinationStream);
} finally {
if (sourceStream != null) sourceStream.Close();
if (destinationStream != null) destinationStream.Close();
}
}
public void DecryptFile(string enryptedFile, string destination) {
Stream sourceStream, destinationStream;
sourceStream = null;
destinationStream = null;
try {
sourceStream = new FileStream(enryptedFile, FileMode.Open, FileAccess.Read, FileShare.Read);
destinationStream = new FileStream(destination, FileMode.Create, FileAccess.Write, FileShare.Read);
DecryptStream(sourceStream, destinationStream);
} finally {
if (sourceStream != null) sourceStream.Close();
if (destinationStream != null) destinationStream.Close();
}
}
public void EnryptStream(Stream source, Stream destination) {
CryptoStream cryptoStream;
byte[] buffer = new byte[4096];
int bytesRead;
using (cryptoStream = new CryptoStream(destination, alg.CreateEncryptor(), CryptoStreamMode.Write)) {
while ((bytesRead = source.Read(buffer, 0, buffer.Length)) > 0) {
cryptoStream.Write(buffer, 0, bytesRead);
}
cryptoStream.FlushFinalBlock();
}
}
public void DecryptStream(Stream source, Stream destination) {
CryptoStream cryptoStream;
byte[] buffer = new byte[4096];
int bytesRead;
using (cryptoStream = new CryptoStream(source, alg.CreateDecryptor(), CryptoStreamMode.Read)) {
while ((bytesRead = cryptoStream.Read(buffer, 0, buffer.Length)) > 0) {
destination.Write(buffer, 0, bytesRead);
}
}
}
public static byte[] HexStringToByteArray(string s) {
return HexStringToByteArray(s, " ", "-", ":");
}
public static byte[] HexStringToByteArray(string s, params string[] separator) {
string[] parts = s.Split(separator, StringSplitOptions.RemoveEmptyEntries);
byte[] val = new byte[parts.Length];
for(int i = 0; i < parts.Length; i++) {
val[i] = Convert.ToByte(parts[i], 16);
}
return val;
}
public static string ByteArrayToHexString(byte[] val) {
return ByteArrayToHexString(val, "-");
}
public static string ByteArrayToHexString(byte[] val, string separator) {
StringBuilder sBuild = new StringBuilder();
for (int i = 0; i < val.Length; i++) {
sBuild.AppendFormat("{0:X2}", val[i]);
if (i < val.Length - 1) {
sBuild.Append(separator);
}
}
return sBuild.ToString();
}
}
Die einzig Sinnvolle Methode ist das byte[] in einen Hex-String umzuwandeln.
z.B.:=>CryptIt
Hmm, einfach mehrere FileAppender in der App.config definieren.
Also komplette Pfadangaben sollten eigentlich funktionieren. Versuch mal den Pfad unter Anführungszeichen(/infile:"C:\bla...") anzugeben.
Das als Komponente umzuschreiben habe ich mir auch schon überlegt. Werde ich demnächst mal machen. Eventuell auch mit mehr Kommentaren.
Bezüglich doppelt verschlüsseln:
3DES arbeitet so, allerdings mit verschiedenen Schlüsseln und jeweils verschlüsseln/entschlüsseln/verschlüsseln.
Ich denke nicht, dass doppelt verschlüsseln generell sicherer ist, dafür allerdings wesentlich aufwendiger(Rechenzeit).
Welchen Modestring verwendest du zum verschlüsseln in PHP? Versuch mal "CBC".
Entweder ist der Key/IV ein anderer(falsche Umwandlung), oder Die Einstellungen(z.B.: Mode passt nicht).
Leider finde ich unter MCRYPT_RIJNDAEL keinen Eintrag...
Mir war gerade langweilig...
=>CryptIt
Da des öfteren Fragen zu Verschlüsselung und C# gestellt werden, habe ich mich entschlossen mal ein kleines Kommandozeilen Tool - CryptIt - zu schreiben.
CryptIt soll zeigen, wie man beliebige Dateien verschlüsseln und auch wieder entschlüsseln kann.
Der Großteil des Sourcecodes beschäftigt sich mit Kommandozeilenargumente Parsen und kann getrost übersprungen werden.
Einfach mal
CryptIt /help
eingeben um eine Liste aller Optionen anzuzeigen.
Zum verschlüsseln einer Datei
CryptIt /mode:Encrypt /IVFile:myIVFile /KeyFile:myKeyFile /inFile:myFile.txt /outFile:myFile.secret
eingeben und zum entschlüsseln
CryptIt /mode:Decrypt /IVFile:myIVFile /KeyFile:myKeyFile /inFile:myFile.secret
using System;
using System.Text;
using System.IO;
using System.Security.Cryptography;
public class CryptIt {
public enum Mode {
Encrypt,
Decrypt,
GenerateIV,
GenerateKey
}
private static string inFile;
private static string outFile;
private static string algorithmName = "RijnDael";
private static CipherMode cipherMode = CipherMode.CBC;
private static PaddingMode paddingMode = PaddingMode.PKCS7;
private static int blockSize = -1;
private static int keySize = -1;
private static byte[] iv;
private static byte[] key;
private static Mode mode = Mode.Encrypt;
private static bool showHelp;
public static void Main(string[] args) {
try {
ParseArgs(args);
if (showHelp) {
PrintUsage();
return;
}
switch (mode) {
case Mode.Encrypt:
Encrypt();
break;
case Mode.Decrypt:
Decrypt();
break;
case Mode.GenerateIV:
Console.WriteLine(ByteArrayToHexString(GenerateIV()));
break;
case Mode.GenerateKey:
Console.WriteLine(ByteArrayToHexString(GenerateKey()));
break;
}
} catch (Exception e) {
Console.Error.WriteLine("An exception occurred. {0}", e.Message);
Console.Error.WriteLine("Write CryptIt /help for more information.");
Environment.Exit(1);
}
}
private static byte[] GenerateIV() {
byte[] retVal;
SymmetricAlgorithm alg;
alg = CreateAndInitCipher();
alg.GenerateIV();
retVal = alg.IV;
alg.Clear();
return retVal;
}
private static byte[] GenerateKey() {
byte[] retVal;
SymmetricAlgorithm alg;
alg = CreateAndInitCipher();
alg.GenerateKey();
retVal = alg.Key;
alg.Clear();
return retVal;
}
private static void Encrypt() {
SymmetricAlgorithm alg;
Stream inStream = null;
Stream outStream = null;
CryptoStream cryptoStream = null;
byte[] buffer = new byte[4096];
int bytesRead;
alg = CreateAndInitCipher();
if (iv == null) {
Console.WriteLine("IV: {0}", ByteArrayToHexString(alg.IV));
}
if (key == null) {
Console.WriteLine("Key: {0}", ByteArrayToHexString(alg.Key));
}
try {
// Open input stream
if (inFile == null) {
inStream = Console.OpenStandardInput();
} else {
inStream = new FileStream(inFile, FileMode.Open, FileAccess.Read, FileShare.Read);
}
// Open output stream
if (outFile == null) {
outStream = Console.OpenStandardOutput();
} else {
outStream = new FileStream(outFile, FileMode.Create, FileAccess.Write, FileShare.Read);
}
// Create crypto stream
cryptoStream = new CryptoStream(outStream, alg.CreateEncryptor(), CryptoStreamMode.Write);
// Encrypt bytes
while ((bytesRead = inStream.Read(buffer, 0, buffer.Length)) > 0) {
cryptoStream.Write(buffer, 0, bytesRead);
}
cryptoStream.FlushFinalBlock();
} finally {
if (inStream != null) inStream.Close();
if (cryptoStream != null) cryptoStream.Close();
if (outStream != null) outStream.Close();
alg.Clear();
}
}
private static void Decrypt() {
SymmetricAlgorithm alg;
Stream inStream = null;
Stream outStream = null;
CryptoStream cryptoStream = null;
byte[] buffer = new byte[4096];
int bytesRead;
alg = CreateAndInitCipher();
if (iv == null) {
throw new ApplicationException("Cannot decrypt because no IV set.");
}
if (key == null) {
throw new ApplicationException("Cannot decrypt because no Key set.");
}
try {
// Open input stream
if (inFile == null) {
inStream = Console.OpenStandardInput();
} else {
inStream = new FileStream(inFile, FileMode.Open, FileAccess.Read, FileShare.Read);
}
// Open output stream
if (outFile == null) {
outStream = Console.OpenStandardOutput();
} else {
outStream = new FileStream(outFile, FileMode.Create, FileAccess.Write, FileShare.Read);
}
// Create crypto stream
cryptoStream = new CryptoStream(inStream, alg.CreateDecryptor(), CryptoStreamMode.Read);
// Decrypt bytes
while ((bytesRead = cryptoStream.Read(buffer, 0, buffer.Length)) > 0) {
outStream.Write(buffer, 0, bytesRead);
}
} finally {
if (cryptoStream != null) cryptoStream.Close();
if (inStream != null) inStream.Close();
if (outStream != null) outStream.Close();
alg.Clear();
}
}
private static void PrintUsage() {
Console.WriteLine("CryptIt");
Console.WriteLine();
Console.WriteLine(" CryptIt options");
Console.WriteLine();
Console.WriteLine("/help Shows this message");
Console.WriteLine("/mode:Encrypt Encrypts a file (default)");
Console.WriteLine("/mode:Decrypt Decrypts a file");
Console.WriteLine("/mode:GenerateIV Generates an IV.");
Console.WriteLine("/mode:GenerateKey Generates a secret key.");
Console.WriteLine("/infile:<file> Specify input file name; stdin if omitted");
Console.WriteLine("/outfile:<file> Specify output file name; stdout if omitted");
Console.WriteLine("/algorithm:RijnDael AES used as cipher (default)");
Console.WriteLine("/algorithm:DES DES used as cipher");
Console.WriteLine("/algorithm:TripleDES TripleDES used as cipher");
Console.WriteLine("/algorithm:RC2 RC2 used as cipher");
Console.WriteLine("/ciphermode:CBC Cipher Block Chaining mode used (default)");
Console.WriteLine("/ciphermode:CFB Cipher Feedback mode used");
Console.WriteLine("/ciphermode:CTS Cipher Text Stealing mode used");
Console.WriteLine("/ciphermode:ECB Electronic Codebook mode used");
Console.WriteLine("/ciphermode:thumbsup:FB Output Feedback mode used");
Console.WriteLine("/paddingmode:ANSIX923 The ANSIX923 padding string consists of a sequence of bytes filled with zeros before the length");
Console.WriteLine("/paddingmode:ISO10126 The ISO10126 padding string consists of random data before the length");
Console.WriteLine("/paddingmode:None No padding is done");
Console.WriteLine("/paddingmode:PKCS7 The PKCS #7 padding string consists of a sequence of bytes, each of which is equal to the total number of padding bytes added (default)");
Console.WriteLine("/paddingmode:Zeros The padding string consists of bytes set to zero");
Console.WriteLine("/iv:<string> The initialization vector as a hex string; valid delimeter characters are ' ', ':', '-'");
Console.WriteLine("/ivfile:<file> Specify initialization vector file name used to load IV");
Console.WriteLine("/key:<string> The secret key as a hex string; valid delimeter characters are ' ', ':', '-'");
Console.WriteLine("/keyfile:<file> Specify key file name used to load secret key");
Console.WriteLine("/keysize:<size> The size, in bits, of the secret key");
Console.WriteLine("/blocksize:<size> The block size, in bits");
}
private static void ParseArgs(string[] args) {
foreach (string s in args) {
if (String.Equals(s, "/help", StringComparison.CurrentCultureIgnoreCase)) {
showHelp = true;
return;
}
// Split into '/<command>' and 'value'
string[] parts = s.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
if (parts.Length != 2) {
string msg = String.Format("Could not parse command line at '{0}'.", s);
throw new ApplicationException(msg);
}
switch (parts[0].ToLower()) {
case "/infile":
inFile = parts[1];
break;
case "/outfile":
outFile = parts[1];
break;
case "/algorithm":
algorithmName = parts[1];
break;
case "/ciphermode":
cipherMode = (CipherMode)Enum.Parse(typeof(CipherMode), parts[1], true);
break;
case "/paddingmode":
paddingMode = (PaddingMode)Enum.Parse(typeof(PaddingMode), parts[1], true);
break;
case "/iv":
iv = HexStringToByteArray(parts[1]);
break;
case "/ivfile":
iv = HexStringToByteArray(File.ReadAllText(parts[1]).Trim());
break;
case "/key":
key = HexStringToByteArray(parts[1]);
break;
case "/keyfile":
key = HexStringToByteArray(File.ReadAllText(parts[1]).Trim());
break;
case "/keysize":
keySize = Int32.Parse(parts[1]);
break;
case "/blocksize":
blockSize = Int32.Parse(parts[1]);
break;
case "/mode":
mode = (Mode)Enum.Parse(typeof(Mode), parts[1], true);
break;
default:
string msg = String.Format("'{0}' - unknown command.", s);
throw new ApplicationException(msg);
}
}
}
private static byte[] HexStringToByteArray(string s) {
string[] parts = s.Split(new char[] { ' ', ':', '-' }, StringSplitOptions.RemoveEmptyEntries);
byte[] val = new byte[parts.Length];
for(int i = 0; i < parts.Length; i++) {
val[i] = Convert.ToByte(parts[i], 16);
}
return val;
}
private static string ByteArrayToHexString(byte[] val) {
StringBuilder sBuild = new StringBuilder();
for (int i = 0; i < val.Length; i++) {
sBuild.AppendFormat("{0:X2}", val[i]);
if (i < val.Length - 1) {
sBuild.Append('-');
}
}
return sBuild.ToString();
}
private static SymmetricAlgorithm CreateAndInitCipher() {
SymmetricAlgorithm alg;
alg = SymmetricAlgorithm.Create(algorithmName);
alg.Mode = cipherMode;
alg.Padding = paddingMode;
if (keySize != -1) {
// Use user defined key size
alg.KeySize = keySize;
}
if (blockSize != -1) {
// Use user defined block size
alg.BlockSize = blockSize;
}
if (iv != null) {
// user entered an IV
alg.IV = iv;
} else {
alg.GenerateIV();
}
if (key != null) {
// user entered a secret key
alg.Key= key;
} else {
alg.GenerateKey();
}
return alg;
}
}
Werden die Plugins beim FF nicht in JavaScript + XUL entwickelt?
=> SetSystemTime
Über WMI wird es auch irgendwie gehen.
foreach (byte b in hash) {
stringBuilder.AppendFormat("{0:X2} ", b);
}
Du wirst deinen Hash wohl in einen Hex-String umwandeln müssen.
Du kannst als Rückgabewert einen IntPtr angeben und dir die einzelnen Strings per Marshal.PtrToString holen.
Hallo herbivore!
Das einzig Sinnvolle was mir zu char** einfällt ist entweder ein Pointer auf ein char* um z.B.: eine Stringvariable zu ändern(ref in C#) oder eben ein Array von Strings.
Aber natürlich könnte sich der Programmierer dieser Funktion dabei auch etwas Anderes gedacht haben...
lg
habe ich mir zuerst auch gedacht, aber Burgpflanze sagte ja "zurückgibt".
Darum vermute ich mal string[].
Falls es aber ein Parameter ist, könnte es sowohl ref StringBuilder sein als auch string[].
Stream.Read in einer Schleife aufrufen.
Sieht mir nach TypeConverter aus.
Einfacher geht es wenn du deine Liste serialisierst(z.B.:BinaryFormater)
Naja, du ließt ja die Datei komplett in den Hauptspeicher ein(StreamReader.ReadToEnd) und verschlüsselst sie dann.
=>Immer nur eine gewisse Größe einlesen, am Besten ein Vielfaches der Blockgröße von AES. Dann verschlüsseln und gleich in die Datei schreiben. Ausserdem solltest du mit byte[] und nicht mit strings arbeiten. Sonst gibts unerklärliche Fehler und du kannst dadurch auch binäre Dateien verschlüsseln.
Hallo Rainbird!
Danke für die Antwort. Gibt es auch eine Möglichkeit nur eine Konfigurationsdatei zu verwenden?
lg
Schau dir mal den Konstruktor der UTF8Encoding-Klasse an. Dort kannst du angeben, ob die BOM geschrieben werden soll.
.Net bietet hier schon einige Möglichkeiten.
Such mal nach Lokalisierung/Ressourcen.
Hallo!
Ich habe eine Serverapplikation die mit ihren (lokalen) Clients über Remoting kommuniziert. Diese Serverapplikation lädt dynamisch Erweiterungen in eine zweite AppDomain. Diese Plugins können ebenfalls mit den Clients über Remoting kommunizieren.
Damit das klappt muss soweit ich das Verstanden habe in beiden AppDomains ein ServerChannel vorhanden sein. Bisher habe ich das Remotingframework für die Default-AppDomain über die AppConfig konfiguriert. Doch wie kann ich das Framework für die zweite AppDomain möglichst über die AppConfig konfigurieren?
Einen Syntaxbaum braucht man auch nur, wenn man einen Mehrpass-Compiler erzeugen will. Ansonsten kann man die Daten auch on-the-fly verarbeiten.
Und da es sich hier um einen Konsolen-Output-Parser handelt, bezweifle ich dass ein AST vonnöten ist.
Coco/R gibt es auch für .net inklusive Sourcen. Somit kannst du diesen Compiler Generator leicht in dein Projekt einbinden.
Oder du erzeugst dir eine...
=>AllocConsole