Install-Package Murphy.ByteString -Version
dotnet add package Murphy.ByteString --version
<PackageReference Include="Murphy.ByteString" Version="" />
For projects that support PackageReference, copy this XML node into the project file to reference the package.
paket add Murphy.ByteString --version
The NuGet Team does not provide support for this client. Please contact its maintainers for support.
#r "nuget: Murphy.ByteString,"
#r directive can be used in F# Interactive, C# scripting and .NET Interactive. Copy this into the interactive tool or source code of the script to reference the package.
// Install Murphy.ByteString as a Cake Addin
#addin nuget:?package=Murphy.ByteString&version=

// Install Murphy.ByteString as a Cake Tool
#tool nuget:?package=Murphy.ByteString&version=
The NuGet Team does not provide support for this client. Please contact its maintainers for support.

ByteString is a small utility library that provides a conceptually immutable byte string type with many convenient operations.


You can install ByteString via NuGet.

To build ByteString from source you will need an F# 3.1 compiler (or newer) and a .NET development environment. The .sln and .fsproj files in the source directories should be understood by .NET Core command line tools, MSBuild or IDEs such as VSCode, VisualStudio, or Rider.


ByteString is a library. Its central class is Murphy.ByteString.ByteString, which behaves a lot like System.String, only it contains bytes rather than unicode code points. Like with simple byte arrays, the contents of a byte string may be addressed by index, but they are thought to be immutable and a byte string can be used as a key for hashed or sorted collections, for example.

Here are some usage examples for the library:

#r "nuget: Murphy.ByteString, 3.1.0"
open System
open Murphy.ByteString

// Create from the UTF-8 representation of a string (any encoding is supported):
let b = ByteString.FromString("Hello world!\tHow are you?")

// Derive keys from a password:
let k, k' =
  use kdf = new Security.Cryptography.Rfc2898DeriveBytes("password", "salty stuff"B)

// Compare contents lexicographically:
printfn "k < b:  %b" <| (k < b)
printfn "k = k': %b" <| (k = k')

// Perform bitwise operations:
printfn "XOR(k, k'): %s" <| (k ^^^ k').ToHexadecimal()
printfn "Number of different bits (k, k'): %d" <| (k --- k')

// Compute cryptographic checksums:
printfn "Message digest: %s" <| b.GetHash("SHA256").ToHexadecimal()
printfn "HMAC          : %s" <| b.GetHmac("HMACSHA256", k).ToHexadecimal()

// Encrypt and authenticate data using best practices:
let box = b.BoxWith("AES/HMACSHA256", k)

// Interact with streams:
  use s = IO.File.Create("box.dat")

// Or use even simpler convenience methods for files:
IO.File.ReadAllByteString("box.dat") = box
|> printfn "Still the same data? %b"

// Decrypt and authenticate data:
box.UnboxWith("AES/HMACSHA256", k)
|> printfn "Decrypted: %s"

// But not with the wrong key, of course:
match box.TryUnboxWith("AES/HMACSHA256", k') with
| Some b -> printfn "Decrypted even with the wrong key: %O" b
| None   -> printfn "Wrong key detected!"

// Format and interpret data in various ways:
b.ToEscaped():                       "{0}"B
b.ToBase64():                         {0:B}
k.ToHexadecimal().ToLower():          {1:x}
k.ToHexadecimal().ToUpper():          {1:X}
k.ToSpeak64():                        {1:S}
k.ToBigInteger(littleEndian = false): {1:D}
k.ToBigInteger(littleEndian = true):  {1:d}
""", b, k)

// Clear sensitive data

A variety of conversion operations, binary operators and standard interfaces are provided for byte strings. None of these modify the data represented by the instances they operate on.

However, the byte string type encapsulates a byte array and for efficiency, a few operations allow access to this raw array. These operations are marked with "unsafe" in their names and should be used with care.

Extra Modules


If you use

<PackageReference Include="Murphy.ByteString" Version="3.1.0" />
<PackageReference Include="" Version="3.7.5" />

in your project, you may add

<Compile Include="$(ByteStringExtra)\ByteStringIce.fs" />

to get convenience methods for serialization / deserialization of Ice objects to / from byte strings.


If you use

<PackageReference Include="Murphy.ByteString" Version="3.1.0" />
<PackageReference Include="Rebex.Elliptic.Curve25519" Version="1.2.1" />

in your project, you may add

<Compile Include="$(ByteStringExtra)\ByteStringCurve25519.fs" />

to get a convenience method for key agreement using byte strings as key blobs.

NuGet packages

This package is not used by any NuGet packages.

GitHub repositories

This package is not used by any popular GitHub repositories.

Version Downloads Last updated 79 2/16/2021
3.0.0 594 4/11/2018
2.1.0 616 3/30/2018
2.0.0 465 3/22/2018