F #: conversione di una stringa in una serie di byte

Question

Sto scrivendo un semplice programma di crittografia/decrittografia rc4 come primo progetto. Sono bloccato nel tentativo di convertire la stringa data in una matrice di byte che può quindi essere manipolata dall'algoritmo di base. Come si converte una stringa in una matrice di byte in f # funzionale?

//From another thread 
let private replace find (repl : string) (str : string) = str.Replace(find, repl) 

//let private algorithm bytes = blah blah blah 

let Encrypt (decrypted : string) = 
    decrypted.Chars 
    |> Array.map(fun c -> byte.Parse(c)) // This line is clearly not working 
    // |> algorithm 
    |> BitConverter.ToString 
    |> replace "-" "" 

FYI in C# Assomiglia:

public static string Encrypt(string decrypted) 
    { 
     byte[] bytes = new byte[decrypted.Length]; 

     for (int i = 0; i < decrypted.Length; ++i) 
      bytes[i] = (byte)decrypted[i]; 

     Algorithm(ref bytes); 

     return BitConverter.ToString(bytes).Replace("-", "").ToLower(); 
    } 

Answer 1

Anche se si potrebbe scrivere la propria funzione per fare il lavoro, è meglio attaccare con i metodi .NET built-in:

stringa di byte:

System.Text.Encoding.ASCII.GetBytes("hello world!") 

byte a stringa:

System.Text.Encoding.ASCII.GetString([|104uy; 101uy; 108uy; 108uy; 
      111uy; 32uy; 119uy; 111uy; 114uy; 108uy; 100uy; 33uy|]) 

Answer 2

si potrebbe fare una traduzione diretta

let Encrypt(decrypted : string) = 
    let bytes = Array.init decrypted.Length (fun i -> byte decrypted.[i]) 
    Algorithm(ref bytes) 
    BitConverter.ToString(bytes).Replace("-", "").ToLower() 

Answer 3

come da richiesta del Gradbot, il codice finale assomiglia a:

1) Non mi piace il cast al byte

2) La funzione dell'algoritmo principale sembra molto non funzionante

Le critiche costruttive sono benvenute.

Rc4.fs

#light 

open System 
open MiscUtils 
open StringUtils 

let private key = "Mykey"B 
let private byteMask = 0xff 
let private byteMax = byteMask 

let private algorithm (bytes : byte[]) = 
    let mutable j = 0 
    let mutable i = 0 
    let mutable s = [| for c in 0 .. byteMax -> (byte) c |] 

    for i in 0 .. byteMax do 
     j <- (j + (int) (s.[i] + key.[i % key.GetLength(0)])) &&& byteMask 
     Swap (&s.[i]) (&s.[j]) 

    i <- 0 
    j <- 0 
    for x in 0 .. bytes.Length - 1 do 
     i <- (i + 1) &&& byteMask 
     j <- (j + (int) s.[i]) &&& byteMask 
     Swap (&s.[i]) (&s.[j]) 
     let mutable t = (int)(s.[i] + s.[j]) &&& byteMask 
     bytes.[x] <- bytes.[x] ^^^ s.[t] 

    bytes 

let Encrypt (decrypted : string) = 
    Text.Encoding.ASCII.GetBytes decrypted 
    |> algorithm 
    |> BitConverter.ToString 
    |> ToLower 
    |> Replace "-" "" 

let Decrypt (encrypted : string) = 
    [| for i in 0 .. 2 .. encrypted.Length - 1 -> Convert.ToByte(encrypted.Substring(i, 2), 16) |] 
    |> algorithm 
    |> System.Text.Encoding.ASCII.GetString 

StringUtils.Fs

#light 

let Replace find (repl : string) (str : string) = str.Replace(find, repl) 
let ToLower (str : string) = str.ToLower() 

MiscUtils.fs

#light 

let Swap (left : 'a byref) (right : 'a byref) = 
    let temp = left 
    left <- right 
    right <- temp