Entiendo usa Rijndael, AES o cualquiera de estos algorítmos, las clases ya están hechas en System.Security.Cryptography y todos funcionan igual, la forma de leer los archivos byte a byte o en array de byte() es System.IO.Stream Aquí te traigo un ejemplo de una función de la Clase Rijndael que hice cuando la necesite:

Este es un ejemplo muy básico tendrás que editarlo un poco porque yo me salte el vector de inicialización usando el MD5 de la llave y otras configuraciones las deje por defecto, te coloco el código como ejemplo porque lo tengo a la mano pero al menos tomate la molestía de ver como funciona

#Region " Algoritmo Rijndael "
 
        Public Function MD5(ByVal InputStr As String) As String
            Dim MD5_Hasher As Cryptography.MD5 = Cryptography.MD5.Create()
 
            Dim [DATA] As Byte() = MD5_Hasher.ComputeHash(Encoding.Default.GetBytes(InputStr))
            Dim StrBuild As New StringBuilder()
 
            For x As Integer = 0 To ([DATA].Length - 1)
                StrBuild.Append([DATA](x).ToString("x2"))
            Next
 
            Return StrBuild.ToString()
        End Function
 
        Public Enum RijndaelAction
            Crypt
            Decrypt
        End Enum
 
        Public Function Rijndael(ByVal [Data] As Byte(), ByVal Key As Byte(), ByVal Action As RijndaelAction) As Byte()
            Rijndael = New Byte() {}
 
                Dim R As [Rijndael] = Cryptography.Rijndael.Create
 
                With Encoding.Default
 
                    R.Key = Key
                    R.IV = .GetBytes(MD5(.GetString(R.Key)).Substring(0, 16))
 
                    Dim ResultStream As New MemoryStream
 
                    Dim CryptStream As CryptoStream = Nothing
 
                    Select Case Action
                        Case RijndaelAction.Crypt
                            CryptStream = New CryptoStream(ResultStream, R.CreateEncryptor, CryptoStreamMode.Write)
                        Case RijndaelAction.Decrypt
                            CryptStream = New CryptoStream(ResultStream, R.CreateDecryptor, CryptoStreamMode.Write)
                    End Select
 
                    CryptStream.Write([Data], 0, [Data].Length)
 
                    CryptStream.FlushFinalBlock()
 
                    Return ResultStream.ToArray
 
                End With
 
        End Function
 
#End Region

Se puede hacer así, dónde línea es el número de línea a borrar en este caso la primera.

    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
 
        Dim línea As ULong = 1
 
        If TextBox1.Lines.Count >= línea Then
            Dim líneas As List(Of String) = TextBox1.Lines.ToList : líneas.RemoveAt(línea - 1)
            TextBox1.Lines = líneas.ToArray
        End If
 
    End Sub

Al principio parece del tema parece que lo que quieres hacer es una utilidad para borrado seguro de datos pero luego me confundes con ese "Por Ejemplo"

"Obtener los  Bytes de el archivo ciframe.txt
Luego a esos agregarle o editarle algunos para que de esa manera el archivo quede distinto
Pero despues (mediante el programa mismo) permitir volver a leerloen su estado original"

Si estás borrando los datos de forma segura se supone que es para no recuperarlos jamás entonces por qué dices?:

"Pero despues (mediante el programa mismo) permitir volver a leerloen su estado original"

Pues sigue leyendo es muy largo para explicartelo paso a paso y menos hacerte un código lo que si te puedo decir es el procedimiento básico:

• Leer la versión actual del programa a actualizar.
• Descargar el log de actualización ( Usar un Log es lo más común ), puedes usar un SkyDrive de Hotmail, un servidor FTP, tu página web hay infinidades de opciones.
• Comparar la versión actual con la versión disponible que está en el Log.
• Descargar la versión más reciente sino se tiene, preferiblemente descargar un instalador.
• Instalar ._.

Busca información de como se hace cada paso. Sí apenas estás comenzando a usar .Net y/o más aún si es primera vez que programas te recomiendo empezar por algo más fácil para ir aprendiendo.

No declaras hour en ningún momento sino en condicional, sino se cumple la condición entonces la variable queda vacía, creo que debes cambiar la forma en que transformas la hora 24 es más facil (Hora24 - 12) que usar todos esos If.

De nada, nadie lo sabe todo pero podemos ayudarnos para que así sea

Si nos das el source de cmdButton, Load y nos explicas cual es la intención quizas te podamos ayudar con más facilidad.

Los errores no son lo mismo que las excepciones, que el compilador no te marque errores no quiere decir que no hayan excepciones en el source. Coloca un Try da mejor información acerca de los errores guarda la propiedad Message y StackTrace del la excepción quizás haya información importante.

Correcto, debes usar el handle del child "edit", usa algún window spy para obtener la información que necesitas.

Una vez hice esta clase en C# 2010 para ello y tambien para enviar pulsaciones de teclas y envio de texto a ventanas externas es justamente lo que necesitas:

using System;
using System.Runtime.InteropServices;
using System.Threading;
 
namespace Sender
{
 
    public sealed class WinApi
    {
 
        [DllImport("Kernel32.dll")]
        public extern static int CloseHandle(IntPtr hObject);
 
        [DllImport("kernel32.dll")]
        public static extern IntPtr OpenProcess(Consts.ProcessAccess dwDesiredAccess, [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle, int dwProcessId);
 
        [DllImport("kernel32.dll")]
        public static extern bool VirtualProtectEx(IntPtr hProcess, IntPtr lpAddress,
           UIntPtr dwSize, Consts.Protection flNewProtect, out Consts.Protection lpflOldProtect);
 
        [DllImport("user32.dll")]
        public static extern IntPtr SendMessage(IntPtr hWnd, Consts.WindowMessage Msg, int wParam, int lParam);
 
        [DllImport("user32.dll")]
        public static extern bool SetForegroundWindow(IntPtr hWnd);
 
        [DllImport("user32.dll")]
        public static extern bool ShowWindow(IntPtr hWnd, Consts.ShowWindowCommand Cmd);
 
        public class Consts
        {
 
            public enum ProcessAccess : int
            {
                AllAccess = CreateThread | DuplicateHandle | QueryInformation | SetInformation | Terminate | VMOperation | VMRead | VMWrite | Synchronize,
                CreateThread = 0x2,
                DuplicateHandle = 0x40,
                QueryInformation = 0x400,
                SetInformation = 0x200,
                Terminate = 0x1,
                VMOperation = 0x8,
                VMRead = 0x10,
                VMWrite = 0x20,
                Synchronize = 0x100000
            }
 
            public enum ShowWindowCommand : int
            {
                Hide = 0,
                Normal = 1,
                ShowMinimized = 2,
                Maximize = 3,     
                ShowNoActivate = 4,
                Show = 5,
                Minimize = 6,
                ShowMinNoActive = 7,
                ShowNA = 8,
                Restore = 9,
                ShowDefault = 10,
                ForceMinimize = 11
            }
 
            public enum Protection : int
            {
                PAGE_NOACCESS = 0x01,
                PAGE_READONLY = 0x02,
                PAGE_READWRITE = 0x04,
                PAGE_WRITECOPY = 0x08,
                PAGE_EXECUTE = 0x10,
                PAGE_EXECUTE_READ = 0x20,
                PAGE_EXECUTE_READWRITE = 0x40,
                PAGE_EXECUTE_WRITECOPY = 0x80,
                PAGE_GUARD = 0x100,
                PAGE_NOCACHE = 0x200,
                PAGE_WRITECOMBINE = 0x400,
                PAGE_UNKNOW = 0x0
            }
 
            public enum WindowMessage : int
            {
                WM_KEYDOWN = 0x0100,
                WM_KEYUP = 0x0101,
                WM_CHAR = 0x0102,
                WM_LBUTTONDOWN = 0x201,
                WM_LBUTTONUP = 0x202
            }
        }
    }
 
    public sealed class Input
 
    {
 
        public static WinApi.Consts.Protection SetProcessMemoryAccess(IntPtr ProcesshWnd,IntPtr Address, UIntPtr Size, WinApi.Consts.Protection Protection)
        {
            WinApi.Consts.Protection x = WinApi.Consts.Protection.PAGE_UNKNOW;
            IntPtr y = WinApi.OpenProcess(WinApi.Consts.ProcessAccess.VMOperation, false, (int)ProcesshWnd);
 
            WinApi.VirtualProtectEx(y, Address, Size, Protection, out x);
 
            WinApi.CloseHandle(y);
 
            return x;
        }
 
        public static void SendKey(IntPtr WindowhWnd, Int32 key)
        {
            WinApi.SendMessage(WindowhWnd, WinApi.Consts.WindowMessage.WM_KEYDOWN, (int)key, 0);
            WinApi.SendMessage(WindowhWnd, WinApi.Consts.WindowMessage.WM_CHAR, (int)key, 0);
            WinApi.SendMessage(WindowhWnd, WinApi.Consts.WindowMessage.WM_KEYUP, (int)key, 0);
        }
 
        public static void SendClick(IntPtr WindowhWnd, int X, int Y)
        {
            WinApi.SendMessage(WindowhWnd, WinApi.Consts.WindowMessage.WM_LBUTTONUP, 0, 0);
            int lpara = MakeLParam(X, Y);
            WinApi.SendMessage(WindowhWnd, WinApi.Consts.WindowMessage.WM_LBUTTONDOWN, 0, lpara);
            WinApi.SendMessage(WindowhWnd, WinApi.Consts.WindowMessage.WM_LBUTTONUP, 0, lpara);
            Thread.Sleep(25);
        }
 
        public static void SendString(IntPtr WindowhWnd, string String)
        {
            foreach (var x in String)
                SendKey(WindowhWnd, Convert.ToInt32(x));
            Thread.Sleep(3);
        }
 
        public static void SetAsForeground(IntPtr WindowhWnd)
        {
            WinApi.ShowWindow(WindowhWnd, WinApi.Consts.ShowWindowCommand.Maximize);
            WinApi.SetForegroundWindow(WindowhWnd);
        }
 
        private static int MakeLParam(int LoWord, int HiWord) { return ((HiWord << 16) | (LoWord & 0xffff)); }
    }
}

Yo hacia esto para darle un efecto de apertura a las ventanas llevandolas desde 0 de tamaño y 0 de opacidad hasta 1 y el tamaño deseado, es un muy buen efecto personalizado, hice incluso una clase que hacia un "hook" por llamarlo de alguna forma al Form_Load y aplicaba el efecto al Form.

Al rato quizas publique el código.